fix tarbomb with source tars

* implement window sharing

Co-authored-by: Mihai Fufezan <fufexan@protonmail.com>

.github/workflows/ci.yaml

@@ -41,7 +41,7 @@ jobs:
           cp ./LICENSE hyprland/
           cp build/Hyprland hyprland/
           cp hyprctl/hyprctl hyprland/
-          cp subprojects/wlroots/build/libwlroots.so.11032 hyprland/
+          cp subprojects/wlroots/build/libwlroots.so.12032 hyprland/
           cp build/Hyprland hyprland/
           cp -r example/ hyprland/
           cp -r assets/ hyprland/
@@ -62,7 +62,7 @@ jobs:
         run: |
           sed -i 's/SigLevel    = Required DatabaseOptional/SigLevel    = Optional TrustAll/' /etc/pacman.conf
           pacman --noconfirm --noprogressbar -Syyu
-          pacman --noconfirm --noprogressbar -Sy glslang libepoxy libfontenc libxcvt libxfont2 libxkbfile vulkan-headers vulkan-validation-layers xcb-util-errors xcb-util-renderutil xcb-util-wm xorg-fonts-encodings xorg-server-common xorg-setxkbmap xorg-xkbcomp xorg-xwayland git go clang lld libc++ pkgconf meson ninja wayland wayland-protocols libinput libxkbcommon pixman glm libdrm libglvnd cairo pango systemd scdoc base-devel seatd
+          pacman --noconfirm --noprogressbar -Sy glslang libepoxy libfontenc libxcvt libxfont2 libxkbfile vulkan-headers vulkan-validation-layers git go clang lld libc++ pkgconf meson ninja wayland wayland-protocols libinput libxkbcommon pixman glm libdrm libglvnd cairo pango systemd scdoc base-devel seatd cmake 
       - name: Checkout Hyprland
         uses: actions/checkout@v3
         with:
@@ -73,13 +73,23 @@ jobs:
             -Ddefault_library=static
       - name: Compile
         run: ninja -C obj-x86_64-pc-linux-gnu
-#       - name: Compress artifacts
-#         run: |
-#           mkdir x86_64-pc-linux-gnu
-#           DESTDIR=$PWD/x86_64-pc-linux-gnu meson install -C obj-x86_64-pc-linux-gnu --tags runtime
-#           tar -cvf x86_64-pc-linux-gnu.tar.xz x86_64-pc-linux-gnu
-#       - name: Upload artifacts
-#         uses: actions/upload-artifact@v3
-#         with:
-#           name: Build artifacts (x86_64-pc-linux-gnu)
-#           path: x86_64-pc-linux-gnu.tar.xz
+
+  noxwayland:
+    name: "Build Hyprland in pure Wayland (Arch)"
+    runs-on: ubuntu-latest
+    container:
+      image: archlinux
+    steps:
+      - name: Download dependencies
+        run: |
+          sed -i 's/SigLevel    = Required DatabaseOptional/SigLevel    = Optional TrustAll/' /etc/pacman.conf
+          pacman --noconfirm --noprogressbar -Syyu
+          pacman --noconfirm --noprogressbar -Sy glslang libepoxy libfontenc libxcvt libxfont2 libxkbfile vulkan-headers vulkan-validation-layers git cmake go clang lld libc++ pkgconf meson ninja wayland wayland-protocols libinput libxkbcommon pixman glm libdrm libglvnd cairo pango systemd scdoc base-devel seatd
+      - name: Checkout Hyprland
+        uses: actions/checkout@v3
+        with:
+          submodules: true
+      - name: Configure
+        run: mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DNO_XWAYLAND:STRING=true -H./ -B./build -G Ninja 
+      - name: Compile
+        run: make config && make release

.github/workflows/nix-build.yaml

@@ -16,13 +16,13 @@ jobs:
       with:
         submodules: recursive
     - name: Install nix
-      uses: cachix/install-nix-action@v17
+      uses: cachix/install-nix-action@v18
       with:
-        install_url: https://releases.nixos.org/nix/nix-2.10.3/install
+        install_url: https://nixos.org/nix/install
         extra_nix_config: |
           auto-optimise-store = true
           experimental-features = nix-command flakes
-    - uses: cachix/cachix-action@v10
+    - uses: cachix/cachix-action@v12
       with:
         name: hyprland
         authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'

.github/workflows/nix-update.yaml

@@ -9,9 +9,9 @@ jobs:
     - name: Clone repository
       uses: actions/checkout@v3
     - name: Install nix
-      uses: cachix/install-nix-action@v17
+      uses: cachix/install-nix-action@v18
       with:
-        install_url: https://releases.nixos.org/nix/nix-2.8.0/install
+        install_url: https://nixos.org/nix/install
         extra_nix_config: |
           auto-optimise-store = true
           experimental-features = nix-command flakes

.github/workflows/release.yaml

@@ -17,7 +17,7 @@ jobs:
 
       - name: Create tarball with submodules
         id: tar
-        run: tar -czv --owner=0 --group=0 --no-same-owner --no-same-permissions -f source.tar.gz *
+        run: mkdir hyprland-source; mv ./* ./hyprland-source; tar -czv --owner=0 --group=0 --no-same-owner --no-same-permissions -f source.tar.gz *
 
       - id: whatrelease
         name: Get latest release

.gitignore

@@ -25,3 +25,5 @@ hyprctl/hyprctl
 gmon.out
 *.out
 *.tar.gz
+
+PKGBUILD

.gitmodules

@@ -1,3 +1,6 @@
 [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

CMakeLists.txt

@@ -5,7 +5,7 @@ project(Hyprland
 
 set(CMAKE_MESSAGE_LOG_LEVEL "STATUS")
 
-message(STATUS "Configuring Hyprland!")
+message(STATUS "Gathering git info")
 
 # Get git info
 # hash and branch
@@ -22,27 +22,39 @@ execute_process(
     OUTPUT_STRIP_TRAILING_WHITESPACE)
 
 execute_process(
-    COMMAND bash -c "git show ${GIT_COMMIT_HASH} | head -n 5 | tail -n 1"
+    COMMAND sh -c "git show ${GIT_COMMIT_HASH} | head -n 5 | tail -n 1 | sed -s 's/#|\"//g'"
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
     OUTPUT_VARIABLE GIT_COMMIT_MESSAGE
     OUTPUT_STRIP_TRAILING_WHITESPACE)
 
 execute_process(
-    COMMAND bash -c "git diff-index --quiet HEAD -- || echo \"dirty\""
+    COMMAND sh -c "git diff-index --quiet HEAD -- || echo \"dirty\""
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
     OUTPUT_VARIABLE GIT_DIRTY
     OUTPUT_STRIP_TRAILING_WHITESPACE)
 #
 #
 
+IF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
+    message(STATUS "Configuring Hyprland in Debug with CMake")
+    add_definitions( -DHYPRLAND_DEBUG )
+ELSE()
+    add_compile_options( -O3 )
+    message(STATUS "Configuring Hyprland in Release with CMake")
+ENDIF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
+
 include_directories(. PRIVATE "subprojects/wlroots/include/")
 include_directories(. PRIVATE "subprojects/wlroots/build/include/")
-add_compile_options(-std=c++23 -DWLR_USE_UNSTABLE )
+set(CMAKE_CXX_STANDARD 23)
+add_compile_options(-DWLR_USE_UNSTABLE)
 add_compile_options(-Wall -Wextra -Wno-unused-parameter -Wno-unused-value -Wno-missing-field-initializers -Wno-narrowing)
+
+message(STATUS "Checking deps...")
+
 find_package(Threads REQUIRED)
 
 find_package(PkgConfig REQUIRED)
-pkg_check_modules(deps REQUIRED IMPORTED_TARGET wayland-server wayland-client wayland-cursor wayland-protocols cairo pango pangocairo libdrm egl xkbcommon libinput xcb) # we do not check for wlroots, as we provide it ourselves
+pkg_check_modules(deps REQUIRED IMPORTED_TARGET wayland-server wayland-client wayland-cursor wayland-protocols cairo pango pangocairo libdrm egl xkbcommon libinput) # we do not check for wlroots, as we provide it ourselves
 
 file(GLOB_RECURSE SRCFILES "src/*.cpp")
 
@@ -56,15 +68,11 @@ ENDIF(LEGACY_RENDERER MATCHES true)
 IF(NO_XWAYLAND MATCHES true)
     message(STATUS "Using the NO_XWAYLAND flag, disabling XWayland!")
     add_definitions( -DNO_XWAYLAND )
-ENDIF(NO_XWAYLAND MATCHES true)
-
-IF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
-    message(STATUS "Configuring Hyprland in Debug with CMake!")
-    add_definitions( -DHYPRLAND_DEBUG )
 ELSE()
-    add_compile_options( -O3 )
-    message(STATUS "Configuring Hyprland in Release with CMake!")
-ENDIF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
+    message(STATUS "XWAYLAND Enabled (NO_XWAYLAND not defined) checking deps...")
+    pkg_check_modules(xcbdep REQUIRED xcb)
+    target_link_libraries(Hyprland xcb)
+ENDIF(NO_XWAYLAND MATCHES true)
 
 target_compile_definitions(Hyprland PRIVATE "-DGIT_COMMIT_HASH=\"${GIT_COMMIT_HASH}\"")
 target_compile_definitions(Hyprland PRIVATE "-DGIT_BRANCH=\"${GIT_BRANCH}\"")
@@ -77,20 +85,25 @@ set(CPACK_PROJECT_NAME ${PROJECT_NAME})
 set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
 include(CPack)
 
+message(STATUS "Setting link libraries")
+
 target_link_libraries(Hyprland PkgConfig::deps)
 
 target_link_libraries(Hyprland
-        ${CMAKE_SOURCE_DIR}/subprojects/wlroots/build/libwlroots.so.11032 # wlroots is provided by us
+        ${CMAKE_SOURCE_DIR}/subprojects/wlroots/build/libwlroots.so.12032 # wlroots is provided by us
         pixman-1
         OpenGL
         GLESv2
         pthread
         ${CMAKE_THREAD_LIBS_INIT}
         ${CMAKE_SOURCE_DIR}/ext-workspace-unstable-v1-protocol.o
+        ${CMAKE_SOURCE_DIR}/hyprland-toplevel-export-v1-protocol.o
 )
 
 IF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
+    message(STATUS "Setting debug flags")
+
     SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pg -no-pie -fno-builtin")
     SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pg -no-pie -fno-builtin")
     SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pg -no-pie -fno-builtin")
-ENDIF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
+ENDIF(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)

Makefile

@@ -91,21 +91,41 @@ wlr-output-power-management-unstable-v1-protocol.c:
 
 wlr-output-power-management-unstable-v1-protocol.o: wlr-output-power-management-unstable-v1-protocol.h
 
+hyprland-toplevel-export-v1-protocol.h:
+	$(WAYLAND_SCANNER) server-header \
+		subprojects/hyprland-protocols/protocols/hyprland-toplevel-export-v1.xml $@
+
+hyprland-toplevel-export-v1-protocol.c:
+	$(WAYLAND_SCANNER) private-code \
+		subprojects/hyprland-protocols/protocols/hyprland-toplevel-export-v1.xml $@
+
+hyprland-toplevel-export-v1-protocol.o: hyprland-toplevel-export-v1-protocol.h
+
+linux-dmabuf-unstable-v1-protocol.h:
+	$(WAYLAND_SCANNER) server-header \
+		$(WAYLAND_PROTOCOLS)/unstable/linux-dmabuf/linux-dmabuf-unstable-v1.xml $@
+
+linux-dmabuf-unstable-v1-protocol.c:
+	$(WAYLAND_SCANNER) private-code \
+		$(WAYLAND_PROTOCOLS)/unstable/linux-dmabuf/linux-dmabuf-unstable-v1.xml $@
+
+linux-dmabuf-unstable-v1-protocol.o: linux-dmabuf-unstable-v1-protocol.h
+
 legacyrenderer:
 	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DLEGACY_RENDERER:STRING=true -H./ -B./build -G Ninja
-	cmake --build ./build --config Release --target all -j $(nproc)
+	cmake --build ./build --config Release --target all -j$(shell nproc)
 
 legacyrendererdebug:
 	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -DLEGACY_RENDERER:STRING=true -H./ -B./build -G Ninja
-	cmake --build ./build --config Release --target all -j $(nproc)
+	cmake --build ./build --config Release --target all -j$(shell nproc)
 
 release:
 	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -H./ -B./build -G Ninja
-	cmake --build ./build --config Release --target all -j $(nproc)
+	cmake --build ./build --config Release --target all -j$(shell nproc)
 
 debug:
 	mkdir -p build && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -H./ -B./build -G Ninja
-	cmake --build ./build --config Debug --target all -j $(nproc)
+	cmake --build ./build --config Debug --target all -j$(shell nproc)
 
 clear:
 	rm -rf build
@@ -114,14 +134,17 @@ clear:
 	rm -rf ./subprojects/wlroots/build
 
 all:
-	make config
+	make clear
+	make fixwlr
+	cd ./subprojects/wlroots && meson build/ --buildtype=release && ninja -C build/ && cp ./build/libwlroots.so.12032 /usr/lib/ && cd ../..
+	make protocols
 	make release
-	cd ./hyprctl && make all && cd ..
+	cd hyprctl && make all && cd ..
 
 install:
 	make clear
 	make fixwlr
-	cd ./subprojects/wlroots && meson build/ --buildtype=release && ninja -C build/ && cp ./build/libwlroots.so.11032 /usr/lib/ && cd ../..
+	cd ./subprojects/wlroots && meson build/ --buildtype=release && ninja -C build/ && cp ./build/libwlroots.so.12032 /usr/lib/ && cd ../..
 	make protocols
 	make release
 	cd hyprctl && make all && cd ..
@@ -137,11 +160,11 @@ install:
 	cp ./assets/wall_8K.png ${PREFIX}/share/hyprland
 
 	install -Dm644 -t ${PREFIX}/share/man/man1 ./docs/*.1
-	
+
 cleaninstall:
 	make clear
 	make fixwlr
-	cd ./subprojects/wlroots && meson build/ --buildtype=release && ninja -C build/ && cp ./build/libwlroots.so.11032 /usr/lib/ && cd ../..
+	cd ./subprojects/wlroots && meson build/ --buildtype=release && ninja -C build/ && cp ./build/libwlroots.so.12032 /usr/lib/ && cd ../..
 	make protocols
 	make release
 	cd hyprctl && make all && cd ..
@@ -161,15 +184,15 @@ uninstall:
 	rm -f ${PREFIX}/share/wayland-sessions/hyprland.desktop
 	rm -f ${PREFIX}/bin/Hyprland
 	rm -f ${PREFIX}/bin/hyprctl
-	rm -f /usr/lib/libwlroots.so.11032
+	rm -f /usr/lib/libwlroots.so.12032
 	rm -rf ${PREFIX}/share/hyprland
 	rm -f ${PREFIX}/share/man/man1/Hyprland.1
 	rm -f ${PREFIX}/share/man/man1/hyprctl.1
 
-protocols: xdg-shell-protocol.o wlr-layer-shell-unstable-v1-protocol.o wlr-screencopy-unstable-v1-protocol.o idle-protocol.o ext-workspace-unstable-v1-protocol.o pointer-constraints-unstable-v1-protocol.o tablet-unstable-v2-protocol.o wlr-output-power-management-unstable-v1-protocol.o
+protocols: xdg-shell-protocol.o wlr-layer-shell-unstable-v1-protocol.o wlr-screencopy-unstable-v1-protocol.o idle-protocol.o ext-workspace-unstable-v1-protocol.o pointer-constraints-unstable-v1-protocol.o tablet-unstable-v2-protocol.o wlr-output-power-management-unstable-v1-protocol.o linux-dmabuf-unstable-v1-protocol.o hyprland-toplevel-export-v1-protocol.o
 
 fixwlr:
-	sed -i -E 's/(soversion = 11)([^032]|$$)/soversion = 11032/g' subprojects/wlroots/meson.build
+	sed -i -E 's/(soversion = 12)([^032]|$$)/soversion = 12032/g' subprojects/wlroots/meson.build
 
 	rm -rf ./subprojects/wlroots/build
 
@@ -178,7 +201,7 @@ config:
 
 	make fixwlr
 
-	cd subprojects/wlroots && meson ./build --prefix=/usr --buildtype=release
+	cd subprojects/wlroots && meson ./build --prefix=/usr --buildtype=release -Dwerror=false -Dexamples=false
 	cd subprojects/wlroots && ninja -C build/
 
 	cd subprojects/wlroots && ninja -C build/ install

README.md

@@ -6,7 +6,6 @@
 
 ![Badge Workflow] 
 [![Badge License]][License] 
-![Badge Lines] 
 ![Badge Language] 
 [![Badge Pull Requests]][Pull Requests] 
 [![Badge Issues]][Issues] 
@@ -40,31 +39,28 @@ Hyprland is still in pretty early development compared to some other Wayland com
 
 Although Hyprland is pretty stable, it may have some bugs.
 
-### Help Wanted
-
-Hyprland needs testers! <br/>
-Try it out and report bugs / suggestions!
-
 # Features
 
 - Easily expandable and readable codebase
 - Config reloaded instantly upon saving
 - Custom bezier curve based animations
-- `wlr_ext` workspaces protocol support
 - Dual Kawase blur
 - Drop shadows
+- Rounded corners
+- Gradient borders
 - Fully dynamic workspaces
 - Closely follows `wlroots-git`
 - Global keybinds passed to your apps of choice
+- A lot of customization
 - Bundled wlroots
 - Window/layer fade in/out
 - Tiling/pseudotiling/floating/fullscreen windows
 - Switching workspaces between window modes on the fly
-- Special workspace (scratchpad)
+- Special workspaces (scratchpads)
 - Window/monitor rules
 - Socket-based IPC
+- `wlr_ext` workspaces protocol support
 - Event system for bash scripts
-- Rounded corners
 - Full damage tracking
 - Docks support
 - Drawing tablet support
@@ -150,9 +146,9 @@ Try it out and report bugs / suggestions!
 <!----------------------------------{ Images }--------------------------------->
 
 [Stars Preview]: https://starchart.cc/vaxerski/Hyprland.svg
-[Preview A]: https://i.imgur.com/pC6YF1Y.png
-[Preview B]: https://i.imgur.com/NbrTnZH.png
-[Preview C]: https://i.imgur.com/sCafdKQ.png
+[Preview A]: https://i.ibb.co/B3GJg28/20221126-20h53m26s-grim.png
+[Preview B]: https://i.imgur.com/pC6YF1Y.png
+[Preview C]: https://i.imgur.com/NbrTnZH.png
 
 
 <!----------------------------------{ Badges }--------------------------------->

docs/Hyprland.1

@@ -1,10 +1,10 @@
-.\" Automatically generated by Pandoc 2.5
+.\" Automatically generated by Pandoc 2.9.2.1
 .\"
-.TH "Hyprland" "1" "24 Aug 2022" "" "Hyprland User Manual"
+.TH "Hyprland" "1" "02 Dec 2022" "" "Hyprland User Manual"
 .hy
 .SH NAME
 .PP
-Hyprland \- Dynamic tiling Wayland compositor
+Hyprland - Dynamic tiling Wayland compositor
 .SH SYNOPSIS
 .PP
 \f[B]Hyprland\f[R] [\f[I]arg [...]\f[R]].
@@ -27,14 +27,14 @@ For configuration information please see
 <\f[I]https://github.com/hyprwm/Hyprland/wiki\f[R]>.
 .SH OPTIONS
 .TP
-.B \f[B]\-h\f[R], \f[B]\-\-help\f[R]
+\f[B]-h\f[R], \f[B]--help\f[R]
 Show command usage.
 .TP
-.B \f[B]\-c\f[R], \f[B]\-\-config\f[R]
+\f[B]-c\f[R], \f[B]--config\f[R]
 Specify config file to use.
 .SH BUGS
 .TP
-.B Submit bug reports and request features online at:
+Submit bug reports and request features online at:
 <\f[I]https://github.com/hyprwm/Hyprland/issues\f[R]>
 .SH SEE ALSO
 .PP

docs/ISSUE_GUIDELINES.md

@@ -57,3 +57,15 @@ coredumpctl info [PID]
 ```
 where `[PID]` is the PID you remembered.
 
+## Obtaining the debug Hyprland coredump
+In very rare cases, the normal coredump would not be enough.
+If that's the case, you could try obtaining the debug coredump.
+1. [Compile Hyprland with debug mode](http://wiki.hyprland.org/Contributing-and-Debugging/#build-in-debug-mode)
+> Note: The config file used will be `hyprlandd.conf` instead of `hyprland.conf`
+
+2. Reproduce the crash in debug mode.
+3. `env DEBUGINFOD_URLS="https://debuginfod.archlinux.org/" coredumpctl debug [PID]`(see section above)
+4. Wait until the `(gdb)` appears
+5. If gdb asks you `press y to continue without paging?` Type `y`
+6. `bt -full`
+7. copy the output of the command and provide that.

docs/hyprctl.1

@@ -1,10 +1,10 @@
-.\" Automatically generated by Pandoc 2.5
+.\" Automatically generated by Pandoc 2.9.2.1
 .\"
-.TH "hyprctl" "1" "24 Aug 2022" "" "hyprctl User Manual"
+.TH "hyprctl" "1" "02 Dec 2022" "" "hyprctl User Manual"
 .hy
 .SH NAME
 .PP
-hyprctl \- Utility for controlling parts of Hyprland from a CLI or a
+hyprctl - Utility for controlling parts of Hyprland from a CLI or a
 script
 .SH SYNOPSIS
 .PP
@@ -26,7 +26,7 @@ For dispatchers without parameters it can be anything.
 .PP
 Returns: \f[I]ok\f[R] on success, and an error message on failure.
 .TP
-.B Examples:
+Examples:
 \f[B]hyprctl\f[R] \f[I]dispatch exec kitty\f[R]
 .RS
 .PP
@@ -41,7 +41,7 @@ Set a config keyword dynamically.
 .PP
 Returns: \f[I]ok\f[R] on success, and an error message on failure.
 .TP
-.B Examples:
+Examples:
 \f[B]hyprctl\f[R] \f[I]keyword bind SUPER,0,pseudo\f[R]
 .RS
 .PP
@@ -112,13 +112,13 @@ Returns the current random splash.
 .RE
 .SH OPTIONS
 .PP
-\f[B]\-\-batch\f[R]
+\f[B]--batch\f[R]
 .RS
 .PP
 Specify a batch of commands to execute.
 .TP
-.B Example:
-\f[B]hyprctl\f[R] \f[I]\-\-batch \[dq]keyword general:border_size 2 ;
+Example:
+\f[B]hyprctl\f[R] \f[I]--batch \[dq]keyword general:border_size 2 ;
 keyword general:gaps_out 20\[dq]\f[R]
 .RS
 .PP
@@ -126,14 +126,14 @@ keyword general:gaps_out 20\[dq]\f[R]
 .RE
 .RE
 .PP
-\f[B]\-j\f[R]
+\f[B]-j\f[R]
 .RS
 .PP
 Outputs information in JSON.
 .RE
 .SH BUGS
 .TP
-.B Submit bug reports and request features online at:
+Submit bug reports and request features online at:
 <\f[I]https://github.com/hyprwm/Hyprland/issues\f[R]>
 .SH SEE ALSO
 .PP

example/hyprland.conf

@@ -1,117 +1,158 @@
 # This is an example Hyprland config file.
-# Syntax is the same as in Hypr, but settings might differ.
 #
 # Refer to the wiki for more information.
 
 #
 # Please note not all available settings / options are set here.
-# For a full list, see the wiki (basic and advanced configuring)
+# For a full list, see the wiki
 #
 
+# See https://wiki.hyprland.org/Configuring/Monitors/
 monitor=,preferred,auto,1
-workspace=DP-1,1
 
+
+# See https://wiki.hyprland.org/Configuring/Keywords/ for more
+
+# Execute your favorite apps at launch
+# exec-once = waybar & hyprpaper & firefox
+
+# Source a file (multi-file configs)
+# source = ~/.config/hypr/myColors.conf
+
+# For all categories, see https://wiki.hyprland.org/Configuring/Variables/
 input {
-    kb_file=
-    kb_layout=
-    kb_variant=
-    kb_model=
-    kb_options=
-    kb_rules=
+    kb_layout = us
+    kb_variant =
+    kb_model =
+    kb_options =
+    kb_rules =
 
-    follow_mouse=1
+    follow_mouse = 1
 
     touchpad {
-        natural_scroll=no
+        natural_scroll = no
     }
 
-    sensitivity=0 # -1.0 - 1.0, 0 means no modification.
+    sensitivity = 0 # -1.0 - 1.0, 0 means no modification.
 }
 
 general {
-    gaps_in=5
-    gaps_out=20
-    border_size=2
-    col.active_border=0x66ee1111
-    col.inactive_border=0x66333333
+    # See https://wiki.hyprland.org/Configuring/Variables/ for more
 
-    apply_sens_to_raw=0 # whether to apply the sensitivity to raw input (e.g. used by games where you aim using your mouse)
+    gaps_in = 5
+    gaps_out = 20
+    border_size = 2
+    col.active_border = rgba(33ccffee) rgba(00ff99ee) 45deg
+    col.inactive_border = rgba(595959aa)
 
-    damage_tracking=full # leave it on full unless you hate your GPU and want to make it suffer
+    layout = dwindle
 }
 
 decoration {
-    rounding=10
-    blur=1
-    blur_size=3 # minimum 1
-    blur_passes=1 # minimum 1
-    blur_new_optimizations=1
+    # See https://wiki.hyprland.org/Configuring/Variables/ for more
+
+    rounding = 10
+    blur = yes
+    blur_size = 3
+    blur_passes = 1
+    blur_new_optimizations = on
+
+    drop_shadow = yes
+    shadow_range = 4
+    shadow_render_power = 3
+    col.shadow = rgba(1a1a1aee)
 }
 
 animations {
-    enabled=1
-    animation=windows,1,7,default
-    animation=border,1,10,default
-    animation=fade,1,10,default
-    animation=workspaces,1,6,default
+    enabled = yes
+
+    # Some default animations, see https://wiki.hyprland.org/Configuring/Animations/ for more
+
+    bezier = myBezier, 0.05, 0.9, 0.1, 1.05
+
+    animation = windows, 1, 7, myBezier
+    animation = windowsOut, 1, 7, default, popin 80%
+    animation = border, 1, 10, default
+    animation = fade, 1, 7, default
+    animation = workspaces, 1, 6, default
 }
 
 dwindle {
-    pseudotile=0 # enable pseudotiling on dwindle
+    # See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
+    pseudotile = yes # master switch for pseudotiling. Enabling is bound to mainMod + P in the keybinds section below
+    preserve_split = yes # you probably want this
+}
+
+master {
+    # See https://wiki.hyprland.org/Configuring/Master-Layout/ for more
+    new_is_master = true
 }
 
 gestures {
-    workspace_swipe=no
+    # See https://wiki.hyprland.org/Configuring/Variables/ for more
+    workspace_swipe = off
 }
 
-# example window rules
-# for windows named/classed as abc and xyz
-#windowrule=move 69 420,abc
-#windowrule=size 420 69,abc
-#windowrule=tile,xyz
-#windowrule=float,abc
-#windowrule=pseudo,abc
-#windowrule=monitor 0,xyz
+# Example per-device config
+# See https://wiki.hyprland.org/Configuring/Keywords/#executing for more
+device:epic mouse V1 {
+    sensitivity = -0.5
+}
 
-# some nice mouse binds
-bindm=SUPER,mouse:272,movewindow
-bindm=SUPER,mouse:273,resizewindow
+# Example windowrule v1
+# windowrule = float, ^(kitty)$
+# Example windowrule v2
+# windowrulev2 = float,class:^(kitty)$,title:^(kitty)$
+# See https://wiki.hyprland.org/Configuring/Window-Rules/ for more
 
-# example binds
-bind=SUPER,Q,exec,kitty
-bind=SUPER,C,killactive,
-bind=SUPER,M,exit,
-bind=SUPER,E,exec,dolphin
-bind=SUPER,V,togglefloating,
-bind=SUPER,R,exec,wofi --show drun -o DP-3
-bind=SUPER,P,pseudo,
 
-bind=SUPER,left,movefocus,l
-bind=SUPER,right,movefocus,r
-bind=SUPER,up,movefocus,u
-bind=SUPER,down,movefocus,d
+# See https://wiki.hyprland.org/Configuring/Keywords/ for more
+$mainMod = SUPER
 
-bind=SUPER,1,workspace,1
-bind=SUPER,2,workspace,2
-bind=SUPER,3,workspace,3
-bind=SUPER,4,workspace,4
-bind=SUPER,5,workspace,5
-bind=SUPER,6,workspace,6
-bind=SUPER,7,workspace,7
-bind=SUPER,8,workspace,8
-bind=SUPER,9,workspace,9
-bind=SUPER,0,workspace,10
+# Example binds, see https://wiki.hyprland.org/Configuring/Binds/ for more
+bind = $mainMod, Q, exec, kitty
+bind = $mainMod, C, killactive, 
+bind = $mainMod, M, exit, 
+bind = $mainMod, E, exec, dolphin
+bind = $mainMod, V, togglefloating, 
+bind = $mainMod, R, exec, wofi --show drun
+bind = $mainMod, P, pseudo, # dwindle
+bind = $mainMod, J, togglesplit, # dwindle
 
-bind=ALT,1,movetoworkspace,1
-bind=ALT,2,movetoworkspace,2
-bind=ALT,3,movetoworkspace,3
-bind=ALT,4,movetoworkspace,4
-bind=ALT,5,movetoworkspace,5
-bind=ALT,6,movetoworkspace,6
-bind=ALT,7,movetoworkspace,7
-bind=ALT,8,movetoworkspace,8
-bind=ALT,9,movetoworkspace,9
-bind=ALT,0,movetoworkspace,10
+# Move focus with mainMod + arrow keys
+bind = $mainMod, left, movefocus, l
+bind = $mainMod, right, movefocus, r
+bind = $mainMod, up, movefocus, u
+bind = $mainMod, down, movefocus, d
 
-bind=SUPER,mouse_down,workspace,e+1
-bind=SUPER,mouse_up,workspace,e-1
+# Switch workspaces with mainMod + [0-9]
+bind = $mainMod, 1, workspace, 1
+bind = $mainMod, 2, workspace, 2
+bind = $mainMod, 3, workspace, 3
+bind = $mainMod, 4, workspace, 4
+bind = $mainMod, 5, workspace, 5
+bind = $mainMod, 6, workspace, 6
+bind = $mainMod, 7, workspace, 7
+bind = $mainMod, 8, workspace, 8
+bind = $mainMod, 9, workspace, 9
+bind = $mainMod, 0, workspace, 10
+
+# Move active window to a workspace with mainMod + SHIFT + [0-9]
+bind = $mainMod SHIFT, 1, movetoworkspace, 1
+bind = $mainMod SHIFT, 2, movetoworkspace, 2
+bind = $mainMod SHIFT, 3, movetoworkspace, 3
+bind = $mainMod SHIFT, 4, movetoworkspace, 4
+bind = $mainMod SHIFT, 5, movetoworkspace, 5
+bind = $mainMod SHIFT, 6, movetoworkspace, 6
+bind = $mainMod SHIFT, 7, movetoworkspace, 7
+bind = $mainMod SHIFT, 8, movetoworkspace, 8
+bind = $mainMod SHIFT, 9, movetoworkspace, 9
+bind = $mainMod SHIFT, 0, movetoworkspace, 10
+
+# Scroll through existing workspaces with mainMod + scroll
+bind = $mainMod, mouse_down, workspace, e+1
+bind = $mainMod, mouse_up, workspace, e-1
+
+# Move/resize windows with mainMod + LMB/RMB and dragging
+bindm = $mainMod, mouse:272, movewindow
+bindm = $mainMod, mouse:273, resizewindow

example/screenShader.frag

@@ -0,0 +1,16 @@
+//
+// Example blue light filter shader.
+// 
+
+precision mediump float;
+varying vec2 v_texcoord;
+uniform sampler2D tex;
+
+void main() {
+
+    vec4 pixColor = texture2D(tex, v_texcoord);
+
+    pixColor[2] *= 0.8;
+
+    gl_FragColor = pixColor;
+}

flake.lock

@@ -1,12 +1,44 @@
 {
   "nodes": {
+    "hyprland-protocols": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1670258048,
+        "narHash": "sha256-Lm2sXnDVZNE+taHqsqVibvPmSdu65VHvXI507KVX4lg=",
+        "owner": "hyprwm",
+        "repo": "hyprland-protocols",
+        "rev": "0dcff94fc10df2bbb66d3e1b5a1d6cfd3ada5515",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprland-protocols",
+        "type": "github"
+      }
+    },
+    "hyprland-protocols_2": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1670185345,
+        "narHash": "sha256-hxWGqlPecqEsE6nOHDV29KFBKePbY2Ipeac6lrChMKY=",
+        "owner": "hyprwm",
+        "repo": "hyprland-protocols",
+        "rev": "4623a404c091e64743ba310199bb380ec52f1936",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprland-protocols",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1665259268,
-        "narHash": "sha256-ONFhHBLv5nZKhwV/F2GOH16197PbvpyWhoO0AOyktkU=",
+        "lastModified": 1670064435,
+        "narHash": "sha256-+ELoY30UN+Pl3Yn7RWRPabykwebsVK/kYE9JsIsUMxQ=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "c5924154f000e6306030300592f4282949b2db6c",
+        "rev": "61a8a98e6d557e6dd7ed0cdb54c3a3e3bbc5e25c",
         "type": "github"
       },
       "original": {
@@ -18,19 +50,21 @@
     },
     "root": {
       "inputs": {
+        "hyprland-protocols": "hyprland-protocols",
         "nixpkgs": "nixpkgs",
-        "wlroots": "wlroots"
+        "wlroots": "wlroots",
+        "xdph": "xdph"
       }
     },
     "wlroots": {
       "flake": false,
       "locked": {
         "host": "gitlab.freedesktop.org",
-        "lastModified": 1665331677,
-        "narHash": "sha256-3Dh1i11mHK80jx5figC1oh1V0rCjieh0Mj+MajXdbPw=",
+        "lastModified": 1669925104,
+        "narHash": "sha256-xMHfW+/G9MieN/5tXHUA5/ztE8dkE093cNFTEUgcwxI=",
         "owner": "wlroots",
         "repo": "wlroots",
-        "rev": "ab8341975e62b1f668d8c9779ec8e72d04718a99",
+        "rev": "c8eb24d30e18c165728b8788a10716611c3b633d",
         "type": "gitlab"
       },
       "original": {
@@ -39,6 +73,27 @@
         "repo": "wlroots",
         "type": "gitlab"
       }
+    },
+    "xdph": {
+      "inputs": {
+        "hyprland-protocols": "hyprland-protocols_2",
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1670202338,
+        "narHash": "sha256-StTfshdAoSxO+t0wRbq1I3YESLFIQWFjGJse5ICV8rk=",
+        "owner": "hyprwm",
+        "repo": "xdg-desktop-portal-hyprland",
+        "rev": "af840a9e0947a79a37a95a9f62062653721e43fa",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "xdg-desktop-portal-hyprland",
+        "type": "github"
+      }
     }
   },
   "root": "root",

flake.nix

@@ -7,6 +7,16 @@
       url = "gitlab:wlroots/wlroots?host=gitlab.freedesktop.org";
       flake = false;
     };
+
+    xdph = {
+      url = "github:hyprwm/xdg-desktop-portal-hyprland";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+
+    hyprland-protocols = {
+      url = "github:hyprwm/hyprland-protocols";
+      flake = false;
+    };
   };
 
   outputs = inputs @ {
@@ -20,35 +30,34 @@
       "aarch64-linux"
       "x86_64-linux"
     ];
+
     pkgsFor = genSystems (system:
       import nixpkgs {
         inherit system;
         overlays = [
           (_: prev: {
             libdrm = prev.libdrm.overrideAttrs (old: rec {
-              version = "2.4.113";
+              version = "2.4.114";
               src = prev.fetchurl {
                 url = "https://dri.freedesktop.org/${old.pname}/${old.pname}-${version}.tar.xz";
-                sha256 = "sha256-f9frKWf2O+tGBvItUOJ32ZNIDQXvdd2Iqb2OZ3Mj5eE=";
+                sha256 = "sha256-MEnPhDpH0S5e7vvDvjSW14L6CfQjRr8Lfe/j0eWY0CY=";
+              };
+            });
+            wayland-protocols = prev.wayland-protocols.overrideAttrs (old: rec {
+              version = "1.29";
+              src = prev.fetchurl {
+                url = "https://gitlab.freedesktop.org/wayland/${old.pname}/-/releases/${version}/downloads/${old.pname}-${version}.tar.xz";
+                hash = "sha256-4l6at1rHNnBN3v6S6PmshzC+q29WTbYvetaVu6T/ntg=";
               };
-              mesonFlags =
-                [
-                  "-Dinstall-test-programs=true"
-                  "-Domap=enabled"
-                  "-Dcairo-tests=disabled"
-                ]
-                ++ lib.optionals prev.stdenv.hostPlatform.isAarch [
-                  "-Dtegra=enabled"
-                  "-Detnaviv=enabled"
-                ];
             });
           })
         ];
       });
+
     mkDate = longDate: (lib.concatStringsSep "-" [
-      (__substring 0 4 longDate)
-      (__substring 4 2 longDate)
-      (__substring 6 2 longDate)
+      (builtins.substring 0 4 longDate)
+      (builtins.substring 4 2 longDate)
+      (builtins.substring 6 2 longDate)
     ]);
   in {
     overlays.default = _: prev: rec {
@@ -58,8 +67,9 @@
       };
       hyprland = prev.callPackage ./nix/default.nix {
         stdenv = prev.gcc12Stdenv;
-        version = "0.15.0beta" + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty");
+        version = "0.18.0beta" + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty");
         wlroots = wlroots-hyprland;
+        inherit (inputs) hyprland-protocols;
       };
       hyprland-debug = hyprland.override {debug = true;};
       hyprland-no-hidpi = hyprland.override {hidpiXWayland = false;};
@@ -78,6 +88,12 @@
     devShells = genSystems (system: {
       default = pkgsFor.${system}.mkShell.override {stdenv = pkgsFor.${system}.gcc12Stdenv;} {
         name = "hyprland-shell";
+        nativeBuildInputs = with pkgsFor.${system}; [
+          cmake
+        ];
+        buildInputs = [
+          self.packages.${system}.wlroots-hyprland
+        ];
         inputsFrom = [
           self.packages.${system}.wlroots-hyprland
           self.packages.${system}.hyprland
@@ -87,7 +103,7 @@
 
     formatter = genSystems (system: pkgsFor.${system}.alejandra);
 
-    nixosModules.default = import ./nix/module.nix self;
+    nixosModules.default = import ./nix/module.nix inputs;
     homeManagerModules.default = import ./nix/hm-module.nix self;
   };
 

hyprctl/main.cpp

@@ -36,15 +36,24 @@ commands:
     reload
     setcursor
     getoption
+    cursorpos
+    switchxkblayout
 
 flags:
     -j -> output in JSON
     --batch -> execute a batch of commands, separated by ';'
 )#";
 
-void request(std::string arg) {
+void request(std::string arg, int minArgs = 0) {
     const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
 
+    const auto ARGS = std::count(arg.begin(), arg.end(), ' ');
+
+    if (ARGS < minArgs) {
+        std::cout << "Not enough arguments, expected at least " << minArgs;
+        return;
+    }
+
     if (SERVERSOCKET < 0) {
         std::cout << "Couldn't open a socket (1)";
         return;
@@ -80,6 +89,7 @@ void request(std::string arg) {
         return;
     }
 
+    std::string reply = "";
     char buffer[8192] = {0};
 
     sizeWritten = read(SERVERSOCKET, buffer, 8192);
@@ -89,9 +99,20 @@ void request(std::string arg) {
         return;
     }
 
+    reply += std::string(buffer, sizeWritten);
+
+    while (sizeWritten == 8192) {
+        sizeWritten = read(SERVERSOCKET, buffer, 8192);
+        if (sizeWritten < 0) {
+            std::cout << "Couldn't read (5)";
+            return;
+        }
+        reply += std::string(buffer, sizeWritten);
+    }
+
     close(SERVERSOCKET);
 
-    std::cout << std::string(buffer);
+    std::cout << reply;
 }
 
 void requestHyprpaper(std::string arg) {
@@ -145,25 +166,31 @@ void requestHyprpaper(std::string arg) {
     std::cout << std::string(buffer);
 }
 
-void dispatchRequest(int argc, char** argv) {
+int dispatchRequest(int argc, char** argv) {
 
     if (argc < 4) {
-        std::cout << "dispatch requires 2 params";
-        return;
+        std::cout << "Usage: hyprctl dispatch <dispatcher> <arg>\n\
+            Execute a hyprland keybind dispatcher with the given argument";
+        return 1;
     }
 
     std::string rq = "/dispatch";
 
-    for(int i = 2; i < argc; i++)
+    for(int i = 2; i < argc; i++) {
+        if (!strcmp(argv[i], "--"))
+            continue;
         rq += " " + std::string(argv[i]);
+    }
 
     request(rq);
+    return 0;
 }
 
-void keywordRequest(int argc, char** argv) {
+int keywordRequest(int argc, char** argv) {
     if (argc < 4) {
-        std::cout << "keyword requires 2 params";
-        return;
+        std::cout << "Usage: hyprctl keyword <keyword> <arg>\n\
+            Execute a hyprland keyword with the given argument";
+        return 1;
     }
 
     std::string rq = "/keyword";
@@ -172,28 +199,48 @@ void keywordRequest(int argc, char** argv) {
         rq += " " + std::string(argv[i]);
 
     request(rq);
+    return 0;
 }
 
-void hyprpaperRequest(int argc, char** argv) {
+int hyprpaperRequest(int argc, char** argv) {
     if (argc < 4) {
-        std::cout << "hyprpaper requires 2 params";
-        return;
+        std::cout << "Usage: hyprctl hyprpaper <command> <arg>\n\
+            Execute a hyprpaper command with the given argument";
+        return 1;
     }
 
     std::string rq = std::string(argv[2]) + " " + std::string(argv[3]);
 
     requestHyprpaper(rq);
+    return 0;
 }
 
-void setcursorRequest(int argc, char** argv) {
+int setcursorRequest(int argc, char** argv) {
     if (argc < 4) {
-        std::cout << "setcursor requires 2 params";
-        return;
+        std::cout << "Usage: hyprctl setcursor <theme> <size>\n\
+            Sets the cursor theme for everything except GTK and reloads the cursor";
+        return 1;
     }
 
     std::string rq = "setcursor " + std::string(argv[2]) + " " + std::string(argv[3]);
 
     request(rq);
+    return 0;
+}
+
+int outputRequest(int argc, char** argv) {
+    if (argc < 4) {
+        std::cout << "Usage: hyprctl output <mode> <name>\n\
+            creates / destroys a fake output\n\
+            with create, name is the backend name to use (available: auto, x11, wayland, headless)\n\
+            with destroy, name is the output name to destroy";
+        return 1;
+    }
+
+    std::string rq = "output " + std::string(argv[2]) + " " + std::string(argv[3]);
+
+    request(rq);
+    return 0;
 }
 
 void batchRequest(std::string arg) {
@@ -212,11 +259,14 @@ std::deque<std::string> splitArgs(int argc, char** argv) {
 }
 
 bool isNumber(const std::string& str, bool allowfloat) {
+    if (str.empty())
+        return false;
     return std::ranges::all_of(str.begin(), str.end(), [&](char c) { return isdigit(c) != 0 || c == '-' || (allowfloat && c == '.'); });
 }
 
 int main(int argc, char** argv) {
     int bflag = 0, sflag = 0, index, c;
+    bool parseArgs = true;
 
     if (argc < 2) {
         printf("%s\n", USAGE.c_str());
@@ -228,7 +278,12 @@ int main(int argc, char** argv) {
     const auto ARGS = splitArgs(argc, argv);
 
     for (auto i = 0; i < ARGS.size(); ++i) {
-        if (ARGS[i][0] == '-' && !isNumber(ARGS[i], true) /* For stuff like -2 */) {
+        if (ARGS[i] == "--") {
+            // Stop parsing arguments after --
+            parseArgs = false;
+            continue;
+        }
+        if (parseArgs && (ARGS[i][0] == '-') && !isNumber(ARGS[i], true) /* For stuff like -2 */) {
             // parse
             if (ARGS[i] == "-j" && !fullArgs.contains("j")) {
                 fullArgs += "j";
@@ -253,6 +308,8 @@ int main(int argc, char** argv) {
     fullRequest.pop_back(); // remove trailing space
 
     fullRequest = fullArgs + "/" + fullRequest;
+    
+    int exitStatus = 0;
 
     if (fullRequest.contains("/--batch")) batchRequest(fullRequest);
     else if (fullRequest.contains("/monitors")) request(fullRequest);
@@ -266,10 +323,13 @@ int main(int argc, char** argv) {
     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("/setcursor")) setcursorRequest(argc, argv);
-    else if (fullRequest.contains("/dispatch")) dispatchRequest(argc, argv);
-    else if (fullRequest.contains("/keyword")) keywordRequest(argc, argv);
-    else if (fullRequest.contains("/hyprpaper")) hyprpaperRequest(argc, argv);
+    else if (fullRequest.contains("/cursorpos")) request(fullRequest);
+    else if (fullRequest.contains("/switchxkblayout")) request(fullRequest, 2);
+    else if (fullRequest.contains("/output")) exitStatus = outputRequest(argc, argv);
+    else if (fullRequest.contains("/setcursor")) exitStatus = setcursorRequest(argc, argv);
+    else if (fullRequest.contains("/dispatch")) exitStatus = dispatchRequest(argc, argv);
+    else if (fullRequest.contains("/keyword")) exitStatus = keywordRequest(argc, argv);
+    else if (fullRequest.contains("/hyprpaper")) exitStatus = hyprpaperRequest(argc, argv);
     else if (fullRequest.contains("/--help")) printf("%s", USAGE.c_str());
     else {
         printf("%s\n", USAGE.c_str());
@@ -277,5 +337,5 @@ int main(int argc, char** argv) {
     }
 
     printf("\n");
-    return 0;
+    return exitStatus;
 }

meson.build

@@ -1,5 +1,5 @@
 project('Hyprland', 'cpp', 'c',
-  version : '0.15.0beta',
+  version : '0.18.0beta',
   default_options : [
     'warning_level=2',
     'default_library=static',
@@ -20,8 +20,8 @@ endif
 
 GIT_BRANCH = run_command('git', 'rev-parse', '--abbrev-ref', 'HEAD', check: false).stdout().strip()
 GIT_COMMIT_HASH = run_command('git', 'rev-parse', 'HEAD', check: false).stdout().strip()
-GIT_COMMIT_MESSAGE = run_command('bash', '-c', 'git show | head -n 5 | tail -n 1', check: false).stdout().strip()
-GIT_DIRTY = run_command('bash', '-c', 'git diff-index --quiet HEAD -- || echo "dirty"', check: false).stdout().strip()
+GIT_COMMIT_MESSAGE = run_command('sh', '-c', 'git show | head -n 5 | tail -n 1', check: false).stdout().strip()
+GIT_DIRTY = run_command('sh', '-c', 'git diff-index --quiet HEAD -- || echo "dirty"', check: false).stdout().strip()
 
 add_project_arguments(
   [

nix/default.nix

@@ -7,6 +7,7 @@
   meson,
   ninja,
   git,
+  hyprland-protocols,
   libdrm,
   libinput,
   libxcb,
@@ -14,6 +15,7 @@
   mesa,
   mount,
   pango,
+  pciutils,
   wayland,
   wayland-protocols,
   wayland-scanner,
@@ -62,17 +64,16 @@ in
           git
           libdrm
           libinput
-          libxcb
           libxkbcommon
           mesa
           pango
           wayland
           wayland-protocols
           wayland-scanner
+          pciutils
           (wlroots.override {inherit enableXWayland hidpiXWayland nvidiaPatches;})
-          xcbutilwm
         ]
-        ++ lib.optional enableXWayland xwayland;
+        ++ lib.optionals enableXWayland [libxcb xcbutilwm xwayland];
 
       mesonBuildType =
         if debug
@@ -92,6 +93,10 @@ in
       # Fix hardcoded paths to /usr installation
       postPatch = ''
         sed -i "s#/usr#$out#" src/render/OpenGL.cpp
+
+        # for some reason rmdir doesn't work in a dirty tree
+        rmdir subprojects/hyprland-protocols || true
+        ln -s ${hyprland-protocols} subprojects/hyprland-protocols
       '';
 
       passthru.providedSessions = ["hyprland"];

nix/hm-module.nix

@@ -92,18 +92,13 @@ in {
       ++ lib.optional cfg.xwayland.enable pkgs.xwayland;
 
     home.sessionVariables = lib.mkIf cfg.recommendedEnvironment {
-      GDK_BACKEND = "wayland";
-      _JAVA_AWT_WM_NONREPARENTING = "1";
       NIXOS_OZONE_WL = "1";
-      XCURSOR_SIZE = toString config.home.pointerCursor.size or "24";
-      XDG_SESSION_TYPE = "wayland";
     };
 
     xdg.configFile."hypr/hyprland.conf" = {
       text =
         (lib.optionalString cfg.systemdIntegration ''
-          exec-once=${pkgs.dbus}/bin/dbus-update-activation-environment --systemd DISPLAY WAYLAND_DISPLAY HYPRLAND_INSTANCE_SIGNATURE XDG_CURRENT_DESKTOP
-          exec-once=systemctl --user start hyprland-session.target
+          exec-once=${pkgs.dbus}/bin/dbus-update-activation-environment --systemd DISPLAY WAYLAND_DISPLAY HYPRLAND_INSTANCE_SIGNATURE XDG_CURRENT_DESKTOP && systemctl --user start hyprland-session.target
         '')
         + cfg.extraConfig;
 

nix/module.nix

@@ -1,5 +1,5 @@
 # Copied from https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/programs/sway.nix
-self: {
+inputs: {
   config,
   lib,
   pkgs,
@@ -23,7 +23,7 @@ in {
 
     package = mkOption {
       type = types.nullOr types.package;
-      default = self.packages.${pkgs.system}.default;
+      default = inputs.self.packages.${pkgs.system}.default;
       defaultText = literalExpression "<Hyprland flake>.packages.<system>.default";
       example = literalExpression "<Hyprland flake>.packages.<system>.default.override { }";
       description = ''
@@ -47,11 +47,7 @@ in {
       systemPackages = lib.optional (cfg.package != null) cfg.package;
 
       sessionVariables = mkIf cfg.recommendedEnvironment {
-        GDK_BACKEND = "wayland";
-        _JAVA_AWT_WM_NONREPARENTING = "1";
         NIXOS_OZONE_WL = "1";
-        XCURSOR_SIZE = "24";
-        XDG_SESSION_TYPE = "wayland";
       };
     };
     fonts.enableDefaultFonts = mkDefault true;
@@ -64,7 +60,8 @@ in {
     services.xserver.displayManager.sessionPackages = lib.optional (cfg.package != null) cfg.package;
     xdg.portal = {
       enable = mkDefault true;
-      extraPortals = [pkgs.xdg-desktop-portal-wlr];
+      # xdg-desktop-portal-hyprland
+      extraPortals = [inputs.xdph.packages.${pkgs.system}.default];
     };
   };
 }

nix/wlroots.nix

@@ -6,6 +6,7 @@
   xwayland,
   fetchpatch,
   lib,
+  hwdata,
   hidpiXWayland ? true,
   enableXWayland ? true,
   nvidiaPatches ? false,
@@ -51,6 +52,7 @@ assert (lib.assertMsg (hidpiXWayland -> enableXWayland) ''
           ''
           else ""
         );
+      buildInputs = old.buildInputs ++ [hwdata];
     }))
   .override {
     xwayland = xwayland.overrideAttrs (old: {

protocols/meson.build

@@ -3,7 +3,14 @@ wayland_protos = dependency('wayland-protocols',
 	fallback: 'wayland-protocols',
 	default_options: ['tests=false'],
 )
+
+hyprland_protos = dependency('hyprland-protocols',
+	version: '>=0.1',
+  fallback: 'hyprland-protocols',
+)
+
 wl_protocol_dir = wayland_protos.get_variable('pkgdatadir')
+hl_protocol_dir = hyprland_protos.get_variable('pkgdatadir')
 
 wayland_scanner_dep = dependency('wayland-scanner', native: true)
 wayland_scanner = find_program(
@@ -13,12 +20,14 @@ wayland_scanner = find_program(
 
 protocols = [
   [wl_protocol_dir, 'stable/xdg-shell/xdg-shell.xml'],
+  [wl_protocol_dir, 'unstable/linux-dmabuf/linux-dmabuf-unstable-v1.xml'],
   ['wlr-layer-shell-unstable-v1.xml'],
   ['wlr-output-power-management-unstable-v1.xml'],
   ['ext-workspace-unstable-v1.xml'],
   ['pointer-constraints-unstable-v1.xml'],
   ['tablet-unstable-v2.xml'],
-  ['idle.xml']
+  ['idle.xml'],
+  [hl_protocol_dir, 'protocols/hyprland-toplevel-export-v1.xml']
 ]
 wl_protos_src = []
 wl_protos_headers = []

src/Compositor.cpp

@@ -53,7 +53,7 @@ CCompositor::CCompositor() {
     wl_event_loop_add_signal(m_sWLEventLoop, SIGTERM, handleCritSignal, nullptr);
     //wl_event_loop_add_signal(m_sWLEventLoop, SIGINT, handleCritSignal, nullptr);
 
-    m_sWLRBackend = wlr_backend_autocreate(m_sWLDisplay);
+    m_sWLRBackend = wlr_backend_autocreate(m_sWLDisplay, &m_sWLRSession);
 
     if (!m_sWLRBackend) {
         Debug::log(CRIT, "m_sWLRBackend was NULL!");
@@ -73,7 +73,14 @@ CCompositor::CCompositor() {
         throw std::runtime_error("wlr_gles2_renderer_create_with_drm_fd() failed!");
     }
 
-    wlr_renderer_init_wl_display(m_sWLRRenderer, m_sWLDisplay);
+    wlr_renderer_init_wl_shm(m_sWLRRenderer, m_sWLDisplay);
+
+    if (wlr_renderer_get_dmabuf_texture_formats(m_sWLRRenderer)) {
+        if (wlr_renderer_get_drm_fd(m_sWLRRenderer) >= 0)
+            wlr_drm_create(m_sWLDisplay, m_sWLRRenderer);
+
+        m_sWLRLinuxDMABuf = wlr_linux_dmabuf_v1_create_with_renderer(m_sWLDisplay, 4, m_sWLRRenderer);
+    }
 
     m_sWLRAllocator = wlr_allocator_autocreate(m_sWLRBackend, m_sWLRRenderer);
 
@@ -107,7 +114,7 @@ CCompositor::CCompositor() {
     m_sWLRScene = wlr_scene_create();
     wlr_scene_attach_output_layout(m_sWLRScene, m_sWLROutputLayout);
 
-    m_sWLRXDGShell = wlr_xdg_shell_create(m_sWLDisplay, 4);
+    m_sWLRXDGShell = wlr_xdg_shell_create(m_sWLDisplay, 5);
 
     m_sWLRCursor = wlr_cursor_create();
     wlr_cursor_attach_output_layout(m_sWLRCursor, m_sWLROutputLayout);
@@ -115,13 +122,16 @@ CCompositor::CCompositor() {
     m_sWLRXCursorMgr = wlr_xcursor_manager_create(nullptr, 24);
     wlr_xcursor_manager_load(m_sWLRXCursorMgr, 1);
 
+    if (const auto XCURSORENV = getenv("XCURSOR_SIZE"); !XCURSORENV || std::string(XCURSORENV).empty())
+        setenv("XCURSOR_SIZE", "24", true);
+
     m_sSeat.seat = wlr_seat_create(m_sWLDisplay, "seat0");
 
     m_sWLRPresentation = wlr_presentation_create(m_sWLDisplay, m_sWLRBackend);
 
     m_sWLRIdle = wlr_idle_create(m_sWLDisplay);
 
-    m_sWLRLayerShell = wlr_layer_shell_v1_create(m_sWLDisplay);
+    m_sWLRLayerShell = wlr_layer_shell_v1_create(m_sWLDisplay, 4);
 
     m_sWLRServerDecoMgr = wlr_server_decoration_manager_create(m_sWLDisplay);
     m_sWLRXDGDecoMgr = wlr_xdg_decoration_manager_v1_create(m_sWLDisplay);
@@ -162,11 +172,20 @@ CCompositor::CCompositor() {
 
     m_sWLRPointerGestures = wlr_pointer_gestures_v1_create(m_sWLDisplay);
 
-    m_sWLRSession = wlr_backend_get_session(m_sWLRBackend);
-
     m_sWLRTextInputMgr = wlr_text_input_manager_v3_create(m_sWLDisplay);
 
     m_sWLRIMEMgr = wlr_input_method_manager_v2_create(m_sWLDisplay);
+
+    m_sWLRActivation = wlr_xdg_activation_v1_create(m_sWLDisplay);
+
+    m_sWLRHeadlessBackend = wlr_headless_backend_create(m_sWLDisplay);
+
+    if (!m_sWLRHeadlessBackend) {
+        Debug::log(CRIT, "Couldn't create the headless backend");
+        throw std::runtime_error("wlr_headless_backend_create() failed!");
+    }
+
+    wlr_multi_backend_add(m_sWLRBackend, m_sWLRHeadlessBackend);
 }
 
 CCompositor::~CCompositor() {
@@ -223,6 +242,7 @@ void CCompositor::initAllSignals() {
     addWLSignal(&m_sWLROutputPowerMgr->events.set_mode, &Events::listen_powerMgrSetMode, m_sWLROutputPowerMgr, "PowerMgr");
     addWLSignal(&m_sWLRIMEMgr->events.input_method, &Events::listen_newIME, m_sWLRIMEMgr, "IMEMgr");
     addWLSignal(&m_sWLRTextInputMgr->events.text_input, &Events::listen_newTextInput, m_sWLRTextInputMgr, "TextInputMgr");
+    addWLSignal(&m_sWLRActivation->events.request_activate, &Events::listen_activateXDG, m_sWLRActivation, "ActivationV1");
 
     if(m_sWRLDRMLeaseMgr)
         addWLSignal(&m_sWRLDRMLeaseMgr->events.request, &Events::listen_leaseRequest, &m_sWRLDRMLeaseMgr, "DRM");
@@ -235,12 +255,14 @@ void CCompositor::cleanup() {
     if (!m_sWLDisplay || m_bIsShuttingDown)
         return;
 
+    m_bIsShuttingDown = true;
+
     m_pLastFocus = nullptr;
     m_pLastWindow = nullptr;
 
     // accumulate all PIDs for killing, also request closing.
     for (auto& w : m_vWindows) {
-        if (w->m_bIsMapped && !w->m_bHidden)
+        if (w->m_bIsMapped && !w->isHidden())
             m_dProcessPIDsOnShutdown.push_back(w->getPID());
     }
 
@@ -250,8 +272,6 @@ void CCompositor::cleanup() {
     m_vWorkspaces.clear();
     m_vWindows.clear();
 
-    m_bIsShuttingDown = true;
-
     for (auto& m : m_vMonitors) {
         g_pHyprOpenGL->destroyMonitorResources(m.get());
 
@@ -306,6 +326,9 @@ void CCompositor::startCompositor() {
     Debug::log(LOG, "Creating the XWaylandManager!");
     g_pXWaylandManager = std::make_unique<CHyprXWaylandManager>();
 
+    Debug::log(LOG, "Creating the ProtocolManager!");
+    g_pProtocolManager = std::make_unique<CProtocolManager>();
+
     Debug::log(LOG, "Creating the EventManager!");
     g_pEventManager = std::make_unique<CEventManager>();
     g_pEventManager->startThread();
@@ -322,18 +345,27 @@ void CCompositor::startCompositor() {
 
     initAllSignals();
 
-    m_szWLDisplaySocket = wl_display_add_socket_auto(m_sWLDisplay);
+    // get socket, avoid using 0
+    for (int candidate = 1; candidate <= 32; candidate++) {
+        if (wl_display_add_socket(m_sWLDisplay, ("wayland-" + std::to_string(candidate)).c_str()) >= 0) {
+            m_szWLDisplaySocket = "wayland-" + std::to_string(candidate);
+            break;
+        }
+    }
 
-    if (!m_szWLDisplaySocket) {
+    if (m_szWLDisplaySocket.empty()) {
         Debug::log(CRIT, "m_szWLDisplaySocket NULL!");
         wlr_backend_destroy(m_sWLRBackend);
         throw std::runtime_error("m_szWLDisplaySocket was null! (wl_display_add_socket_auto failed)");
     }
 
-    setenv("WAYLAND_DISPLAY", m_szWLDisplaySocket, 1);
+    setenv("WAYLAND_DISPLAY", m_szWLDisplaySocket.c_str(), 1);
 
     signal(SIGPIPE, SIG_IGN);
 
+    if (m_sWLRSession /* Session-less Hyprland usually means a nest, don't update the env in that case */ && fork() == 0)
+        execl("/bin/sh", "/bin/sh", "-c", "dbus-update-activation-environment --systemd WAYLAND_DISPLAY XDG_CURRENT_DESKTOP HYPRLAND_INSTANCE_SIGNATURE", nullptr);
+
     Debug::log(LOG, "Running on WAYLAND_DISPLAY: %s", m_szWLDisplaySocket);
 
     if (!wlr_backend_start(m_sWLRBackend)) {
@@ -442,16 +474,16 @@ bool CCompositor::windowExists(CWindow* pWindow) {
 CWindow* CCompositor::vectorToWindow(const Vector2D& pos) {
     const auto PMONITOR = getMonitorFromVector(pos);
 
-    if (PMONITOR->specialWorkspaceOpen) {
+    if (PMONITOR->specialWorkspaceID) {
         for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
             wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
-            if ((*w)->m_bIsFloating && (*w)->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && (*w)->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && !(*w)->m_bHidden)
+            if ((*w)->m_bIsFloating && (*w)->m_iWorkspaceID == PMONITOR->specialWorkspaceID && (*w)->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && !(*w)->isHidden())
                 return (*w).get();
         }
 
         for (auto& w : m_vWindows) {
             wlr_box box = {w->m_vRealPosition.vec().x, w->m_vRealPosition.vec().y, w->m_vRealSize.vec().x, w->m_vRealSize.vec().y};
-            if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && wlr_box_contains_point(&box, pos.x, pos.y) && w->m_bIsMapped && !w->m_bIsFloating && !w->m_bHidden)
+            if (w->m_iWorkspaceID == PMONITOR->specialWorkspaceID && wlr_box_contains_point(&box, pos.x, pos.y) && w->m_bIsMapped && !w->m_bIsFloating && !w->isHidden())
                 return w.get();
         }
     }
@@ -459,20 +491,20 @@ CWindow* CCompositor::vectorToWindow(const Vector2D& pos) {
     // pinned
     for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
         wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
-        if (wlr_box_contains_point(&box, pos.x, pos.y) && (*w)->m_bIsMapped && (*w)->m_bIsFloating && !(*w)->m_bHidden && (*w)->m_bPinned)
+        if (wlr_box_contains_point(&box, pos.x, pos.y) && (*w)->m_bIsMapped && (*w)->m_bIsFloating && !(*w)->isHidden() && (*w)->m_bPinned)
             return w->get();
     }
 
     // first loop over floating cuz they're above, m_vWindows should be sorted bottom->top, for tiled it doesn't matter.
     for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
         wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
-        if (wlr_box_contains_point(&box, pos.x, pos.y) && (*w)->m_bIsMapped && (*w)->m_bIsFloating && isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->m_bHidden && !(*w)->m_bPinned)
+        if (wlr_box_contains_point(&box, pos.x, pos.y) && (*w)->m_bIsMapped && (*w)->m_bIsFloating && isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->isHidden() && !(*w)->m_bPinned)
             return w->get();
     }
 
     for (auto& w : m_vWindows) {
         wlr_box box = {w->m_vRealPosition.vec().x, w->m_vRealPosition.vec().y, w->m_vRealSize.vec().x, w->m_vRealSize.vec().y};
-        if (wlr_box_contains_point(&box, pos.x, pos.y) && w->m_bIsMapped && !w->m_bIsFloating && PMONITOR->activeWorkspace == w->m_iWorkspaceID && !w->m_bHidden)
+        if (wlr_box_contains_point(&box, pos.x, pos.y) && w->m_bIsMapped && !w->m_bIsFloating && PMONITOR->activeWorkspace == w->m_iWorkspaceID && !w->isHidden())
             return w.get();
     }
 
@@ -482,17 +514,17 @@ CWindow* CCompositor::vectorToWindow(const Vector2D& pos) {
 CWindow* CCompositor::vectorToWindowTiled(const Vector2D& pos) {
     const auto PMONITOR = getMonitorFromVector(pos);
 
-    if (PMONITOR->specialWorkspaceOpen) {
+    if (PMONITOR->specialWorkspaceID) {
         for (auto& w : m_vWindows) {
             wlr_box box = {w->m_vPosition.x, w->m_vPosition.y, w->m_vSize.x, w->m_vSize.y};
-            if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && wlr_box_contains_point(&box, pos.x, pos.y) && !w->m_bIsFloating && !w->m_bHidden)
+            if (w->m_iWorkspaceID == PMONITOR->specialWorkspaceID && wlr_box_contains_point(&box, pos.x, pos.y) && !w->m_bIsFloating && !w->isHidden())
                 return w.get();
         }
     }
 
     for (auto& w : m_vWindows) {
         wlr_box box = {w->m_vPosition.x, w->m_vPosition.y, w->m_vSize.x, w->m_vSize.y};
-        if (w->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && w->m_iWorkspaceID == PMONITOR->activeWorkspace && !w->m_bIsFloating && !w->m_bHidden)
+        if (w->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && w->m_iWorkspaceID == PMONITOR->activeWorkspace && !w->m_bIsFloating && !w->isHidden())
             return w.get();
     }
 
@@ -512,16 +544,16 @@ CWindow* CCompositor::vectorToWindowIdeal(const Vector2D& pos) {
     const auto PMONITOR = getMonitorFromVector(pos);
 
     // special workspace
-    if (PMONITOR->specialWorkspaceOpen) {
+    if (PMONITOR->specialWorkspaceID) {
         for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
             wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
-            if ((*w)->m_bIsFloating && (*w)->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && (*w)->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && !(*w)->m_bHidden && !(*w)->m_bX11ShouldntFocus)
+            if ((*w)->m_bIsFloating && (*w)->m_iWorkspaceID == PMONITOR->specialWorkspaceID && (*w)->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && !(*w)->isHidden() && !(*w)->m_bX11ShouldntFocus)
                 return (*w).get();
         }
 
         for (auto& w : m_vWindows) {
             wlr_box box = {w->m_vPosition.x, w->m_vPosition.y, w->m_vSize.x, w->m_vSize.y};
-            if (!w->m_bIsFloating && w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && w->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && !w->m_bHidden && !w->m_bX11ShouldntFocus)
+            if (!w->m_bIsFloating && w->m_iWorkspaceID == PMONITOR->specialWorkspaceID && w->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && !w->isHidden() && !w->m_bX11ShouldntFocus)
                 return w.get();
         }
     }
@@ -529,7 +561,7 @@ CWindow* CCompositor::vectorToWindowIdeal(const Vector2D& pos) {
     // pinned windows on top of floating regardless
     for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
         wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
-        if ((*w)->m_bIsFloating && (*w)->m_bIsMapped && !(*w)->m_bHidden && !(*w)->m_bX11ShouldntFocus && (*w)->m_bPinned) {
+        if ((*w)->m_bIsFloating && (*w)->m_bIsMapped && !(*w)->isHidden() && !(*w)->m_bX11ShouldntFocus && (*w)->m_bPinned) {
             if (wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y))
                 return w->get();
 
@@ -548,7 +580,7 @@ CWindow* CCompositor::vectorToWindowIdeal(const Vector2D& pos) {
     // first loop over floating cuz they're above, m_lWindows should be sorted bottom->top, for tiled it doesn't matter.
     for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
         wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
-        if ((*w)->m_bIsFloating && (*w)->m_bIsMapped && isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->m_bHidden && !(*w)->m_bPinned) {
+        if ((*w)->m_bIsFloating && (*w)->m_bIsMapped && isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->isHidden() && !(*w)->m_bPinned) {
             // OR windows should add focus to parent
             if ((*w)->m_bX11ShouldntFocus && (*w)->m_iX11Type != 2)
                 continue;
@@ -578,7 +610,7 @@ CWindow* CCompositor::vectorToWindowIdeal(const Vector2D& pos) {
 
     // for windows, we need to check their extensions too, first.
     for (auto& w : m_vWindows) {
-        if (!w->m_bIsX11 && !w->m_bIsFloating && w->m_bIsMapped && w->m_iWorkspaceID == PMONITOR->activeWorkspace && !w->m_bHidden && !w->m_bX11ShouldntFocus) {
+        if (!w->m_bIsX11 && !w->m_bIsFloating && w->m_bIsMapped && w->m_iWorkspaceID == PMONITOR->activeWorkspace && !w->isHidden() && !w->m_bX11ShouldntFocus) {
             wlr_surface* resultSurf = nullptr;
             Vector2D origin = w->m_vRealPosition.vec();
             SExtensionFindingData data = {origin, pos, &resultSurf};
@@ -590,7 +622,7 @@ CWindow* CCompositor::vectorToWindowIdeal(const Vector2D& pos) {
     }
     for (auto& w : m_vWindows) {
         wlr_box box = {w->m_vPosition.x, w->m_vPosition.y, w->m_vSize.x, w->m_vSize.y};
-        if (!w->m_bIsFloating && w->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && w->m_iWorkspaceID == PMONITOR->activeWorkspace && !w->m_bHidden && !w->m_bX11ShouldntFocus)
+        if (!w->m_bIsFloating && w->m_bIsMapped && wlr_box_contains_point(&box, pos.x, pos.y) && w->m_iWorkspaceID == PMONITOR->activeWorkspace && !w->isHidden() && !w->m_bX11ShouldntFocus)
             return w.get();
     }
 
@@ -600,16 +632,16 @@ CWindow* CCompositor::vectorToWindowIdeal(const Vector2D& pos) {
 CWindow* CCompositor::windowFromCursor() {
     const auto PMONITOR = getMonitorFromCursor();
 
-    if (PMONITOR->specialWorkspaceOpen) {
+    if (PMONITOR->specialWorkspaceID) {
         for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
             wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
-            if ((*w)->m_bIsFloating && (*w)->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && (*w)->m_bIsMapped && wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && !(*w)->m_bHidden)
+            if ((*w)->m_bIsFloating && (*w)->m_iWorkspaceID == PMONITOR->specialWorkspaceID && (*w)->m_bIsMapped && wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && !(*w)->isHidden())
                 return (*w).get();
         }
 
         for (auto& w : m_vWindows) {
             wlr_box box = {w->m_vPosition.x, w->m_vPosition.y, w->m_vSize.x, w->m_vSize.y};
-            if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && w->m_bIsMapped)
+            if (w->m_iWorkspaceID == PMONITOR->specialWorkspaceID && wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && w->m_bIsMapped)
                 return w.get();
         }
     }
@@ -640,13 +672,13 @@ CWindow* CCompositor::windowFromCursor() {
 CWindow* CCompositor::windowFloatingFromCursor() {
     for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
         wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
-        if (wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && (*w)->m_bIsMapped && (*w)->m_bIsFloating && !(*w)->m_bHidden && (*w)->m_bPinned)
+        if (wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && (*w)->m_bIsMapped && (*w)->m_bIsFloating && !(*w)->isHidden() && (*w)->m_bPinned)
             return w->get();
     }
 
     for (auto w = m_vWindows.rbegin(); w != m_vWindows.rend(); w++) {
         wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
-        if (wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && (*w)->m_bIsMapped && (*w)->m_bIsFloating && isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->m_bHidden && !(*w)->m_bPinned)
+        if (wlr_box_contains_point(&box, m_sWLRCursor->x, m_sWLRCursor->y) && (*w)->m_bIsMapped && (*w)->m_bIsFloating && isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->isHidden() && !(*w)->m_bPinned)
             return w->get();
     }
 
@@ -709,6 +741,8 @@ void CCompositor::focusWindow(CWindow* pWindow, wlr_surface* pSurface) {
         if (windowValidMapped(PLASTWINDOW)) {
             updateWindowAnimatedDecorationValues(PLASTWINDOW);
 
+            g_pXWaylandManager->activateWindow(PLASTWINDOW, false);
+
             if (PLASTWINDOW->m_phForeignToplevel)
                 wlr_foreign_toplevel_handle_v1_set_activated(PLASTWINDOW->m_phForeignToplevel, false);
         }
@@ -717,7 +751,11 @@ void CCompositor::focusWindow(CWindow* pWindow, wlr_surface* pSurface) {
 
         g_pEventManager->postEvent(SHyprIPCEvent{"activewindow", ","});
 
+        g_pLayoutManager->getCurrentLayout()->onWindowFocusChange(nullptr);
+
         m_pLastFocus = nullptr;
+
+        g_pInputManager->recheckIdleInhibitorStatus();
         return;
     }
 
@@ -742,10 +780,8 @@ void CCompositor::focusWindow(CWindow* pWindow, wlr_surface* pSurface) {
     if (windowValidMapped(PLASTWINDOW)) {
         updateWindowAnimatedDecorationValues(PLASTWINDOW);
 
-        if (PLASTWINDOW->m_bIsX11) {
-            wlr_seat_keyboard_notify_clear_focus(m_sSeat.seat);
-            wlr_seat_pointer_clear_focus(m_sSeat.seat);
-        }
+        if (!pWindow->m_bIsX11 || pWindow->m_iX11Type == 1)
+            g_pXWaylandManager->activateWindow(PLASTWINDOW, false);
 
         if (PLASTWINDOW->m_phForeignToplevel)
             wlr_foreign_toplevel_handle_v1_set_activated(PLASTWINDOW->m_phForeignToplevel, false);
@@ -768,8 +804,19 @@ void CCompositor::focusWindow(CWindow* pWindow, wlr_surface* pSurface) {
     // Send an event
     g_pEventManager->postEvent(SHyprIPCEvent{"activewindow", g_pXWaylandManager->getAppIDClass(pWindow) + "," + pWindow->m_szTitle});
 
+    g_pLayoutManager->getCurrentLayout()->onWindowFocusChange(pWindow);
+
     if (pWindow->m_phForeignToplevel)
         wlr_foreign_toplevel_handle_v1_set_activated(pWindow->m_phForeignToplevel, true);
+
+    if (!pWindow->m_bIsX11) {
+        const auto PCONSTRAINT = wlr_pointer_constraints_v1_constraint_for_surface(m_sWLRPointerConstraints, pWindow->m_uSurface.xdg->surface, m_sSeat.seat);
+
+        if (PCONSTRAINT)
+            g_pInputManager->constrainMouse(m_sSeat.mouse, PCONSTRAINT);
+    }
+
+    g_pInputManager->recheckIdleInhibitorStatus();
 }
 
 void CCompositor::focusSurface(wlr_surface* pSurface, CWindow* pWindowOwner) {
@@ -778,7 +825,7 @@ void CCompositor::focusSurface(wlr_surface* pSurface, CWindow* pWindowOwner) {
         return;  // Don't focus when already focused on this.
 
     // Unfocus last surface if should
-    if (m_pLastFocus && ((m_sSeat.seat->keyboard_state.focused_surface && wlr_surface_is_xdg_surface(m_pLastFocus)) || !pSurface))
+    if (m_pLastFocus && !pWindowOwner)
         g_pXWaylandManager->activateSurface(m_pLastFocus, false);
 
     if (!pSurface) {
@@ -810,11 +857,14 @@ void CCompositor::focusSurface(wlr_surface* pSurface, CWindow* pWindowOwner) {
     else
         Debug::log(LOG, "Set keyboard focus to surface %x", pSurface);
 
-    g_pXWaylandManager->activateSurface(pSurface, false);
+    g_pXWaylandManager->activateSurface(pSurface, true);
     m_pLastFocus = pSurface;
 }
 
 bool CCompositor::windowValidMapped(CWindow* pWindow) {
+    if (!pWindow)
+        return false;
+
     if (!windowExists(pWindow))
         return false;
 
@@ -824,7 +874,7 @@ bool CCompositor::windowValidMapped(CWindow* pWindow) {
     if (!pWindow->m_bIsMapped)
         return false;
 
-    if (pWindow->m_bHidden)
+    if (pWindow->isHidden())
         return false;
 
     return true;
@@ -844,7 +894,11 @@ wlr_surface* CCompositor::vectorToLayerSurface(const Vector2D& pos, std::vector<
         if ((*it)->fadingOut || !(*it)->layerSurface || ((*it)->layerSurface && !(*it)->layerSurface->mapped) || (*it)->alpha.fl() == 0.f)
             continue;
 
-        const auto SURFACEAT = wlr_layer_surface_v1_surface_at((*it)->layerSurface, pos.x - (*it)->geometry.x, pos.y - (*it)->geometry.y, &sCoords->x, &sCoords->y);
+        auto SURFACEAT = wlr_layer_surface_v1_surface_at((*it)->layerSurface, pos.x - (*it)->geometry.x, pos.y - (*it)->geometry.y, &sCoords->x, &sCoords->y);
+
+        if (!SURFACEAT && VECINRECT(pos, (*it)->geometry.x, (*it)->geometry.y, (*it)->geometry.x + (*it)->geometry.width, (*it)->geometry.y + (*it)->geometry.height)) {
+            SURFACEAT = (*it)->layerSurface->surface;
+        }
 
         if (SURFACEAT) {
             *ppLayerSurfaceFound = it->get();
@@ -864,6 +918,16 @@ CWindow* CCompositor::getWindowFromSurface(wlr_surface* pSurface) {
     return nullptr;
 }
 
+CWindow* CCompositor::getWindowFromHandle(uint32_t handle) {
+    for (auto& w : m_vWindows) {
+        if ((uint32_t)(((uint64_t)w.get()) & 0xFFFFFFFF) == handle) {
+            return w.get();
+        }
+    }
+
+    return nullptr;
+}
+
 CWindow* CCompositor::getFullscreenWindowOnWorkspace(const int& ID) {
     for (auto& w : m_vWindows) {
         if (w->m_iWorkspaceID == ID && w->m_bIsFullscreen)
@@ -878,7 +942,7 @@ bool CCompositor::isWorkspaceVisible(const int& w) {
         if (m->activeWorkspace == w)
             return true;
 
-        if (m->specialWorkspaceOpen && w == SPECIAL_WORKSPACE_ID)
+        if (m->specialWorkspaceID && isWorkspaceSpecial(w))
             return true;
     }
 
@@ -907,10 +971,8 @@ void CCompositor::sanityCheckWorkspaces() {
             continue;
         }
 
-        if ((*it)->m_iID == SPECIAL_WORKSPACE_ID && WINDOWSONWORKSPACE == 0) {
-            for (auto& m : m_vMonitors) {
-                m->specialWorkspaceOpen = false;
-            }
+        if ((*it)->m_bIsSpecialWorkspace && WINDOWSONWORKSPACE == 0) {
+            getMonitorFromID((*it)->m_iMonitorID)->specialWorkspaceID = 0;
 
             it = m_vWorkspaces.erase(it);
 
@@ -934,7 +996,7 @@ int CCompositor::getWindowsOnWorkspace(const int& id) {
 
 CWindow* CCompositor::getFirstWindowOnWorkspace(const int& id) {
     for (auto& w : m_vWindows) {
-        if (w->m_iWorkspaceID == id && w->m_bIsMapped && !w->m_bHidden)
+        if (w->m_iWorkspaceID == id && w->m_bIsMapped && !w->isHidden())
             return w.get();
     }
 
@@ -980,7 +1042,7 @@ void CCompositor::moveWindowToTop(CWindow* pWindow) {
     std::deque<CWindow*> toMove;
 
     for (auto& w : m_vWindows) {
-        if (w->m_bIsMapped && w->m_bMappedX11 && !w->m_bHidden && w->m_bIsX11 && w->X11TransientFor() == pWindow) {
+        if (w->m_bIsMapped && w->m_bMappedX11 && !w->isHidden() && w->m_bIsX11 && w->X11TransientFor() == pWindow) {
             toMove.emplace_back(w.get());
         }
     }
@@ -1103,7 +1165,11 @@ CWindow* CCompositor::getWindowInDirection(CWindow* pWindow, char dir) {
     CWindow* longestIntersectWindow = nullptr;
 
     for (auto& w : m_vWindows) {
-        if (w.get() == pWindow || !w->m_bIsMapped || w->m_bHidden || w->m_bIsFloating || !isWorkspaceVisible(w->m_iWorkspaceID))
+        if (w.get() == pWindow || !w->m_bIsMapped || w->isHidden() || w->m_bIsFloating || !isWorkspaceVisible(w->m_iWorkspaceID))
+            continue;
+
+        const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID);
+        if (PWORKSPACE->m_bHasFullscreenWindow && !w->m_bIsFullscreen && !w->m_bCreatedOverFullscreen)
             continue;
 
         const auto BWINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved();
@@ -1177,12 +1243,12 @@ CWindow* CCompositor::getNextWindowOnWorkspace(CWindow* pWindow, bool focusableO
             continue;
         }
 
-        if (w->m_iWorkspaceID == pWindow->m_iWorkspaceID && w->m_bIsMapped && !w->m_bHidden && (!focusableOnly || !w->m_bNoFocus))
+        if (w->m_iWorkspaceID == pWindow->m_iWorkspaceID && w->m_bIsMapped && !w->isHidden() && (!focusableOnly || !w->m_bNoFocus))
             return w.get();
     }
 
     for (auto& w : m_vWindows) {
-        if (w.get() != pWindow && w->m_iWorkspaceID == pWindow->m_iWorkspaceID && w->m_bIsMapped && !w->m_bHidden && (!focusableOnly || !w->m_bNoFocus))
+        if (w.get() != pWindow && w->m_iWorkspaceID == pWindow->m_iWorkspaceID && w->m_bIsMapped && !w->isHidden() && (!focusableOnly || !w->m_bNoFocus))
             return w.get();
     }
 
@@ -1200,12 +1266,12 @@ CWindow* CCompositor::getPrevWindowOnWorkspace(CWindow* pWindow, bool focusableO
             continue;
         }
 
-        if ((*it)->m_iWorkspaceID == pWindow->m_iWorkspaceID && (*it)->m_bIsMapped && !(*it)->m_bHidden && (!focusableOnly || !(*it)->m_bNoFocus))
+        if ((*it)->m_iWorkspaceID == pWindow->m_iWorkspaceID && (*it)->m_bIsMapped && !(*it)->isHidden() && (!focusableOnly || !(*it)->m_bNoFocus))
             return it->get();
     }
 
     for (auto it = m_vWindows.rbegin(); it != m_vWindows.rend(); it++) {
-        if (it->get() != pWindow && (*it)->m_iWorkspaceID == pWindow->m_iWorkspaceID && (*it)->m_bIsMapped && !(*it)->m_bHidden && (!focusableOnly || !(*it)->m_bNoFocus))
+        if (it->get() != pWindow && (*it)->m_iWorkspaceID == pWindow->m_iWorkspaceID && (*it)->m_bIsMapped && !(*it)->isHidden() && (!focusableOnly || !(*it)->m_bNoFocus))
             return it->get();
     }
 
@@ -1255,6 +1321,11 @@ bool CCompositor::isPointOnAnyMonitor(const Vector2D& point) {
     return false;
 }
 
+void checkFocusSurfaceIter(wlr_surface* pSurface, int x, int y, void* data) {
+    auto pair = (std::pair<wlr_surface*, bool>*)data;
+    pair->second = pair->second || pSurface == pair->first;
+}
+
 CWindow* CCompositor::getConstraintWindow(SMouse* pMouse) {
     if (!pMouse->currentConstraint)
         return nullptr;
@@ -1262,11 +1333,18 @@ CWindow* CCompositor::getConstraintWindow(SMouse* pMouse) {
     const auto PSURFACE = pMouse->currentConstraint->surface;
 
     for (auto& w : m_vWindows) {
-        if (PSURFACE == g_pXWaylandManager->getWindowSurface(w.get())) {
-            if (!w->m_bIsX11 && w->m_bIsMapped && !w->m_bHidden)
-                continue;
+        if (w->isHidden() || !w->m_bMappedX11 || !w->m_bIsMapped || !g_pXWaylandManager->getWindowSurface(w.get()))
+            continue;
 
-            return w.get();
+        if (w->m_bIsX11) {
+            if (PSURFACE == g_pXWaylandManager->getWindowSurface(w.get()))
+                return w.get();
+        } else {
+            std::pair<wlr_surface*, bool> check = {PSURFACE, false};
+            wlr_surface_for_each_surface(w->m_uSurface.xdg->surface, checkFocusSurfaceIter, &check);
+
+            if (check.second)
+                return w.get();
         }
     }
 
@@ -1345,8 +1423,8 @@ void CCompositor::updateAllWindowsAnimatedDecorationValues() {
 
 void CCompositor::updateWindowAnimatedDecorationValues(CWindow* pWindow) {
     // optimization
-    static int64_t* ACTIVECOL = &g_pConfigManager->getConfigValuePtr("general:col.active_border")->intValue;
-    static int64_t* INACTIVECOL = &g_pConfigManager->getConfigValuePtr("general:col.inactive_border")->intValue;
+    static auto *const ACTIVECOL = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("general:col.active_border")->data.get();
+    static auto *const INACTIVECOL = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("general:col.inactive_border")->data.get();
     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 PFULLSCREENALPHA = &g_pConfigManager->getConfigValuePtr("decoration:fullscreen_opacity")->floatValue;
@@ -1354,12 +1432,25 @@ void CCompositor::updateWindowAnimatedDecorationValues(CWindow* pWindow) {
     static auto *const PSHADOWCOLINACTIVE = &g_pConfigManager->getConfigValuePtr("decoration:col.shadow_inactive")->intValue;
     static auto *const PDIMSTRENGTH = &g_pConfigManager->getConfigValuePtr("decoration:dim_strength")->floatValue;
 
+    auto setBorderColor = [&] (CGradientValueData grad) -> void {
+
+        if (grad == pWindow->m_cRealBorderColor)
+            return;
+
+        pWindow->m_cRealBorderColorPrevious = pWindow->m_cRealBorderColor;
+        pWindow->m_cRealBorderColor = grad;
+        pWindow->m_fBorderAnimationProgress.setValueAndWarp(0.f);
+        pWindow->m_fBorderAnimationProgress = 1.f;
+    };
+
     // border
     const auto RENDERDATA = g_pLayoutManager->getCurrentLayout()->requestRenderHints(pWindow);
     if (RENDERDATA.isBorderColor)
-        pWindow->m_cRealBorderColor = RENDERDATA.borderColor;
+        setBorderColor(RENDERDATA.borderColor * (1.f / 255.f));
     else
-        pWindow->m_cRealBorderColor = CColor(pWindow == m_pLastWindow ? *ACTIVECOL : *INACTIVECOL);
+        setBorderColor(pWindow == m_pLastWindow ?
+                                            (pWindow->m_sSpecialRenderData.activeBorderColor >= 0 ? CGradientValueData(CColor(pWindow->m_sSpecialRenderData.activeBorderColor) * (1.f / 255.f)) : *ACTIVECOL) :
+                                            (pWindow->m_sSpecialRenderData.inactiveBorderColor >= 0 ? CGradientValueData(CColor(pWindow->m_sSpecialRenderData.inactiveBorderColor) * (1.f / 255.f)) : *INACTIVECOL));
 
 
     // opacity
@@ -1480,7 +1571,40 @@ void CCompositor::swapActiveWorkspaces(CMonitor* pMonitorA, CMonitor* pMonitorB)
 }
 
 CMonitor* CCompositor::getMonitorFromString(const std::string& name) {
-    if (isNumber(name)) {
+    if (name[0] == '+' || name[0] == '-') {
+        // relative
+        const auto OFFSET = name[0] == '-' ? name : name.substr(1);
+
+        if (!isNumber(OFFSET)) {
+            Debug::log(ERR, "Error in getMonitorFromString: Not a number in relative.");
+            return nullptr;
+        }
+
+        int offsetLeft = std::stoi(OFFSET) % m_vMonitors.size(); // no need to cycle more
+
+        int currentPlace = 0;
+        for (int i = 0; i < (int)m_vMonitors.size(); i++) {
+            if (m_vMonitors[i].get() == m_pLastMonitor) {
+                currentPlace = i;
+                break;
+            }
+        }
+
+        currentPlace += offsetLeft;
+
+        if (currentPlace < 0) {
+            currentPlace = m_vMonitors.size() - currentPlace;
+        } else {
+            currentPlace = currentPlace % m_vMonitors.size();
+        }
+
+        if (currentPlace != std::clamp(currentPlace, 0, (int)m_vMonitors.size())) {
+            Debug::log(WARN, "Error in getMonitorFromString: Vaxry's code sucks.");
+            currentPlace = std::clamp(currentPlace, 0, (int)m_vMonitors.size());
+        }
+
+        return m_vMonitors[currentPlace].get();
+    } else if (isNumber(name)) {
         // change by ID
         int monID = -1;
         try {
@@ -1543,7 +1667,7 @@ void CCompositor::moveWorkspaceToMonitor(CWorkspace* pWorkspace, CMonitor* pMoni
     if (nextWorkspaceOnMonitorID == -1) {
         nextWorkspaceOnMonitorID = 1;
 
-        while (getWorkspaceByID(nextWorkspaceOnMonitorID))
+        while (getWorkspaceByID(nextWorkspaceOnMonitorID) || [&]() -> bool { const auto B = g_pConfigManager->getBoundMonitorForWS(std::to_string(nextWorkspaceOnMonitorID)); return B && B != POLDMON; }())
             nextWorkspaceOnMonitorID++;
 
         Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with new %d", nextWorkspaceOnMonitorID);
@@ -1564,7 +1688,7 @@ void CCompositor::moveWorkspaceToMonitor(CWorkspace* pWorkspace, CMonitor* pMoni
             w->m_iMonitorID = pMonitor->ID;
 
             // additionally, move floating and fs windows manually
-            if (w->m_bIsMapped && !w->m_bHidden) {
+            if (w->m_bIsMapped && !w->isHidden()) {
                 if (w->m_bIsFloating)
                     w->m_vRealPosition = w->m_vRealPosition.vec() - POLDMON->vecPosition + pMonitor->vecPosition;
 
@@ -1606,7 +1730,7 @@ bool CCompositor::workspaceIDOutOfBounds(const int& id) {
     int highestID = -99999;
 
     for (auto& w : m_vWorkspaces) {
-        if (w->m_iID == SPECIAL_WORKSPACE_ID)
+        if (w->m_bIsSpecialWorkspace)
             continue;
 
         if (w->m_iID < lowestID)
@@ -1641,12 +1765,15 @@ void CCompositor::setWindowFullscreen(CWindow* pWindow, bool on, eFullscreenMode
 
     g_pXWaylandManager->setWindowFullscreen(pWindow, pWindow->m_bIsFullscreen && mode == FULLSCREEN_FULL);
 
+    pWindow->updateDynamicRules();
+    g_pCompositor->updateWindowAnimatedDecorationValues(pWindow);
+
     // make all windows on the same workspace under the fullscreen window
     for (auto& w : g_pCompositor->m_vWindows) {
         if (w->m_iWorkspaceID == pWindow->m_iWorkspaceID) {
             w->m_bCreatedOverFullscreen = false;
             if (w.get() != pWindow && !w->m_bFadingOut && !w->m_bPinned)
-                w->m_fAlpha = pWindow->m_bIsFullscreen && mode == FULLSCREEN_FULL ? 0.f : 255.f;
+                w->m_fAlpha = pWindow->m_bIsFullscreen ? 0.f : 255.f;
         }
     }
 
@@ -1658,6 +1785,11 @@ void CCompositor::setWindowFullscreen(CWindow* pWindow, bool on, eFullscreenMode
     g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goalv(), true);
 
     forceReportSizesToWindowsOnWorkspace(pWindow->m_iWorkspaceID);
+
+    g_pInputManager->recheckIdleInhibitorStatus();
+
+    // DMAbuf stuff for direct scanout
+    g_pHyprRenderer->setWindowScanoutMode(pWindow);
 }
 
 void CCompositor::moveUnmanagedX11ToWindows(CWindow* pWindow) {
@@ -1698,6 +1830,9 @@ void CCompositor::scheduleFrameForMonitor(CMonitor* pMonitor) {
     if ((m_sWLRSession && !m_sWLRSession->active) || !m_bSessionActive)
         return;
 
+    if (!pMonitor->m_bEnabled)
+        return;
+
     wlr_output_schedule_frame(pMonitor->output);
 }
 
@@ -1718,7 +1853,7 @@ CWindow* CCompositor::getWindowByRegex(const std::string& regexp) {
     }
 
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (!w->m_bIsMapped || w->m_bHidden)
+        if (!w->m_bIsMapped || w->isHidden())
             continue;
 
         switch (mode) {
@@ -1770,7 +1905,7 @@ void CCompositor::warpCursorTo(const Vector2D& pos) {
 
     const auto PMONITORNEW = getMonitorFromVector(pos);
     if (PMONITORNEW != m_pLastMonitor)
-        m_pLastMonitor = PMONITORNEW;
+        setActiveMonitor(PMONITORNEW);
 }
 
 SLayerSurface* CCompositor::getLayerSurfaceFromWlr(wlr_layer_surface_v1* pLS) {
@@ -1846,7 +1981,7 @@ Vector2D CCompositor::parseWindowVectorArgsRelative(const std::string& args, con
 
 void CCompositor::forceReportSizesToWindowsOnWorkspace(const int& wid) {
     for (auto& w : m_vWindows) {
-        if (w->m_iWorkspaceID == wid && w->m_bIsMapped && !w->m_bHidden) {
+        if (w->m_iWorkspaceID == wid && w->m_bIsMapped && !w->isHidden()) {
             g_pXWaylandManager->setWindowSize(w.get(), w->m_vRealSize.vec(), true);
         }
     }
@@ -1862,3 +1997,56 @@ bool CCompositor::cursorOnReservedArea() {
 
     return !VECINRECT(CURSORPOS, XY1.x, XY1.y, XY2.x, XY2.y);
 }
+
+CWorkspace* CCompositor::createNewWorkspace(const int& id, const int& monid, const std::string& name) {
+    const auto NAME = name == "" ? std::to_string(id) : name;
+    auto monID = monid;
+
+    // check if bound
+    if (const auto PMONITOR = g_pConfigManager->getBoundMonitorForWS(NAME); PMONITOR) {
+        monID = PMONITOR->ID;
+    }
+
+    const bool SPECIAL = id >= SPECIAL_WORKSPACE_START && id <= -2;
+
+    const auto PWORKSPACE = m_vWorkspaces.emplace_back(std::make_unique<CWorkspace>(monID, NAME, SPECIAL)).get();
+
+    // We are required to set the name here immediately
+    if (!SPECIAL)
+        wlr_ext_workspace_handle_v1_set_name(PWORKSPACE->m_pWlrHandle, NAME.c_str());
+
+    PWORKSPACE->m_iID = id;
+    PWORKSPACE->m_iMonitorID = monID;
+
+    return PWORKSPACE;
+}
+
+void CCompositor::setActiveMonitor(CMonitor* pMonitor) {
+    if (m_pLastMonitor == pMonitor)
+        return;
+
+    if (!pMonitor) {
+        m_pLastMonitor = nullptr;
+        return;
+    }
+
+    const auto PWORKSPACE = getWorkspaceByID(pMonitor->activeWorkspace);
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"focusedmon", pMonitor->szName + "," + PWORKSPACE->m_szName});
+    m_pLastMonitor = pMonitor;
+}
+
+bool CCompositor::isWorkspaceSpecial(const int& id) {
+    return id >= SPECIAL_WORKSPACE_START && id <= -2;
+}
+
+int CCompositor::getNewSpecialID() {
+    int highest = -100;
+    for (auto& ws : m_vWorkspaces) {
+        if (ws->m_bIsSpecialWorkspace && ws->m_iID > highest) {
+            highest = ws->m_iID;
+        }
+    }
+
+    return highest + 1;
+}

src/Compositor.hpp

@@ -15,6 +15,7 @@
 #include "managers/KeybindManager.hpp"
 #include "managers/AnimationManager.hpp"
 #include "managers/EventManager.hpp"
+#include "managers/ProtocolManager.hpp"
 #include "debug/HyprDebugOverlay.hpp"
 #include "helpers/Monitor.hpp"
 #include "helpers/Workspace.hpp"
@@ -69,12 +70,15 @@ public:
     wlr_output_power_manager_v1*     m_sWLROutputPowerMgr;
     wlr_input_method_manager_v2*     m_sWLRIMEMgr;
     wlr_text_input_manager_v3*       m_sWLRTextInputMgr;
+    wlr_xdg_activation_v1*           m_sWLRActivation;
+    wlr_linux_dmabuf_v1*             m_sWLRLinuxDMABuf;
+    wlr_backend*                     m_sWLRHeadlessBackend;
     // ------------------------------------------------- //
 
 
-    const char*             m_szWLDisplaySocket;
+    std::string             m_szWLDisplaySocket = "";
     std::string             m_szInstanceSignature = "";
-    std::string             m_szCurrentSplash = "error";
+    std::string             m_szCurrentSplash   = "error";
 
     std::vector<std::shared_ptr<CMonitor>>      m_vMonitors;
     std::vector<std::shared_ptr<CMonitor>>      m_vRealMonitors; // for all monitors, even those turned off
@@ -89,17 +93,17 @@ public:
     void                    startCompositor();
     void                    cleanup();
 
-    wlr_surface*            m_pLastFocus = nullptr;
-    CWindow*                m_pLastWindow = nullptr;
-    CMonitor*               m_pLastMonitor = nullptr;
+    wlr_surface*            m_pLastFocus        = nullptr;
+    CWindow*                m_pLastWindow       = nullptr;
+    CMonitor*               m_pLastMonitor      = nullptr;
 
     SSeat                   m_sSeat;
 
-    bool                    m_bReadyToProcess = false;
-    bool                    m_bSessionActive = true;
-    bool                    m_bDPMSStateON = true;
-    bool                    m_bUnsafeState = false; // unsafe state is when there is no monitors.
-    bool                    m_bIsShuttingDown = false;
+    bool                    m_bReadyToProcess   = false;
+    bool                    m_bSessionActive    = true;
+    bool                    m_bDPMSStateON      = true;
+    bool                    m_bUnsafeState      = false; // unsafe state is when there is no monitors.
+    bool                    m_bIsShuttingDown   = false;
     std::deque<uint64_t>    m_dProcessPIDsOnShutdown; // stores PIDs of apps to kill later when shutting down
 
     // ------------------------------------------------- //
@@ -123,6 +127,7 @@ public:
     CMonitor*               getMonitorFromOutput(wlr_output*);
     CWindow*                getWindowForPopup(wlr_xdg_popup*);
     CWindow*                getWindowFromSurface(wlr_surface*);
+    CWindow*                getWindowFromHandle(uint32_t);
     bool                    isWorkspaceVisible(const int&);
     CWorkspace*             getWorkspaceByID(const int&);
     CWorkspace*             getWorkspaceByName(const std::string&);
@@ -165,6 +170,10 @@ public:
     Vector2D                parseWindowVectorArgsRelative(const std::string&, const Vector2D&);
     void                    forceReportSizesToWindowsOnWorkspace(const int&);
     bool                    cursorOnReservedArea();
+    CWorkspace*             createNewWorkspace(const int&, const int&, const std::string& name = ""); // will be deleted next frame if left empty and unfocused!
+    void                    setActiveMonitor(CMonitor*);
+    bool                    isWorkspaceSpecial(const int&);
+    int                     getNewSpecialID();
 
     std::string             explicitConfigPath;
 

src/Window.cpp

@@ -3,9 +3,9 @@
 #include "render/decorations/CHyprDropShadowDecoration.hpp"
 
 CWindow::CWindow() {
-    m_vRealPosition.create(AVARTYPE_VECTOR, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), (void*) this, AVARDAMAGE_ENTIRE);
+    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_cRealBorderColor.create(AVARTYPE_COLOR, g_pConfigManager->getAnimationPropertyConfig("border"), (void*)this, AVARDAMAGE_BORDER);
+    m_fBorderAnimationProgress.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("border"), (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);
@@ -59,6 +59,13 @@ wlr_box CWindow::getWindowIdealBoundingBoxIgnoreReserved() {
     auto POS = m_vPosition;
     auto SIZE = m_vSize;
 
+    if (m_bIsFullscreen) {
+        POS = PMONITOR->vecPosition;
+        SIZE = PMONITOR->vecSize;
+
+        return wlr_box{(int)POS.x, (int)POS.y, (int)SIZE.x, (int)SIZE.y};
+    }
+
     if (DELTALESSTHAN(POS.y - PMONITOR->vecPosition.y, PMONITOR->vecReservedTopLeft.y, 1)) {
         POS.y = PMONITOR->vecPosition.y;
         SIZE.y += PMONITOR->vecReservedTopLeft.y;
@@ -244,3 +251,133 @@ void CWindow::removeDecorationByType(eDecorationType type) {
 
     updateWindowDecos();
 }
+
+void unregisterVar(void* ptr) {
+    ((CAnimatedVariable*)ptr)->unregister();
+}
+
+void CWindow::onUnmap() {
+    if (g_pCompositor->m_pLastWindow == this)
+        g_pCompositor->m_pLastWindow = nullptr;
+
+    m_vRealPosition.setCallbackOnEnd(unregisterVar);
+    m_vRealSize.setCallbackOnEnd(unregisterVar);
+    m_fBorderAnimationProgress.setCallbackOnEnd(unregisterVar);
+    m_fActiveInactiveAlpha.setCallbackOnEnd(unregisterVar);
+    m_fAlpha.setCallbackOnEnd(unregisterVar);
+    m_cRealShadowColor.setCallbackOnEnd(unregisterVar);
+    m_fDimPercent.setCallbackOnEnd(unregisterVar);
+
+    m_vRealSize.setCallbackOnBegin(nullptr);
+}
+
+void CWindow::onMap() {
+
+    // JIC, reset the callbacks. If any are set, we'll make sure they are cleared so we don't accidentally unset them. (In case a window got remapped)
+    m_vRealPosition.resetAllCallbacks();
+    m_vRealSize.resetAllCallbacks();
+    m_fBorderAnimationProgress.resetAllCallbacks();
+    m_fActiveInactiveAlpha.resetAllCallbacks();
+    m_fAlpha.resetAllCallbacks();
+    m_cRealShadowColor.resetAllCallbacks();
+    m_fDimPercent.resetAllCallbacks();
+
+    m_vRealPosition.registerVar();
+    m_vRealSize.registerVar();
+    m_fBorderAnimationProgress.registerVar();
+    m_fActiveInactiveAlpha.registerVar();
+    m_fAlpha.registerVar();
+    m_cRealShadowColor.registerVar();
+    m_fDimPercent.registerVar();
+
+    m_vRealSize.setCallbackOnEnd([&] (void* ptr) {
+        g_pHyprOpenGL->onWindowResizeEnd(this);
+    }, false);
+    m_vRealSize.setCallbackOnBegin([&] (void* ptr) {
+        g_pHyprOpenGL->onWindowResizeStart(this);
+    }, false);
+}
+
+void CWindow::setHidden(bool hidden) {
+    m_bHidden = hidden;
+
+    if (hidden && g_pCompositor->m_pLastWindow == this) {
+        g_pCompositor->m_pLastWindow = nullptr;
+    }
+}
+
+bool CWindow::isHidden() {
+    return m_bHidden;
+}
+
+void CWindow::applyDynamicRule(const SWindowRule& r) {
+    if (r.szRule == "noblur") {
+        m_sAdditionalConfigData.forceNoBlur = true;
+    } else if (r.szRule == "noborder") {
+        m_sAdditionalConfigData.forceNoBorder = true;
+    } else if (r.szRule == "noshadow") {
+        m_sAdditionalConfigData.forceNoShadow = true;
+    } else if (r.szRule == "opaque") {
+        if (!m_sAdditionalConfigData.forceOpaqueOverriden)
+            m_sAdditionalConfigData.forceOpaque = true;
+    } else if (r.szRule.find("rounding") == 0) {
+        try {
+            m_sAdditionalConfigData.rounding = std::stoi(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
+        } catch (std::exception& e) {
+            Debug::log(ERR, "Rounding rule \"%s\" failed with: %s", r.szRule.c_str(), e.what());
+        }
+    } else if (r.szRule.find("opacity") == 0) {
+        try {
+            std::string alphaPart = removeBeginEndSpacesTabs(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
+
+            if (alphaPart.contains(' ')) {
+                // we have a space, 2 values
+                m_sSpecialRenderData.alpha = std::stof(alphaPart.substr(0, alphaPart.find_first_of(' ')));
+                m_sSpecialRenderData.alphaInactive = std::stof(alphaPart.substr(alphaPart.find_first_of(' ') + 1));
+            } else {
+                m_sSpecialRenderData.alpha = std::stof(alphaPart);
+            }
+        } catch(std::exception& e) {
+            Debug::log(ERR, "Opacity rule \"%s\" failed with: %s", r.szRule.c_str(), e.what());
+        }
+        } else if (r.szRule == "noanim") {
+            m_sAdditionalConfigData.forceNoAnims = true;
+        }  else if (r.szRule.find("animation") == 0) {
+            auto STYLE = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
+            m_sAdditionalConfigData.animationStyle = STYLE;
+        } else if (r.szRule.find("bordercolor") == 0) {
+        try {
+            std::string colorPart = removeBeginEndSpacesTabs(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
+
+            if (colorPart.contains(' ')) {
+                // we have a space, 2 values
+                m_sSpecialRenderData.activeBorderColor = configStringToInt(colorPart.substr(0, colorPart.find_first_of(' ')));
+                m_sSpecialRenderData.inactiveBorderColor = configStringToInt(colorPart.substr(colorPart.find_first_of(' ') + 1));
+            } else {
+                m_sSpecialRenderData.activeBorderColor = configStringToInt(colorPart);
+            }
+        } catch(std::exception& e) {
+            Debug::log(ERR, "BorderColor rule \"%s\" failed with: %s", r.szRule.c_str(), e.what());
+        }
+    }
+}
+
+void CWindow::updateDynamicRules() {
+    m_sSpecialRenderData.activeBorderColor = -1;
+    m_sSpecialRenderData.inactiveBorderColor = -1;
+    m_sSpecialRenderData.alpha = 1.f;
+    m_sSpecialRenderData.alphaInactive = -1.f;
+    m_sAdditionalConfigData.forceNoBlur = false;
+    m_sAdditionalConfigData.forceNoBorder = false;
+    m_sAdditionalConfigData.forceNoShadow = false;
+    if (!m_sAdditionalConfigData.forceOpaqueOverriden)
+        m_sAdditionalConfigData.forceOpaque = false;
+    m_sAdditionalConfigData.forceNoAnims = false;
+    m_sAdditionalConfigData.animationStyle = "";
+    m_sAdditionalConfigData.rounding = -1;
+
+    const auto WINDOWRULES = g_pConfigManager->getMatchingRules(this);
+    for (auto& r : WINDOWRULES) {
+        applyDynamicRule(r);
+    }
+}

src/Window.hpp

@@ -6,11 +6,22 @@
 #include "helpers/AnimatedVariable.hpp"
 #include "render/decorations/IHyprWindowDecoration.hpp"
 #include <deque>
+#include "config/ConfigDataValues.hpp"
+
+enum eIdleInhibitMode {
+    IDLEINHIBIT_NONE = 0,
+    IDLEINHIBIT_ALWAYS,
+    IDLEINHIBIT_FULLSCREEN,
+    IDLEINHIBIT_FOCUS
+};
 
 struct SWindowSpecialRenderData {
     float alpha = 1.f;
     float alphaInactive = -1.f; // -1 means unset
 
+    int64_t activeBorderColor = -1; // -1 means unset
+    int64_t inactiveBorderColor = -1; // -1 means unset
+
     // set by the layout
     bool rounding = true;
     bool border = true;
@@ -22,8 +33,25 @@ struct SWindowAdditionalConfigData {
     int rounding = -1; // -1 means no
     bool forceNoBlur = false;
     bool forceOpaque = false;
+    bool forceOpaqueOverriden = false; // if true, a rule will not change the forceOpaque state. This is for the force opaque dispatcher.
     bool forceAllowsInput = false;
     bool forceNoAnims = false;
+    bool forceNoBorder = false;
+    bool forceNoShadow = false;
+    bool windowDanceCompat = false;
+};
+
+struct SWindowRule {
+    std::string szRule;
+    std::string szValue;
+
+    bool v2 = false;
+    std::string szTitle;
+    std::string szClass;
+    int bX11 = -1; // -1 means "ANY"
+    int bFloating = -1;
+    int bFullscreen = -1;
+    int bPinned = -1;
 };
 
 class CWindow {
@@ -103,13 +131,16 @@ public:
     bool            m_bNoFocus = false;
     bool            m_bNoInitialFocus = false;
 
-    // initial fullscreen
+    // initial fullscreen and fullscreen disabled
     bool            m_bWantsInitialFullscreen = false;
+    bool            m_bNoFullscreenRequest = false;
 
     SSurfaceTreeNode* m_pSurfaceTree = nullptr;
 
     // Animated border
-    CAnimatedVariable m_cRealBorderColor;
+    CGradientValueData m_cRealBorderColor = {0};
+    CGradientValueData m_cRealBorderColorPrevious = {0};
+    CAnimatedVariable  m_fBorderAnimationProgress;
 
     // Fade in-out
     CAnimatedVariable m_fAlpha;
@@ -118,9 +149,6 @@ public:
     Vector2D        m_vOriginalClosedPos; // these will be used for calculations later on in
     Vector2D        m_vOriginalClosedSize; // drawing the closing animations
 
-    // For hidden windows and stuff
-    bool            m_bHidden = false;
-
     // For pinned (sticky) windows
     bool            m_bPinned = false;
 
@@ -154,6 +182,9 @@ public:
     uint64_t          m_iLastToplevelMonitorID = -1;
     uint64_t          m_iLastSurfaceMonitorID = -1;
 
+    // for idle inhibiting windows
+    eIdleInhibitMode  m_eIdleInhibitMode = IDLEINHIBIT_NONE;
+
     // For the list lookup
     bool operator==(const CWindow& rhs) {
         return m_uSurface.xdg == rhs.m_uSurface.xdg && m_uSurface.xwayland == rhs.m_uSurface.xwayland && m_vPosition == rhs.m_vPosition && m_vSize == rhs.m_vSize && m_bFadingOut == rhs.m_bFadingOut;
@@ -172,4 +203,15 @@ public:
     void            updateSurfaceOutputs();
     void            moveToWorkspace(int);
     CWindow*        X11TransientFor();
+    void            onUnmap();
+    void            onMap();
+    void            setHidden(bool hidden);
+    bool            isHidden();
+    void            applyDynamicRule(const SWindowRule& r);
+    void            updateDynamicRules();
+
+private:
+    // For hidden windows and stuff
+    bool            m_bHidden = false;
+
 };

src/config/ConfigDataValues.hpp

@@ -0,0 +1,48 @@
+#pragma once
+#include "../defines.hpp"
+
+enum eConfigValueDataTypes {
+    CVD_TYPE_INVALID = -1,
+    CVD_TYPE_GRADIENT = 0
+};
+
+interface ICustomConfigValueData {
+public:
+    virtual ~ICustomConfigValueData() = 0;
+
+    virtual eConfigValueDataTypes getDataType() = 0;
+};
+
+class CGradientValueData : public ICustomConfigValueData {
+public:
+    CGradientValueData(CColor col) {
+        m_vColors.push_back(col);
+    };
+    virtual ~CGradientValueData() { };
+
+    virtual eConfigValueDataTypes getDataType() {
+        return CVD_TYPE_GRADIENT;
+    }
+
+    void reset(CColor col) {
+        m_vColors.clear();
+        m_vColors.emplace_back(col);
+        m_fAngle = 0;
+    }
+
+    /* Vector containing the colors */
+    std::vector<CColor> m_vColors;
+
+    /* Float corresponding to the angle (rad) */
+    float               m_fAngle = 0;
+
+    bool operator==(const CGradientValueData& other) {
+        if (other.m_vColors.size() != m_vColors.size() || m_fAngle != other.m_fAngle)
+            return false;
+
+        for (size_t i = 0; i < m_vColors.size(); ++i)
+            if (m_vColors[i] != other.m_vColors[i]) return false;
+
+        return true;
+    }
+};

src/config/ConfigManager.cpp

@@ -11,6 +11,9 @@
 #include <iostream>
 
 CConfigManager::CConfigManager() {
+    configValues["general:col.active_border"].data = std::make_shared<CGradientValueData>(0xffffffff);
+    configValues["general:col.inactive_border"].data = std::make_shared<CGradientValueData>(0xff444444);
+
     setDefaultVars();
     setDefaultAnimationVars();
 
@@ -35,15 +38,12 @@ void CConfigManager::setDefaultVars() {
     configValues["general:main_mod"].strValue = "SUPER";                                               // exposed to the user for easier configuring
     configValues["general:main_mod_internal"].intValue = g_pKeybindManager->stringToModMask("SUPER");  // actually used and automatically calculated
 
-    configValues["general:damage_tracking"].strValue = "full";
-    configValues["general:damage_tracking_internal"].intValue = DAMAGE_TRACKING_FULL;
-
     configValues["general:border_size"].intValue = 1;
     configValues["general:no_border_on_floating"].intValue = 0;
     configValues["general:gaps_in"].intValue = 5;
     configValues["general:gaps_out"].intValue = 20;
-    configValues["general:col.active_border"].intValue = 0xffffffff;
-    configValues["general:col.inactive_border"].intValue = 0xff444444;
+    ((CGradientValueData*)configValues["general:col.active_border"].data.get())->reset(0xffffffff);
+    ((CGradientValueData*)configValues["general:col.inactive_border"].data.get())->reset(0xff444444);
     configValues["general:cursor_inactive_timeout"].intValue = 0;
     configValues["general:no_cursor_warps"].intValue = 0;
 
@@ -60,6 +60,8 @@ void CConfigManager::setDefaultVars() {
     configValues["misc:disable_autoreload"].intValue = 0;
     configValues["misc:enable_swallow"].intValue = 0;
     configValues["misc:swallow_regex"].strValue = STRVAL_EMPTY;
+    configValues["misc:focus_on_activate"].intValue = 0;
+    configValues["misc:no_direct_scanout"].intValue = 0;
 
     configValues["debug:int"].intValue = 0;
     configValues["debug:log_damage"].intValue = 0;
@@ -67,13 +69,15 @@ void CConfigManager::setDefaultVars() {
     configValues["debug:damage_blink"].intValue = 0;
     configValues["debug:disable_logs"].intValue = 0;
     configValues["debug:disable_time"].intValue = 1;
+    configValues["debug:damage_tracking"].intValue = DAMAGE_TRACKING_FULL;
 
     configValues["decoration:rounding"].intValue = 0;
     configValues["decoration:blur"].intValue = 1;
     configValues["decoration:blur_size"].intValue = 8;
     configValues["decoration:blur_passes"].intValue = 1;
     configValues["decoration:blur_ignore_opacity"].intValue = 0;
-    configValues["decoration:blur_new_optimizations"].intValue = 0;
+    configValues["decoration:blur_new_optimizations"].intValue = 1;
+    configValues["decoration:blur_xray"].intValue = 0;
     configValues["decoration:active_opacity"].floatValue = 1;
     configValues["decoration:inactive_opacity"].floatValue = 1;
     configValues["decoration:fullscreen_opacity"].floatValue = 1;
@@ -84,10 +88,12 @@ void CConfigManager::setDefaultVars() {
     configValues["decoration:shadow_render_power"].intValue = 3;
     configValues["decoration:shadow_ignore_window"].intValue = 1;
     configValues["decoration:shadow_offset"].vecValue = Vector2D();
+    configValues["decoration:shadow_scale"].floatValue = 1.f;
     configValues["decoration:col.shadow"].intValue = 0xee1a1a1a;
     configValues["decoration:col.shadow_inactive"].intValue = INT_MAX;
     configValues["decoration:dim_inactive"].intValue = 0;
     configValues["decoration:dim_strength"].floatValue = 0.5f;
+    configValues["decoration:screen_shader"].strValue = STRVAL_EMPTY;
 
     configValues["dwindle:pseudotile"].intValue = 0;
     configValues["dwindle:col.group_border"].intValue = 0x66777700;
@@ -140,6 +146,7 @@ void CConfigManager::setDefaultVars() {
     configValues["input:float_switch_override_focus"].intValue = 1;
     configValues["input:left_handed"].intValue = 0;
     configValues["input:scroll_method"].strValue = STRVAL_EMPTY;
+    configValues["input:scroll_button"].intValue = 0;
     configValues["input:touchpad:natural_scroll"].intValue = 0;
     configValues["input:touchpad:disable_while_typing"].intValue = 1;
     configValues["input:touchpad:clickfinger_behavior"].intValue = 0;
@@ -147,6 +154,8 @@ void CConfigManager::setDefaultVars() {
     configValues["input:touchpad:tap-to-click"].intValue = 1;
     configValues["input:touchpad:drag_lock"].intValue = 0;
     configValues["input:touchpad:scroll_factor"].floatValue = 1.f;
+    configValues["input:touchdevice:transform"].intValue = 0;
+    configValues["input:touchdevice:output"].strValue = STRVAL_EMPTY;
 
     configValues["binds:pass_mouse_when_bound"].intValue = 0;
     configValues["binds:scroll_event_delay"].intValue = 300;
@@ -159,6 +168,8 @@ void CConfigManager::setDefaultVars() {
     configValues["gestures:workspace_swipe_invert"].intValue = 1;
     configValues["gestures:workspace_swipe_min_speed_to_force"].intValue = 30;
     configValues["gestures:workspace_swipe_cancel_ratio"].floatValue = 0.5f;
+    configValues["gestures:workspace_swipe_create_new"].intValue = 1;
+    configValues["gestures:workspace_swipe_forever"].intValue = 0;
 
     configValues["input:follow_mouse"].intValue = 1;
 
@@ -187,6 +198,10 @@ void CConfigManager::setDeviceDefaultVars(const std::string& dev) {
     cfgValues["drag_lock"].intValue = 0;
     cfgValues["left_handed"].intValue = 0;
     cfgValues["scroll_method"].strValue = STRVAL_EMPTY;
+    cfgValues["scroll_button"].intValue = 0;
+    cfgValues["touch_transform"].intValue = 0;
+    cfgValues["touch_output"].strValue = STRVAL_EMPTY;
+    cfgValues["enabled"].intValue = 1; // only for mice / touchpads
 }
 
 void CConfigManager::setDefaultAnimationVars() {
@@ -303,20 +318,10 @@ void CConfigManager::configSetValueSafe(const std::string& COMMAND, const std::s
 
     if (CONFIGENTRY->intValue != -INT64_MAX) {
         try {
-            if (VALUE.find("0x") == 0) {
-                // Values with 0x are hex
-                const auto VALUEWITHOUTHEX = VALUE.substr(2);
-                CONFIGENTRY->intValue = stol(VALUEWITHOUTHEX, nullptr, 16);
-            } else if (VALUE.find("true") == 0 || VALUE.find("on") == 0 || VALUE.find("yes") == 0) {
-                CONFIGENTRY->intValue = 1;
-            } else if (VALUE.find("false") == 0 || VALUE.find("off") == 0 || VALUE.find("no") == 0) {
-                CONFIGENTRY->intValue = 0;
-            }
-            else
-                CONFIGENTRY->intValue = stol(VALUE);
-        } catch (...) {
+            CONFIGENTRY->intValue = configStringToInt(VALUE);
+        } catch (std::exception& e) {
             Debug::log(WARN, "Error reading value of %s", COMMAND.c_str());
-            parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">.";
+            parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">. " + e.what();
         }
     } else if (CONFIGENTRY->floatValue != -__FLT_MAX__) {
         try {
@@ -349,67 +354,77 @@ void CConfigManager::configSetValueSafe(const std::string& COMMAND, const std::s
             Debug::log(WARN, "Error reading value of %s", COMMAND.c_str());
             parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">.";
         }
+    } else if (CONFIGENTRY->data.get() != nullptr) {
+
+        switch (CONFIGENTRY->data->getDataType()) {
+            case CVD_TYPE_GRADIENT: {
+                
+                CVarList varlist(VALUE, 0, ' ');
+
+                CGradientValueData* data = (CGradientValueData*)CONFIGENTRY->data.get();
+                data->m_vColors.clear();
+
+                for (auto& var : varlist) {
+                    if (var.find("deg") != std::string::npos) {
+                        // last arg
+                        try {
+                            data->m_fAngle = std::stoi(var.substr(0, var.find("deg"))) * (PI / 180.0); // radians
+                        } catch (...) {
+                            Debug::log(WARN, "Error reading value of %s", COMMAND.c_str());
+                            parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">.";
+                        }
+
+                        break;
+                    }
+
+                    if (data->m_vColors.size() >= 10) {
+                        Debug::log(WARN, "Error reading value of %s", COMMAND.c_str());
+                        parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">. Max colors in a gradient is 10.";
+                        break;
+                    }
+
+                    try {
+                        data->m_vColors.push_back(CColor(configStringToInt(var)) * (1.f / 255.f));
+                    } catch (std::exception& e) {
+                        Debug::log(WARN, "Error reading value of %s", COMMAND.c_str());
+                        parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">. " + e.what();
+                    }
+                }
+
+                if (data->m_vColors.size() == 0) {
+                    Debug::log(WARN, "Error reading value of %s", COMMAND.c_str());
+                    parseError = "Error setting value <" + VALUE + "> for field <" + COMMAND + ">. No colors provided.";
+
+                    data->m_vColors.push_back(0); // transparent
+                }
+
+                break;
+            }
+            default: {
+                UNREACHABLE();
+            }
+        }
+    }
+
+    if (COMMAND == "decoration:screen_shader") {
+        const auto PATH = absolutePath(VALUE, configCurrentPath);
+
+        configPaths.push_back(PATH);
+
+        struct stat fileStat;
+        int err = stat(PATH.c_str(), &fileStat);
+        if (err != 0) {
+            Debug::log(WARN, "Error at ticking config at %s, error %i: %s", PATH.c_str(), err, strerror(err));
+            return;
+        }
+
+        configModifyTimes[PATH] = fileStat.st_mtime;
     }
 }
 
 void CConfigManager::handleRawExec(const std::string& command, const std::string& args) {
     // Exec in the background dont wait for it.
-
-    std::string toExec = args;
-
-    if (g_pXWaylandManager->m_sWLRXWayland)
-        toExec = std::string("WAYLAND_DISPLAY=") + std::string(g_pCompositor->m_szWLDisplaySocket) + " DISPLAY=" + std::string(g_pXWaylandManager->m_sWLRXWayland->display_name) + " " + toExec;
-    else
-        toExec = std::string("WAYLAND_DISPLAY=") + std::string(g_pCompositor->m_szWLDisplaySocket) + " " + toExec;
-
-    Debug::log(LOG, "Config executing %s", toExec.c_str());
-
-    int socket[2];
-    if (pipe(socket) != 0) {
-        Debug::log(LOG, "Unable to create pipe for fork");
-    }
-
-    pid_t child, grandchild;
-    child = fork();
-    if (child < 0) {
-        close(socket[0]);
-        close(socket[1]);
-        Debug::log(LOG, "Fail to create the first fork");
-        return;
-    }
-    if (child == 0) {
-        // run in child
-        grandchild = fork();
-
-        sigset_t set;
-        sigemptyset(&set);
-        sigprocmask(SIG_SETMASK, &set, NULL);
-
-        if (grandchild == 0) {
-            // run in grandchild
-            close(socket[0]);
-            close(socket[1]);
-            execl("/bin/sh", "/bin/sh", "-c", args.c_str(), nullptr);
-            // exit grandchild
-            _exit(0);
-        }
-        close(socket[0]);
-        write(socket[1], &grandchild, sizeof(grandchild));
-        close(socket[1]);
-        // exit child
-        _exit(0);
-    }
-    // run in parent
-    close(socket[1]);
-    read(socket[0], &grandchild, sizeof(grandchild));
-    close(socket[0]);
-    // clear child and leave child to init
-    waitpid(child, NULL, 0);
-    if (child < 0) {
-        Debug::log(LOG, "Fail to create the second fork");
-        return;
-    }
-    Debug::log(LOG, "Process created with pid %d", grandchild);
+    g_pKeybindManager->spawn(args);
 }
 
 void CConfigManager::handleMonitor(const std::string& command, const std::string& args) {
@@ -500,6 +515,9 @@ void CConfigManager::handleMonitor(const std::string& command, const std::string
         if (ARGS[argno] == "mirror") {
             newrule.mirrorOf = ARGS[argno + 1];
             argno++;
+        } else if (ARGS[argno] == "bitdepth") {
+            newrule.enable10bit = ARGS[argno + 1] == "10";
+            argno++;
         } else {
             Debug::log(ERR, "Config error: invalid monitor syntax");
             parseError = "invalid syntax at \"" + ARGS[argno] + "\"";
@@ -718,19 +736,26 @@ bool windowRuleValid(const std::string& RULE) {
         && RULE.find("move") != 0
         && RULE.find("size") != 0
         && RULE.find("minsize") != 0
+        && RULE.find("maxsize") != 0
         && RULE.find("pseudo") != 0
         && RULE.find("monitor") != 0
+        && RULE.find("idleinhibit") != 0
         && RULE != "nofocus"
         && RULE != "noblur"
+        && RULE != "noshadow"
+        && RULE != "noborder"
         && RULE != "center"
         && RULE != "opaque"
         && RULE != "forceinput"
         && RULE != "fullscreen"
+        && RULE != "nofullscreenrequest"
         && RULE != "pin"
         && RULE != "noanim"
+        && RULE != "windowdance"
         && RULE.find("animation") != 0
         && RULE.find("rounding") != 0
-        && RULE.find("workspace") != 0);
+        && RULE.find("workspace") != 0
+        && RULE.find("bordercolor") != 0);
 }
 
 void CConfigManager::handleWindowRule(const std::string& command, const std::string& value) {
@@ -742,6 +767,13 @@ void CConfigManager::handleWindowRule(const std::string& command, const std::str
         return;
     }
 
+    if (RULE == "unset") {
+        std::erase_if(m_dWindowRules, [&] (const SWindowRule& other) {
+            return other.szValue == VALUE;
+        });
+        return;
+    }
+
     // verify we support a rule
     if (!windowRuleValid(RULE)) {
         Debug::log(ERR, "Invalid rule found: %s", RULE.c_str());
@@ -756,7 +788,7 @@ void CConfigManager::handleWindowRuleV2(const std::string& command, const std::s
     const auto RULE = value.substr(0, value.find_first_of(","));
     const auto VALUE = value.substr(value.find_first_of(",") + 1);
 
-    if (!windowRuleValid(RULE)) {
+    if (!windowRuleValid(RULE) && RULE != "unset") {
         Debug::log(ERR, "Invalid rulev2 found: %s", RULE.c_str());
         parseError = "Invalid rulev2 found: " + RULE;
         return;
@@ -772,8 +804,12 @@ void CConfigManager::handleWindowRuleV2(const std::string& command, const std::s
     const auto CLASSPOS = VALUE.find("class:");
     const auto X11POS   = VALUE.find("xwayland:");
     const auto FLOATPOS = VALUE.find("floating:");
+    const auto FULLSCREENPOS = VALUE.find("fullscreen:");
+    const auto PINNEDPOS = VALUE.find("pinned:");
 
-    if (TITLEPOS == std::string::npos && CLASSPOS == std::string::npos && X11POS == std::string::npos && FLOATPOS == std::string::npos) {
+    if (TITLEPOS == std::string::npos && CLASSPOS == std::string::npos &&
+        X11POS == std::string::npos && FLOATPOS == std::string::npos &&
+        FULLSCREENPOS == std::string::npos && PINNEDPOS == std::string::npos) {
         Debug::log(ERR, "Invalid rulev2 syntax: %s", VALUE.c_str());
         parseError = "Invalid rulev2 syntax: " + VALUE;
         return;
@@ -788,6 +824,8 @@ void CConfigManager::handleWindowRuleV2(const std::string& command, const std::s
         if (CLASSPOS > pos && CLASSPOS < min) min = CLASSPOS;
         if (X11POS > pos && X11POS < min) min = X11POS;
         if (FLOATPOS > pos && FLOATPOS < min) min = FLOATPOS;
+        if (FULLSCREENPOS > pos && FULLSCREENPOS < min) min = FULLSCREENPOS;
+        if (PINNEDPOS > pos && PINNEDPOS < min) min = PINNEDPOS;
 
         result = result.substr(0, min - pos);
 
@@ -815,13 +853,56 @@ void CConfigManager::handleWindowRuleV2(const std::string& command, const std::s
         rule.bFloating = extract(FLOATPOS + 9) == "1" ? 1 : 0;
     }
 
+    if (FULLSCREENPOS != std::string::npos) {
+        rule.bFullscreen = extract(FULLSCREENPOS + 11) == "1" ? 1 : 0;
+    }
+
+    if (PINNEDPOS != std::string::npos) {
+        rule.bPinned = extract(PINNEDPOS + 7) == "1" ? 1 : 0;
+    }
+
+    if (RULE == "unset") {
+        std::erase_if(m_dWindowRules, [&](const SWindowRule& other) {
+            if (!other.v2) {
+                return other.szClass == rule.szClass && !rule.szClass.empty();
+            } else {
+                if (!rule.szClass.empty() && rule.szClass != other.szClass) {
+                    return false;
+                }
+
+                if (!rule.szTitle.empty() && rule.szTitle != other.szTitle) {
+                    return false;
+                }
+
+                if (rule.bX11 != -1 && rule.bX11 != other.bX11) {
+                    return false;
+                }
+
+                if (rule.bFloating != -1 && rule.bFloating != other.bFloating) {
+                    return false;
+                }
+
+                if (rule.bFullscreen != -1 && rule.bFullscreen != other.bFullscreen) {
+                    return false;
+                }
+
+                if (rule.bPinned != -1 && rule.bPinned != other.bPinned) {
+                    return false;
+                }
+
+                return true;
+            }
+        });
+        return;
+    }
+
     m_dWindowRules.push_back(rule);
 }
 
 void CConfigManager::handleBlurLS(const std::string& command, const std::string& value) {
     if (value.find("remove,") == 0) {
         const auto TOREMOVE = removeBeginEndSpacesTabs(value.substr(7));
-        m_dBlurLSNamespaces.erase(std::remove(m_dBlurLSNamespaces.begin(), m_dBlurLSNamespaces.end(), TOREMOVE));
+        std::erase_if(m_dBlurLSNamespaces, [&] (const auto& other) { return other == TOREMOVE; });
         return;
     }
 
@@ -919,6 +1000,8 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
         currentCategory = "";
     }
 
+    int needsLayoutRecalc = COMMAND == "monitor"; // 0 - no, 1 - yes, 2 - maybe
+
     if (COMMAND == "exec") {
         if (isFirstLaunch) {
             firstExecRequests.push_back(VALUE);
@@ -942,16 +1025,22 @@ std::string CConfigManager::parseKeyword(const std::string& COMMAND, const std::
     else if (COMMAND == "submap") handleSubmap(COMMAND, VALUE);
     else if (COMMAND == "blurls") handleBlurLS(COMMAND, VALUE);
     else if (COMMAND == "wsbind") handleBindWS(COMMAND, VALUE);
-    else
+    else {
         configSetValueSafe(currentCategory + (currentCategory == "" ? "" : ":") + COMMAND, VALUE);
+        needsLayoutRecalc = 2;
+    }
 
     if (dynamic) {
         std::string retval = parseError;
         parseError = "";
 
-        // invalidate layouts jic
-        for (auto& m : g_pCompositor->m_vMonitors)
-            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
+        // invalidate layouts if they changed
+        if (needsLayoutRecalc) {
+            if (needsLayoutRecalc == 1 || COMMAND.contains("gaps_") || COMMAND.find("dwindle:") == 0 || COMMAND.find("master:") == 0) {
+                for (auto& m : g_pCompositor->m_vMonitors)
+                    g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
+            }
+        }
 
         // Update window border colors
         g_pCompositor->updateAllWindowsAnimatedDecorationValues();
@@ -981,13 +1070,26 @@ void CConfigManager::applyUserDefinedVars(std::string& line, const size_t equals
 
 void CConfigManager::parseLine(std::string& line) {
     // first check if its not a comment
-    const auto COMMENTSTART = line.find_first_of('#');
-    if (COMMENTSTART == 0)
+    if (line[0] == '#')
         return;
 
-    // now, cut the comment off
-    if (COMMENTSTART != std::string::npos)
-        line = line.substr(0, COMMENTSTART);
+    // now, cut the comment off. ## is an escape.
+    for (long unsigned int i = 1; i < line.length(); ++i) {
+        if (line[i] == '#') {
+            if (i + 1 < line.length() && line[i + 1] != '#') {
+                line = line.substr(0, i);
+                break; // no need to parse more
+            }
+
+            i++;
+        }
+    }
+
+    size_t startPos = 0;
+    while ((startPos = line.find("##", startPos)) != std::string::npos && startPos < line.length() - 1 && startPos > 0) {
+        line.replace(startPos, 2, "#");
+        startPos++;
+    }
 
     // remove shit at the beginning
     while (line[0] == ' ' || line[0] == '\t') {
@@ -1139,17 +1241,14 @@ void CConfigManager::loadConfigLoadVars() {
     if (!isFirstLaunch) {
         g_pInputManager->setKeyboardLayout();
         g_pInputManager->setPointerConfigs();
+        g_pInputManager->setTouchDeviceConfigs();
     }
 
     // Calculate the internal vars
     configValues["general:main_mod_internal"].intValue = g_pKeybindManager->stringToModMask(configValues["general:main_mod"].strValue);
-    const auto DAMAGETRACKINGMODE = g_pHyprRenderer->damageTrackingModeFromStr(configValues["general:damage_tracking"].strValue);
-    if (DAMAGETRACKINGMODE != DAMAGE_TRACKING_INVALID)
-        configValues["general:damage_tracking_internal"].intValue = DAMAGETRACKINGMODE;
-    else {
-        parseError = "invalid value for general:damage_tracking, supported: full, monitor, none";
-        configValues["general:damage_tracking_internal"].intValue = DAMAGE_TRACKING_NONE;
-    }
+
+    if (!isFirstLaunch)
+        g_pHyprOpenGL->m_bReloadScreenShader = true;
 
     // parseError will be displayed next frame
     if (parseError != "")
@@ -1164,10 +1263,10 @@ void CConfigManager::loadConfigLoadVars() {
     // and they'll be taken care of in the newMonitor event
     // ignore if nomonitorreload is set
     if (!isFirstLaunch && !m_bNoMonitorReload) {
-        m_bWantsMonitorReload = true;
-
         // check
+        performMonitorReload();
         ensureDPMS();
+        ensureVRR();
     }
 
     // Update window border colors
@@ -1234,13 +1333,10 @@ SConfigValue CConfigManager::getConfigValueSafe(const std::string& val) {
 SConfigValue CConfigManager::getConfigValueSafeDevice(const std::string& dev, const std::string& val) {
     std::lock_guard<std::mutex> lg(configmtx);
 
-    auto devcopy = dev;
-    std::replace(devcopy.begin(), devcopy.end(), ' ', '-');
-
-    const auto it = deviceConfigs.find(devcopy);
+    const auto it = deviceConfigs.find(dev);
 
     if (it == deviceConfigs.end()) {
-        Debug::log(ERR, "getConfigValueSafeDevice: No device config for %s found???", devcopy.c_str());
+        Debug::log(ERR, "getConfigValueSafeDevice: No device config for %s found???", dev.c_str());
         return SConfigValue();
     }
 
@@ -1394,6 +1490,16 @@ std::vector<SWindowRule> CConfigManager::getMatchingRules(CWindow* pWindow) {
                     if (pWindow->m_bIsFloating != rule.bFloating)
                         continue;
                 }
+
+                if (rule.bFullscreen != -1) {
+                    if (pWindow->m_bIsFullscreen != rule.bFullscreen)
+                        continue;
+                }
+
+                if (rule.bPinned != -1) {
+                    if (pWindow->m_bPinned != rule.bPinned)
+                        continue;
+                }
             } catch (...) {
                 Debug::log(ERR, "Regex error at %s", rule.szValue.c_str());
                 continue;
@@ -1406,6 +1512,19 @@ std::vector<SWindowRule> CConfigManager::getMatchingRules(CWindow* pWindow) {
         returns.push_back(rule);
     }
 
+    const uint64_t PID = pWindow->getPID();
+    bool anyExecFound = false;
+
+    for (auto& er : execRequestedRules) {
+        if (er.iPid == PID) {
+            returns.push_back({er.szRule, "execRule"});
+            anyExecFound = true;
+        }
+    }
+
+    if (anyExecFound) // remove exec rules to unclog searches in the future, why have the garbage here.
+        execRequestedRules.erase(std::remove_if(execRequestedRules.begin(), execRequestedRules.end(), [&](const SExecRequestedRule& other) { return other.iPid == PID; }));
+
     return returns;
 }
 
@@ -1424,6 +1543,7 @@ void CConfigManager::dispatchExecOnce() {
     // set input, fixes some certain issues
     g_pInputManager->setKeyboardLayout();
     g_pInputManager->setPointerConfigs();
+    g_pInputManager->setTouchDeviceConfigs();
 
     // set ws names again
     for (auto& ws : g_pCompositor->m_vWorkspaces) {
@@ -1438,20 +1558,23 @@ void CConfigManager::performMonitorReload() {
     for (auto& m : g_pCompositor->m_vRealMonitors) {
         auto rule = getMonitorRuleFor(m->szName, m->output->description ? m->output->description : "");
 
-        // ensure mirror
-        m->setMirror(rule.mirrorOf);
-
         if (!g_pHyprRenderer->applyMonitorRule(m.get(), &rule)) {
             overAgain = true;
             break;
         }
 
+        // ensure mirror
+        m->setMirror(rule.mirrorOf);
+
         g_pHyprRenderer->arrangeLayersForMonitor(m->ID);
     }
 
     if (overAgain)
         performMonitorReload();
 
+    if (!g_pCompositor->m_vMonitors.empty()) // reset unsafe state if we have monitors
+        g_pCompositor->m_bUnsafeState = false;
+
     m_bWantsMonitorReload = false;
 }
 
@@ -1498,6 +1621,49 @@ void CConfigManager::ensureDPMS() {
     }
 }
 
+void CConfigManager::ensureVRR(CMonitor* pMonitor) {
+    static auto *const PNOVRR = &getConfigValuePtr("misc:no_vfr")->intValue;
+
+    auto ensureVRRForDisplay = [&](CMonitor* m) -> void {
+        if (!*PNOVRR && !m->vrrActive) {
+            // Adaptive sync (VRR)
+            wlr_output_enable_adaptive_sync(m->output, 1);
+
+            if (!wlr_output_test(m->output)) {
+                Debug::log(LOG, "Pending output %s does not accept VRR.", m->output->name);
+                wlr_output_enable_adaptive_sync(m->output, 0);
+            }
+
+            if (!wlr_output_commit(m->output)) {
+                Debug::log(ERR, "Couldn't commit output %s in ensureVRR -> true", m->output->name);
+            }
+
+            m->vrrActive = true;
+
+            Debug::log(LOG, "VRR ensured on %s -> true", m->output->name);
+        } else if (*PNOVRR && m->vrrActive) {
+            wlr_output_enable_adaptive_sync(m->output, 0);
+
+            if (!wlr_output_commit(m->output)) {
+                Debug::log(ERR, "Couldn't commit output %s in ensureVRR -> false", m->output->name);
+            }
+
+            m->vrrActive = false;
+
+            Debug::log(LOG, "VRR ensured on %s -> false", m->output->name);
+        }
+    };
+
+    if (pMonitor) {
+        ensureVRRForDisplay(pMonitor);
+        return;
+    }
+
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        ensureVRRForDisplay(m.get());
+    }
+}
+
 SAnimationPropertyConfig* CConfigManager::getAnimationPropertyConfig(const std::string& name) {
     return &animationConfig[name];
 }
@@ -1505,6 +1671,8 @@ SAnimationPropertyConfig* CConfigManager::getAnimationPropertyConfig(const std::
 void CConfigManager::addParseError(const std::string& err) {
     if (parseError == "")
         parseError = err;
+
+    g_pHyprError->queueCreate(parseError + "\nHyprland may not work correctly.", CColor(255, 50, 50, 255));
 }
 
 CMonitor* CConfigManager::getBoundMonitorForWS(std::string wsname) {
@@ -1518,3 +1686,11 @@ CMonitor* CConfigManager::getBoundMonitorForWS(std::string wsname) {
 
     return nullptr;
 }
+
+void CConfigManager::addExecRule(SExecRequestedRule rule) {
+    execRequestedRules.push_back(rule);
+}
+
+ICustomConfigValueData::~ICustomConfigValueData() {
+    ; // empty
+}

src/config/ConfigManager.hpp

@@ -13,6 +13,7 @@
 #include "../Window.hpp"
 
 #include "defaultConfig.hpp"
+#include "ConfigDataValues.hpp"
 
 #define STRVAL_EMPTY "[[EMPTY]]"
 
@@ -24,6 +25,7 @@ struct SConfigValue {
     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
 };
@@ -38,6 +40,7 @@ struct SMonitorRule {
     bool        disabled = false;
     wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;
     std::string mirrorOf = "";
+    bool        enable10bit = false;
 };
 
 struct SMonitorAdditionalReservedArea {
@@ -47,17 +50,6 @@ struct SMonitorAdditionalReservedArea {
     int         right = 0;
 };
 
-struct SWindowRule {
-    std::string szRule;
-    std::string szValue;
-
-    bool v2 = false;
-    std::string szTitle;
-    std::string szClass;
-    int bX11 = -1; // -1 means "ANY"
-    int bFloating = -1;
-};
-
 struct SAnimationPropertyConfig {
     bool            overriden = true;
 
@@ -70,14 +62,19 @@ struct SAnimationPropertyConfig {
     SAnimationPropertyConfig* pParentAnimation = nullptr;
 };
 
+struct SExecRequestedRule {
+    std::string     szRule = "";
+    uint64_t        iPid = 0;
+};
+
 class CVarList {
 public:
-    CVarList(const std::string& in, long unsigned int lastArgNo = 0) {
+    CVarList(const std::string& in, long unsigned int lastArgNo = 0, const char separator = ',') {
         std::string curitem = "";
         std::string argZ = in;
 
         auto nextItem = [&]() {
-            auto idx = lastArgNo != 0 && m_vArgs.size() >= lastArgNo - 1 ? std::string::npos : argZ.find_first_of(',');
+            auto idx = lastArgNo != 0 && m_vArgs.size() >= lastArgNo - 1 ? std::string::npos : argZ.find_first_of(separator);
 
             if (idx != std::string::npos) {
                 curitem = argZ.substr(0, idx);
@@ -108,7 +105,13 @@ public:
         return m_vArgs[idx];
     }
 
-private:
+    // for range-based loops
+    std::vector<std::string>::iterator begin() { return m_vArgs.begin(); }
+    std::vector<std::string>::const_iterator begin() const { return m_vArgs.begin(); }
+    std::vector<std::string>::iterator end() { return m_vArgs.end(); }
+    std::vector<std::string>::const_iterator end() const { return m_vArgs.end(); }
+
+  private:
     std::vector<std::string> m_vArgs;
 };
 
@@ -151,6 +154,7 @@ public:
     bool                m_bForceReload = false;
     bool                m_bNoMonitorReload = false;
     void                ensureDPMS();
+    void                ensureVRR(CMonitor* pMonitor = nullptr);
 
     std::string         parseKeyword(const std::string&, const std::string&, bool dynamic = false);
 
@@ -158,6 +162,8 @@ public:
 
     SAnimationPropertyConfig* getAnimationPropertyConfig(const std::string&);
 
+    void                addExecRule(SExecRequestedRule);
+
     std::string                                   configCurrentPath;
 
 private:
@@ -177,6 +183,8 @@ private:
 
     std::vector<std::pair<std::string, std::string>> boundWorkspaces;
 
+    std::vector<SExecRequestedRule>               execRequestedRules; // rules requested with exec, e.g. [workspace 2] kitty
+
     bool isFirstLaunch = true;  // For exec-once
 
     std::deque<SMonitorRule> m_dMonitorRules;

src/config/defaultConfig.hpp

@@ -9,121 +9,160 @@ 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.
-# For a full list, see the wiki (basic and advanced configuring)
+# For a full list, see the wiki
 #
 
-autogenerated=1 # remove this line to get rid of the warning on top.
+autogenerated = 1 # remove this line to remove the warning
 
+# See https://wiki.hyprland.org/Configuring/Monitors/
 monitor=,preferred,auto,1
 
-input {
-    kb_file=
-    kb_layout=
-    kb_variant=
-    kb_model=
-    kb_options=
-    kb_rules=
 
-    follow_mouse=1
+# See https://wiki.hyprland.org/Configuring/Keywords/ for more
+
+# Execute your favorite apps at launch
+# exec-once = waybar & hyprpaper & firefox
+
+# Source a file (multi-file configs)
+# source = ~/.config/hypr/myColors.conf
+
+# For all categories, see https://wiki.hyprland.org/Configuring/Variables/
+input {
+    kb_layout = us
+    kb_variant =
+    kb_model =
+    kb_options =
+    kb_rules =
+
+    follow_mouse = 1
 
     touchpad {
-        natural_scroll=no
+        natural_scroll = no
     }
 
-    sensitivity=0 # -1.0 - 1.0, 0 means no modification.
+    sensitivity = 0 # -1.0 - 1.0, 0 means no modification.
 }
 
 general {
-    main_mod=SUPER
+    # See https://wiki.hyprland.org/Configuring/Variables/ for more
 
-    gaps_in=5
-    gaps_out=20
-    border_size=2
-    col.active_border=0x66ee1111
-    col.inactive_border=0x66333333
+    gaps_in = 5
+    gaps_out = 20
+    border_size = 2
+    col.active_border = rgba(33ccffee) rgba(00ff99ee) 45deg
+    col.inactive_border = rgba(595959aa)
 
-    apply_sens_to_raw=0 # whether to apply the sensitivity to raw input (e.g. used by games where you aim using your mouse)
-
-    damage_tracking=full # leave it on full unless you hate your GPU and want to make it suffer
+    layout = dwindle
 }
 
 decoration {
-    rounding=10
-    blur=1
-    blur_size=3 # minimum 1
-    blur_passes=1 # minimum 1
-    blur_new_optimizations=1
+    # See https://wiki.hyprland.org/Configuring/Variables/ for more
+
+    rounding = 10
+    blur = yes
+    blur_size = 3
+    blur_passes = 1
+    blur_new_optimizations = on
+
+    drop_shadow = yes
+    shadow_range = 4
+    shadow_render_power = 3
+    col.shadow = rgba(1a1a1aee)
 }
 
 animations {
-    enabled=1
-    animation=windows,1,7,default
-    animation=border,1,10,default
-    animation=fade,1,10,default
-    animation=workspaces,1,6,default
+    enabled = yes
+
+    # Some default animations, see https://wiki.hyprland.org/Configuring/Animations/ for more
+
+    bezier = myBezier, 0.05, 0.9, 0.1, 1.05
+
+    animation = windows, 1, 7, myBezier
+    animation = windowsOut, 1, 7, default, popin 80%
+    animation = border, 1, 10, default
+    animation = fade, 1, 7, default
+    animation = workspaces, 1, 6, default
 }
 
 dwindle {
-    pseudotile=0 # enable pseudotiling on dwindle
+    # See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
+    pseudotile = yes # master switch for pseudotiling. Enabling is bound to mainMod + P in the keybinds section below
+    preserve_split = yes # you probably want this
+}
+
+master {
+    # See https://wiki.hyprland.org/Configuring/Master-Layout/ for more
+    new_is_master = true
 }
 
 gestures {
-    workspace_swipe=no
+    # See https://wiki.hyprland.org/Configuring/Variables/ for more
+    workspace_swipe = off
 }
 
-# example window rules
-# for windows named/classed as abc and xyz
-#windowrule=move 69 420,abc
-#windowrule=size 420 69,abc
-#windowrule=tile,xyz
-#windowrule=float,abc
-#windowrule=pseudo,abc
-#windowrule=monitor 0,xyz
+# Example per-device config
+# See https://wiki.hyprland.org/Configuring/Keywords/#executing for more
+device:epic mouse V1 {
+    sensitivity = -0.5
+}
 
-# some nice mouse binds
-bindm=SUPER,mouse:272,movewindow
-bindm=SUPER,mouse:273,resizewindow
+# Example windowrule v1
+# windowrule = float, ^(kitty)$
+# Example windowrule v2
+# windowrulev2 = float,class:^(kitty)$,title:^(kitty)$
+# See https://wiki.hyprland.org/Configuring/Window-Rules/ for more
 
-# example binds
-bind=SUPER,Q,exec,kitty
-bind=SUPER,RETURN,exec,alacritty
-bind=SUPER,C,killactive,
-bind=SUPER,M,exit,
-bind=SUPER,E,exec,dolphin
-bind=SUPER,V,togglefloating,
-bind=SUPER,R,exec,wofi --show drun -o DP-3
-bind=SUPER,P,pseudo,
 
-bind=SUPER,left,movefocus,l
-bind=SUPER,right,movefocus,r
-bind=SUPER,up,movefocus,u
-bind=SUPER,down,movefocus,d
+# See https://wiki.hyprland.org/Configuring/Keywords/ for more
+$mainMod = SUPER
 
-bind=SUPER,1,workspace,1
-bind=SUPER,2,workspace,2
-bind=SUPER,3,workspace,3
-bind=SUPER,4,workspace,4
-bind=SUPER,5,workspace,5
-bind=SUPER,6,workspace,6
-bind=SUPER,7,workspace,7
-bind=SUPER,8,workspace,8
-bind=SUPER,9,workspace,9
-bind=SUPER,0,workspace,10
+# Example binds, see https://wiki.hyprland.org/Configuring/Binds/ for more
+bind = $mainMod, Q, exec, kitty
+bind = $mainMod, C, killactive, 
+bind = $mainMod, M, exit, 
+bind = $mainMod, E, exec, dolphin
+bind = $mainMod, V, togglefloating, 
+bind = $mainMod, R, exec, wofi --show drun
+bind = $mainMod, P, pseudo, # dwindle
+bind = $mainMod, J, togglesplit, # dwindle
 
-bind=ALT,1,movetoworkspace,1
-bind=ALT,2,movetoworkspace,2
-bind=ALT,3,movetoworkspace,3
-bind=ALT,4,movetoworkspace,4
-bind=ALT,5,movetoworkspace,5
-bind=ALT,6,movetoworkspace,6
-bind=ALT,7,movetoworkspace,7
-bind=ALT,8,movetoworkspace,8
-bind=ALT,9,movetoworkspace,9
-bind=ALT,0,movetoworkspace,10
+# Move focus with mainMod + arrow keys
+bind = $mainMod, left, movefocus, l
+bind = $mainMod, right, movefocus, r
+bind = $mainMod, up, movefocus, u
+bind = $mainMod, down, movefocus, d
 
-bind=SUPER,mouse_down,workspace,e+1
-bind=SUPER,mouse_up,workspace,e-1
+# Switch workspaces with mainMod + [0-9]
+bind = $mainMod, 1, workspace, 1
+bind = $mainMod, 2, workspace, 2
+bind = $mainMod, 3, workspace, 3
+bind = $mainMod, 4, workspace, 4
+bind = $mainMod, 5, workspace, 5
+bind = $mainMod, 6, workspace, 6
+bind = $mainMod, 7, workspace, 7
+bind = $mainMod, 8, workspace, 8
+bind = $mainMod, 9, workspace, 9
+bind = $mainMod, 0, workspace, 10
+
+# Move active window to a workspace with mainMod + SHIFT + [0-9]
+bind = $mainMod SHIFT, 1, movetoworkspace, 1
+bind = $mainMod SHIFT, 2, movetoworkspace, 2
+bind = $mainMod SHIFT, 3, movetoworkspace, 3
+bind = $mainMod SHIFT, 4, movetoworkspace, 4
+bind = $mainMod SHIFT, 5, movetoworkspace, 5
+bind = $mainMod SHIFT, 6, movetoworkspace, 6
+bind = $mainMod SHIFT, 7, movetoworkspace, 7
+bind = $mainMod SHIFT, 8, movetoworkspace, 8
+bind = $mainMod SHIFT, 9, movetoworkspace, 9
+bind = $mainMod SHIFT, 0, movetoworkspace, 10
+
+# Scroll through existing workspaces with mainMod + scroll
+bind = $mainMod, mouse_down, workspace, e+1
+bind = $mainMod, mouse_up, workspace, e-1
+
+# Move/resize windows with mainMod + LMB/RMB and dragging
+bindm = $mainMod, mouse:272, movewindow
+bindm = $mainMod, mouse:273, resizewindow
 )#";

src/debug/HyprCtl.cpp

@@ -68,14 +68,37 @@ R"#({
     return result;
 }
 
-std::string clientsRequest(HyprCtl::eHyprCtlOutputFormat format) {
-    std::string result = "";
-    if (format == HyprCtl::FORMAT_JSON) {
-        result += "[";
+static std::string getGroupedData(CWindow* w, HyprCtl::eHyprCtlOutputFormat format) {
+    const bool isJson = format == HyprCtl::FORMAT_JSON;
+    if (g_pLayoutManager->getCurrentLayout()->getLayoutName() != "dwindle")
+        return isJson ? "" : "0";
 
-        for (auto& w : g_pCompositor->m_vWindows) {
-            if (w->m_bIsMapped) {
-                result += getFormat(
+    SLayoutMessageHeader header;
+    header.pWindow = w;
+    const auto groupMembers = std::any_cast<std::deque<CWindow*>>(g_pLayoutManager->getCurrentLayout()->layoutMessage(header, "groupinfo"));
+    if (groupMembers.empty())
+        return isJson ? "" : "0";
+
+    const auto comma = isJson ? ", " : ",";
+    const auto fmt = isJson ? "\"0x%x\"" : "%x";
+    std::ostringstream result;
+
+    bool first = true;
+    for (auto& gw : groupMembers) {
+        if (first)
+            first = false;
+        else
+            result << comma;
+
+        result << getFormat(fmt, gw);
+    }
+
+    return result.str();
+}
+
+static std::string getWindowData(CWindow* w, HyprCtl::eHyprCtlOutputFormat format) {
+    if (format == HyprCtl::FORMAT_JSON) {
+        return getFormat(
 R"#({
     "address": "0x%x",
     "at": [%i, %i],
@@ -92,22 +115,40 @@ R"#({
     "xwayland": %s,
     "pinned": %s,
     "fullscreen": %s,
-    "fullscreenMode": %i
+    "fullscreenMode": %i,
+    "grouped": [%s],
+    "swallowing": %s
 },)#",
-                    w.get(),
+                    w,
                     (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))).c_str(),
                     ((int)w->m_bIsFloating == 1 ? "true" : "false"),
                     w->m_iMonitorID,
-                    escapeJSONStrings(g_pXWaylandManager->getAppIDClass(w.get())).c_str(),
-                    escapeJSONStrings(g_pXWaylandManager->getTitle(w.get())).c_str(),
+                    escapeJSONStrings(g_pXWaylandManager->getAppIDClass(w)).c_str(),
+                    escapeJSONStrings(g_pXWaylandManager->getTitle(w)).c_str(),
                     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) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0)
+                    (w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0),
+                    getGroupedData(w, format).c_str(),
+                    (w->m_pSwallowed ? getFormat("\"0x%x\"", w->m_pSwallowed).c_str() : "null")
                 );
+    } else {
+        return getFormat("Window %x -> %s:\n\tat: %i,%i\n\tsize: %i,%i\n\tworkspace: %i (%s)\n\tfloating: %i\n\tmonitor: %i\n\tclass: %s\n\ttitle: %s\n\tpid: %i\n\txwayland: %i\n\tpinned: %i\n\tfullscreen: %i\n\tfullscreenmode: %i\n\tgrouped: %s\n\tswallowing: %x\n\n",
+                w, w->m_szTitle.c_str(), (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.c_str() : std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID)).c_str()), (int)w->m_bIsFloating, w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w).c_str(), g_pXWaylandManager->getTitle(w).c_str(), 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), getGroupedData(w, format).c_str(), w->m_pSwallowed);
+    }
+}
+
+std::string clientsRequest(HyprCtl::eHyprCtlOutputFormat format) {
+    std::string result = "";
+    if (format == HyprCtl::FORMAT_JSON) {
+        result += "[";
+
+        for (auto& w : g_pCompositor->m_vWindows) {
+            if (w->m_bIsMapped) {
+                result += getWindowData(w.get(), format);
             }
         }
 
@@ -119,9 +160,7 @@ R"#({
     } else {
         for (auto& w : g_pCompositor->m_vWindows) {
             if (w->m_bIsMapped) {
-                result += getFormat("Window %x -> %s:\n\tat: %i,%i\n\tsize: %i,%i\n\tworkspace: %i (%s)\n\tfloating: %i\n\tmonitor: %i\n\tclass: %s\n\ttitle: %s\n\tpid: %i\n\txwayland: %i\n\tpinned: %i\n\tfullscreen: %i\n\tfullscreenmode: %i\n\n",
-                                w.get(), w->m_szTitle.c_str(), (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.c_str() : std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID)).c_str()), (int)w->m_bIsFloating, w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w.get()).c_str(), g_pXWaylandManager->getTitle(w.get()).c_str(), 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));
-
+                result += getWindowData(w.get(), format);
             }
         }
     }
@@ -176,38 +215,12 @@ std::string activeWindowRequest(HyprCtl::eHyprCtlOutputFormat format) {
     if (!g_pCompositor->windowValidMapped(PWINDOW))
         return format == HyprCtl::FORMAT_JSON ? "{}" : "Invalid";
 
-    if (format == HyprCtl::FORMAT_JSON) {
-        return getFormat(
-R"#({
-    "address": "0x%x",
-    "at": [%i, %i],
-    "size": [%i, %i],
-    "workspace": {
-        "id": %i,
-        "name": "%s"
-    },
-    "floating": %s,
-    "monitor": %i,
-    "class": "%s",
-    "title": "%s",
-    "pid": %i,
-    "xwayland": %s
-})#",
-            PWINDOW,
-            (int)PWINDOW->m_vRealPosition.vec().x, (int)PWINDOW->m_vRealPosition.vec().y,
-            (int)PWINDOW->m_vRealSize.vec().x, (int)PWINDOW->m_vRealSize.vec().y,
-            PWINDOW->m_iWorkspaceID, escapeJSONStrings(PWINDOW->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_szName).c_str(),
-            ((int)PWINDOW->m_bIsFloating == 1 ? "true" : "false"),
-            PWINDOW->m_iMonitorID,
-            escapeJSONStrings(g_pXWaylandManager->getAppIDClass(PWINDOW)).c_str(),
-            escapeJSONStrings(g_pXWaylandManager->getTitle(PWINDOW)).c_str(),
-            PWINDOW->getPID(),
-            ((int)PWINDOW->m_bIsX11 == 1 ? "true" : "false")
-        );
-    } else {
-        return getFormat("Window %x -> %s:\n\tat: %i,%i\n\tsize: %i,%i\n\tworkspace: %i (%s)\n\tfloating: %i\n\tmonitor: %i\n\tclass: %s\n\ttitle: %s\n\tpid: %i\n\txwayland: %i\n\n",
-                            PWINDOW, PWINDOW->m_szTitle.c_str(), (int)PWINDOW->m_vRealPosition.vec().x, (int)PWINDOW->m_vRealPosition.vec().y, (int)PWINDOW->m_vRealSize.vec().x, (int)PWINDOW->m_vRealSize.vec().y, PWINDOW->m_iWorkspaceID, (PWINDOW->m_iWorkspaceID == -1 ? "" : g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_szName.c_str()), (int)PWINDOW->m_bIsFloating, (int)PWINDOW->m_iMonitorID, g_pXWaylandManager->getAppIDClass(PWINDOW).c_str(), g_pXWaylandManager->getTitle(PWINDOW).c_str(), PWINDOW->getPID(), (int)PWINDOW->m_bIsX11);
-    }
+    auto result = getWindowData(PWINDOW, format);
+    
+    if (format == HyprCtl::FORMAT_JSON)
+        result.pop_back();
+
+    return result;
 }
 
 std::string layersRequest(HyprCtl::eHyprCtlOutputFormat format) {
@@ -308,7 +321,7 @@ R"#(    {
         "defaultSpeed": %f
     },)#",
                 &m,
-                escapeJSONStrings(m.mouse->name).c_str(),
+                escapeJSONStrings(m.name).c_str(),
                 wlr_input_device_is_libinput(m.mouse) ? libinput_device_config_accel_get_default_speed((libinput_device*)wlr_libinput_get_device_handle(m.mouse)) : 0.f
             );
         }
@@ -333,7 +346,7 @@ R"#(    {
         "main": %s
     },)#",
                 &k,
-                escapeJSONStrings(k.keyboard->name).c_str(),
+                escapeJSONStrings(k.name).c_str(),
                 escapeJSONStrings(k.currentRules.rules).c_str(),
                 escapeJSONStrings(k.currentRules.model).c_str(),
                 escapeJSONStrings(k.currentRules.layout).c_str(),
@@ -362,7 +375,7 @@ R"#(    {
     },)#",
                 &d,
                 d.pTabletParent,
-                escapeJSONStrings(d.pTabletParent ? d.pTabletParent->wlrDevice ? d.pTabletParent->wlrDevice->name : "" : "").c_str()
+                escapeJSONStrings(d.pTabletParent ? d.pTabletParent->name : "").c_str()
             );
         }
 
@@ -373,7 +386,7 @@ R"#(    {
         "name": "%s"
     },)#",
                 &d,
-                escapeJSONStrings(d.wlrDevice ? d.wlrDevice->name : "").c_str()
+                escapeJSONStrings(d.name).c_str()
             );
         }
 
@@ -402,7 +415,7 @@ R"#(    {
         "name": "%s"
     },)#",
                 &d,
-                d.pWlrDevice ? d.pWlrDevice->name : ""
+                d.name.c_str()
             );
         }
 
@@ -435,24 +448,24 @@ R"#(    {
         result += "mice:\n";
 
         for (auto& m : g_pInputManager->m_lMice) {
-            result += getFormat("\tMouse at %x:\n\t\t%s\n\t\t\tdefault speed: %f\n", &m, m.mouse->name, (wlr_input_device_is_libinput(m.mouse) ? libinput_device_config_accel_get_default_speed((libinput_device*)wlr_libinput_get_device_handle(m.mouse)) : 0.f));
+            result += getFormat("\tMouse at %x:\n\t\t%s\n\t\t\tdefault speed: %f\n", &m, m.name.c_str(), (wlr_input_device_is_libinput(m.mouse) ? libinput_device_config_accel_get_default_speed((libinput_device*)wlr_libinput_get_device_handle(m.mouse)) : 0.f));
         }
 
         result += "\n\nKeyboards:\n";
 
         for (auto& k : g_pInputManager->m_lKeyboards) {
             const auto KM = g_pInputManager->getActiveLayoutForKeyboard(&k);
-            result += getFormat("\tKeyboard at %x:\n\t\t%s\n\t\t\trules: r \"%s\", m \"%s\", l \"%s\", v \"%s\", o \"%s\"\n\t\t\tactive keymap: %s\n\t\t\tmain: %s\n", &k, k.keyboard->name, k.currentRules.rules.c_str(), k.currentRules.model.c_str(), k.currentRules.layout.c_str(), k.currentRules.variant.c_str(), k.currentRules.options.c_str(), KM.c_str(), (k.active ? "yes" : "no"));
+            result += getFormat("\tKeyboard at %x:\n\t\t%s\n\t\t\trules: r \"%s\", m \"%s\", l \"%s\", v \"%s\", o \"%s\"\n\t\t\tactive keymap: %s\n\t\t\tmain: %s\n", &k, k.name.c_str(), k.currentRules.rules.c_str(), k.currentRules.model.c_str(), k.currentRules.layout.c_str(), k.currentRules.variant.c_str(), k.currentRules.options.c_str(), KM.c_str(), (k.active ? "yes" : "no"));
         }
 
         result += "\n\nTablets:\n";
 
         for (auto& d : g_pInputManager->m_lTabletPads) {
-            result += getFormat("\tTablet Pad at %x (belongs to %x -> %s)\n", &d, d.pTabletParent, d.pTabletParent ? d.pTabletParent->wlrDevice ? d.pTabletParent->wlrDevice->name : "" : "");
+            result += getFormat("\tTablet Pad at %x (belongs to %x -> %s)\n", &d, d.pTabletParent, d.pTabletParent ? d.pTabletParent->name.c_str() : "");
         }
 
         for (auto& d : g_pInputManager->m_lTablets) {
-            result += getFormat("\tTablet at %x:\n\t\t%s\n", &d, d.wlrDevice ? d.wlrDevice->name : "");
+            result += getFormat("\tTablet at %x:\n\t\t%s\n", &d, d.name.c_str());
         }
 
         for (auto& d : g_pInputManager->m_lTabletTools) {
@@ -462,7 +475,7 @@ R"#(    {
         result += "\n\nTouch:\n";
 
         for (auto& d : g_pInputManager->m_lTouchDevices) {
-            result += getFormat("\tTouch Device at %x:\n\t\t%s\n", &d, d.pWlrDevice ? d.pWlrDevice->name : "");
+            result += getFormat("\tTouch Device at %x:\n\t\t%s\n", &d, d.name.c_str());
         }
 
         result += "\n\nSwitches:\n";
@@ -499,7 +512,7 @@ std::string versionRequest(HyprCtl::eHyprCtlOutputFormat format) {
 R"#({
     "branch": "%s",
     "commit": "%s",
-    "dirty": %s
+    "dirty": %s,
     "commit_message": "%s",
     "flags": [)#", GIT_BRANCH, GIT_COMMIT_HASH, (strcmp(GIT_DIRTY, "dirty") == 0 ? "true" : "false"), removeBeginEndSpacesTabs(GIT_COMMIT_MESSAGE).c_str());
 
@@ -562,10 +575,14 @@ std::string dispatchKeyword(std::string in) {
     if (COMMAND.contains("input") || COMMAND.contains("device:")) {
         g_pInputManager->setKeyboardLayout(); // update kb layout
         g_pInputManager->setPointerConfigs(); // update mouse cfgs
+        g_pInputManager->setTouchDeviceConfigs(); // update touch device cfgs
     }
 
     if (COMMAND.contains("general:layout"))
         g_pLayoutManager->switchToLayout(g_pConfigManager->getString("general:layout"));  // update layout
+    
+    if (COMMAND.contains("decoration:screen_shader"))
+        g_pHyprOpenGL->m_bReloadScreenShader = true;
 
     Debug::log(LOG, "Hyprctl: keyword %s : %s", COMMAND.c_str(), VALUE.c_str());
 
@@ -600,6 +617,23 @@ std::string splashRequest() {
     return g_pCompositor->m_szCurrentSplash;
 }
 
+std::string cursorPosRequest(HyprCtl::eHyprCtlOutputFormat format) {
+    const auto CURSORPOS = g_pInputManager->getMouseCoordsInternal().floor();
+
+    if (format == HyprCtl::FORMAT_NORMAL) {
+        return getFormat("%i, %i", (int)CURSORPOS.x, (int)CURSORPOS.y);
+    } else {
+        return getFormat(R"#(
+{
+    "x": %i,
+    "y": %i
+}
+)#", (int)CURSORPOS.x, (int)CURSORPOS.y);
+    }
+
+    return "error";
+}
+
 std::string getReply(std::string);
 
 std::string dispatchBatch(std::string request) {
@@ -684,6 +718,51 @@ std::string dispatchSetCursor(std::string request) {
     return "ok";
 }
 
+std::string switchXKBLayoutRequest(std::string request) {
+    CVarList vars(request, 0, ' ');
+
+    const auto KB = vars[1];
+    const auto CMD = vars[2];
+
+    // get kb
+    const auto PKEYBOARD = std::find_if(g_pInputManager->m_lKeyboards.begin(), g_pInputManager->m_lKeyboards.end(), [&] (const SKeyboard& other) { return other.name == g_pInputManager->deviceNameToInternalString(KB); });
+
+    if (PKEYBOARD == g_pInputManager->m_lKeyboards.end())
+        return "device not found";
+
+    const auto PWLRKEYBOARD = wlr_keyboard_from_input_device(PKEYBOARD->keyboard);
+    const auto LAYOUTS = xkb_keymap_num_layouts(PWLRKEYBOARD->keymap);
+    xkb_layout_index_t activeLayout = 0;
+    while (activeLayout < LAYOUTS) {
+        if (xkb_state_layout_index_is_active(PWLRKEYBOARD->xkb_state, activeLayout, XKB_STATE_LAYOUT_EFFECTIVE))
+            break;
+
+        activeLayout++;
+    }
+
+    if (CMD == "next") {
+        wlr_keyboard_notify_modifiers(PWLRKEYBOARD, PWLRKEYBOARD->modifiers.depressed, PWLRKEYBOARD->modifiers.latched, PWLRKEYBOARD->modifiers.locked, activeLayout > LAYOUTS ? 0 : activeLayout + 1);
+    } else if (CMD == "prev") {
+        wlr_keyboard_notify_modifiers(PWLRKEYBOARD, PWLRKEYBOARD->modifiers.depressed, PWLRKEYBOARD->modifiers.latched, PWLRKEYBOARD->modifiers.locked, activeLayout == 0 ? LAYOUTS - 1 : activeLayout - 1);
+    } else {
+        
+        int requestedLayout = 0;
+        try {
+            requestedLayout = std::stoi(CMD);
+        } catch (std::exception& e) {
+            return "invalid arg 2";
+        }
+
+        if (requestedLayout < 0 || (uint64_t)requestedLayout > LAYOUTS - 1) {
+            return "layout idx out of range of " + std::to_string(LAYOUTS);
+        }
+
+        wlr_keyboard_notify_modifiers(PWLRKEYBOARD, PWLRKEYBOARD->modifiers.depressed, PWLRKEYBOARD->modifiers.latched, PWLRKEYBOARD->modifiers.locked, requestedLayout);      
+    }
+
+    return "ok";
+}
+
 std::string dispatchGetOption(std::string request, HyprCtl::eHyprCtlOutputFormat format) {
     std::string curitem = "";
 
@@ -710,21 +789,102 @@ std::string dispatchGetOption(std::string request, HyprCtl::eHyprCtlOutputFormat
         return "no such option";
 
     if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL)
-        return getFormat("option %s\n\tint: %i\n\tfloat: %f\n\tstr: \"%s\"", curitem.c_str(), PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue.c_str());
+        return getFormat("option %s\n\tint: %lld\n\tfloat: %f\n\tstr: \"%s\"\n\tdata: %x", curitem.c_str(), PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue.c_str(), PCFGOPT->data.get());
     else {
         return getFormat(
 R"#(
 {
     "option": "%s",
-    "int": %i,
+    "int": %lld,
     "float": %f,
-    "str": "%s"
+    "str": "%s",
+    "data": "0x%x"
 }
-)#", curitem.c_str(), PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue.c_str()
+)#", curitem.c_str(), PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue.c_str(), PCFGOPT->data.get()
         );
     }
 }
 
+void createOutputIter(wlr_backend* backend, void* data) {
+    const auto DATA = (std::pair<std::string, bool>*)data;
+
+    if (DATA->second)
+        return;
+
+    if (DATA->first.empty() || DATA->first == "auto") {
+        if (wlr_backend_is_wl(backend)) {
+            wlr_wl_output_create(backend);
+            DATA->second = true;
+        } else if (wlr_backend_is_x11(backend)) {
+            wlr_x11_output_create(backend);
+            DATA->second = true;
+        } else if (wlr_backend_is_headless(backend)) {
+            wlr_headless_add_output(backend, 1920, 1080);
+            DATA->second = true;
+        }
+    } else {
+        if (wlr_backend_is_wl(backend) && DATA->first == "wayland") {
+            wlr_wl_output_create(backend);
+            DATA->second = true;
+        } else if (wlr_backend_is_x11(backend) && DATA->first == "x11") {
+            wlr_x11_output_create(backend);
+            DATA->second = true;
+        } else if (wlr_backend_is_headless(backend) && DATA->first == "headless") {
+            wlr_headless_add_output(backend, 1920, 1080);
+            DATA->second = true;
+        }
+    }
+}
+
+std::string dispatchOutput(std::string request) {
+    std::string curitem = "";
+
+    auto nextItem = [&]() {
+        auto idx = request.find_first_of(' ');
+
+        if (idx != std::string::npos) {
+            curitem = request.substr(0, idx);
+            request = request.substr(idx + 1);
+        } else {
+            curitem = request;
+            request = "";
+        }
+
+        curitem = removeBeginEndSpacesTabs(curitem);
+    };
+
+    nextItem();
+    nextItem();
+
+    const auto MODE = curitem;
+
+    nextItem();
+
+    const auto NAME = curitem;
+
+    if (MODE == "create" || MODE == "add") {
+        std::pair<std::string, bool> result = { NAME, false };
+
+        wlr_multi_for_each_backend(g_pCompositor->m_sWLRBackend, createOutputIter, &result);
+
+        if (!result.second)
+            return "no backend replied to the request";
+
+    } else if (MODE == "destroy" || MODE == "remove") {
+        const auto PMONITOR = g_pCompositor->getMonitorFromName(NAME);
+
+        if (!PMONITOR)
+            return "output not found";
+
+        if (!PMONITOR->createdByUser)
+            return "cannot remove a real display. Use the monitor keyword.";
+
+        wlr_output_destroy(PMONITOR->output);
+    }
+
+    return "ok";
+}
+
 std::string getReply(std::string request) {
     auto format = HyprCtl::FORMAT_NORMAL;
 
@@ -766,6 +926,12 @@ std::string getReply(std::string request) {
         return devicesRequest(format);
     else if (request == "splash")
         return splashRequest();
+    else if (request == "cursorpos")
+        return cursorPosRequest(format);
+    else if (request.find("switchxkblayout") == 0)
+        return switchXKBLayoutRequest(request);
+    else if (request.find("output") == 0)
+        return dispatchOutput(request);
     else if (request.find("dispatch") == 0)
         return dispatchRequest(request);
     else if (request.find("keyword") == 0)

src/defines.hpp

@@ -6,6 +6,8 @@
 
 #include "wlrunstable/wlr_ext_workspace_v1.hpp"
 
+#include <utility>
+
 #ifndef NDEBUG
 #ifdef HYPRLAND_DEBUG
 #define ISDEBUG true
@@ -29,6 +31,8 @@
     const auto RECTSARR = pixman_region32_rectangles(region, &rectsNum); \
     for (int i = 0; i < rectsNum; ++i)
 
+#define PIXMAN_REGION_FOREACH(region) PIXMAN_DAMAGE_FOREACH(region)
+
 
 #define interface class
 
@@ -74,4 +78,6 @@
 #define GIT_DIRTY "?"
 #endif
 
-#define SPECIAL_WORKSPACE_ID -99
+#define SPECIAL_WORKSPACE_START -99
+
+#define PI 3.14159265358979

src/events/Devices.cpp

@@ -91,7 +91,7 @@ void Events::listener_newInput(wl_listener* listener, void* data) {
             break;
     }
 
-    g_pInputManager->updateCapabilities(DEVICE);
+    g_pInputManager->updateCapabilities();
 }
 
 void Events::listener_newConstraint(wl_listener* listener, void* data) {

src/events/Events.hpp

@@ -42,6 +42,7 @@ namespace Events {
 
     // Surface XDG (window)
     LISTENER(newXDGSurface);
+    LISTENER(activateXDG);
 
     // Window events
     DYNLISTENFUNC(commitWindow);
@@ -87,7 +88,6 @@ namespace Events {
     LISTENER(requestMouse);
     LISTENER(requestSetSel);
     LISTENER(requestSetPrimarySel);
-    DYNLISTENFUNC(activate);
 
     // outputMgr
     LISTENER(outputMgrApply);
@@ -96,6 +96,7 @@ namespace Events {
     // Monitor part 2 the sequel
     DYNLISTENFUNC(monitorFrame);
     DYNLISTENFUNC(monitorDestroy);
+    DYNLISTENFUNC(monitorStateRequest);
 
     // XWayland
     LISTENER(readyXWayland);

src/events/Layers.cpp

@@ -31,15 +31,17 @@ void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
         WLRLAYERSURFACE->output = PMONITOR->output;
     }
 
-    const auto PMONITOR = (CMonitor*)g_pCompositor->getMonitorFromOutput(WLRLAYERSURFACE->output);
+    auto PMONITOR = (CMonitor*)g_pCompositor->getMonitorFromOutput(WLRLAYERSURFACE->output);
+
+    if (!WLRLAYERSURFACE->output || !PMONITOR || PMONITOR->pMirrorOf) {
+        PMONITOR = g_pCompositor->m_vMonitors.front().get();
+        WLRLAYERSURFACE->output = PMONITOR->output; // TODO: current mon
+    }
+
     SLayerSurface* layerSurface = PMONITOR->m_aLayerSurfaceLists[WLRLAYERSURFACE->pending.layer].emplace_back(std::make_unique<SLayerSurface>()).get();
 
     layerSurface->szNamespace = WLRLAYERSURFACE->_namespace;
 
-    if (!WLRLAYERSURFACE->output) {
-        WLRLAYERSURFACE->output = g_pCompositor->m_vMonitors.front()->output;  // TODO: current mon
-    }
-
     layerSurface->hyprListener_commitLayerSurface.initCallback(&WLRLAYERSURFACE->surface->events.commit, &Events::listener_commitLayerSurface, layerSurface, "layerSurface");
     layerSurface->hyprListener_destroyLayerSurface.initCallback(&WLRLAYERSURFACE->events.destroy, &Events::listener_destroyLayerSurface, layerSurface, "layerSurface");
     layerSurface->hyprListener_mapLayerSurface.initCallback(&WLRLAYERSURFACE->events.map, &Events::listener_mapLayerSurface, layerSurface, "layerSurface");
@@ -199,8 +201,29 @@ void Events::listener_unmapLayerSurface(void* owner, void* data) {
 
     // refocus if needed
     if (layersurface->layerSurface->surface == g_pCompositor->m_pLastFocus) {
+        
+        Vector2D surfaceCoords;
+        SLayerSurface* pFoundLayerSurface = nullptr;
+        wlr_surface* foundSurface = nullptr;
+
         g_pCompositor->m_pLastFocus = nullptr;
-        g_pInputManager->refocus();
+
+        // find LS-es to focus
+        foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &surfaceCoords, &pFoundLayerSurface);
+
+        if (!foundSurface)
+            foundSurface = g_pCompositor->vectorToLayerSurface(g_pInputManager->getMouseCoordsInternal(), &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP], &surfaceCoords, &pFoundLayerSurface);
+
+
+        if (!foundSurface) {
+            // if there isn't any, focus the last window
+            const auto PLASTWINDOW = g_pCompositor->m_pLastWindow;
+            g_pCompositor->focusWindow(nullptr);
+            g_pCompositor->focusWindow(PLASTWINDOW);
+        } else {
+            // otherwise, full refocus
+            g_pInputManager->refocus();
+        }
     }
 
     wlr_box geomFixed = {layersurface->geometry.x + PMONITOR->vecPosition.x, layersurface->geometry.y + PMONITOR->vecPosition.y, layersurface->geometry.width, layersurface->geometry.height};

src/events/Misc.cpp

@@ -45,6 +45,7 @@ void Events::listener_requestSetSel(wl_listener* listener, void* data) {
 }
 
 void Events::listener_readyXWayland(wl_listener* listener, void* data) {
+#ifndef NO_XWAYLAND
     const auto XCBCONNECTION = xcb_connect(g_pXWaylandManager->m_sWLRXWayland->display_name, NULL);
     const auto ERR = xcb_connection_has_error(XCBCONNECTION);
     if (ERR) {
@@ -72,6 +73,7 @@ void Events::listener_readyXWayland(wl_listener* listener, void* data) {
     }
 
     xcb_disconnect(XCBCONNECTION);
+#endif
 }
 
 void Events::listener_requestDrag(wl_listener* listener, void* data) {
@@ -124,6 +126,8 @@ void Events::listener_startDrag(wl_listener* listener, void* data) {
 void Events::listener_destroyDrag(void* owner, void* data) {
     Debug::log(LOG, "Drag destroyed.");
 
+    static auto *const PFOLLOWMOUSE = &g_pConfigManager->getConfigValuePtr("input:follow_mouse")->intValue;
+
     if (g_pInputManager->m_sDrag.drag && g_pInputManager->m_sDrag.dragIcon && g_pInputManager->m_sDrag.dragIcon->surface)
         g_pHyprRenderer->damageBox(g_pInputManager->m_sDrag.pos.x - 2, g_pInputManager->m_sDrag.pos.y - 2, g_pInputManager->m_sDrag.dragIcon->surface->current.width + 4, g_pInputManager->m_sDrag.dragIcon->surface->current.height + 4);
 
@@ -133,7 +137,7 @@ void Events::listener_destroyDrag(void* owner, void* data) {
 
     g_pInputManager->refocus();
 
-    if (g_pInputManager->m_pFollowOnDnDBegin)
+    if (g_pInputManager->m_pFollowOnDnDBegin && *PFOLLOWMOUSE != 1)
         g_pCompositor->focusWindow(g_pInputManager->m_pFollowOnDnDBegin);
 
     g_pInputManager->m_pFollowOnDnDBegin = nullptr;
@@ -187,6 +191,12 @@ void Events::listener_sessionActive(wl_listener* listener, void* data) {
     Debug::log(LOG, "Session got activated!");
 
     g_pCompositor->m_bSessionActive = true;
+
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        g_pCompositor->scheduleFrameForMonitor(m.get());
+    }
+
+    g_pConfigManager->m_bWantsMonitorReload = true;
 }
 
 void Events::listener_powerMgrSetMode(wl_listener* listener, void* data) {

src/events/Monitors.cpp

@@ -37,8 +37,6 @@ void Events::listener_change(wl_listener* listener, void* data) {
         CONFIGHEAD->state.mode = m->output->current_mode;
         CONFIGHEAD->state.x = m->vecPosition.x;
         CONFIGHEAD->state.y = m->vecPosition.y;
-
-        wlr_output_set_custom_mode(m->output, m->vecPixelSize.x, m->vecPixelSize.y, (int)(round(m->refreshRate * 1000)));
     }
 
     wlr_output_manager_v1_set_configuration(g_pCompositor->m_sWLROutputMgr, CONFIG);
@@ -90,6 +88,9 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
         g_pCompositor->m_bReadyToProcess = true;
         g_pCompositor->m_bUnsafeState = false;
     }
+
+    g_pConfigManager->m_bWantsMonitorReload = true;
+    g_pCompositor->scheduleFrameForMonitor(PNEWMONITOR);
 }
 
 void Events::listener_monitorFrame(void* owner, void* data) {
@@ -108,9 +109,10 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     static std::chrono::high_resolution_clock::time_point endRenderOverlay = std::chrono::high_resolution_clock::now();
 
     static auto *const PDEBUGOVERLAY = &g_pConfigManager->getConfigValuePtr("debug:overlay")->intValue;
-    static auto *const PDAMAGETRACKINGMODE = &g_pConfigManager->getConfigValuePtr("general:damage_tracking_internal")->intValue;
+    static auto *const PDAMAGETRACKINGMODE = &g_pConfigManager->getConfigValuePtr("debug:damage_tracking")->intValue;
     static auto *const PDAMAGEBLINK = &g_pConfigManager->getConfigValuePtr("debug:damage_blink")->intValue;
     static auto *const PNOVFR = &g_pConfigManager->getConfigValuePtr("misc:no_vfr")->intValue;
+    static auto *const PNODIRECTSCANOUT = &g_pConfigManager->getConfigValuePtr("misc:no_direct_scanout")->intValue;
 
     static int damageBlinkCleanup = 0; // because double-buffered
 
@@ -156,6 +158,16 @@ void Events::listener_monitorFrame(void* owner, void* data) {
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITOR->ID);
     }
 
+    // Direct scanout first
+    if (!*PNODIRECTSCANOUT) {
+        if (g_pHyprRenderer->attemptDirectScanout(PMONITOR)) {
+            return;
+        } else if (g_pHyprRenderer->m_pLastScanout) {
+            Debug::log(LOG, "Left a direct scanout.");
+            g_pHyprRenderer->m_pLastScanout = nullptr;
+        }
+    }
+
     timespec now;
     clock_gettime(CLOCK_MONOTONIC, &now);
 
@@ -227,8 +239,6 @@ void Events::listener_monitorFrame(void* owner, void* data) {
 
     if (PMONITOR->isMirror()) {
         g_pHyprOpenGL->renderMirrored();
-
-        Debug::log(LOG, "Mirror frame");
     } else {
         g_pHyprOpenGL->clear(CColor(17, 17, 17, 255));
         g_pHyprOpenGL->clearWithTex();  // will apply the hypr "wallpaper"
@@ -236,11 +246,11 @@ void Events::listener_monitorFrame(void* owner, void* data) {
         g_pHyprRenderer->renderAllClientsForMonitor(PMONITOR->ID, &now);
 
         // if correct monitor draw hyprerror
-        if (PMONITOR->ID == 0)
+        if (PMONITOR == g_pCompositor->m_vMonitors.front().get())
             g_pHyprError->draw();
 
         // for drawing the debug overlay
-        if (PMONITOR->ID == 0 && *PDEBUGOVERLAY == 1) {
+        if (PMONITOR == g_pCompositor->m_vMonitors.front().get() && *PDEBUGOVERLAY == 1) {
             startRenderOverlay = std::chrono::high_resolution_clock::now();
             g_pDebugOverlay->draw();
             endRenderOverlay = std::chrono::high_resolution_clock::now();
@@ -256,15 +266,16 @@ void Events::listener_monitorFrame(void* owner, void* data) {
                 damageBlinkCleanup = 0;
         }
 
-        wlr_renderer_begin(g_pCompositor->m_sWLRRenderer, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
-
-        wlr_output_render_software_cursors(PMONITOR->output, NULL);
-
-        wlr_renderer_end(g_pCompositor->m_sWLRRenderer);
+        if (wlr_renderer_begin(g_pCompositor->m_sWLRRenderer, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y)) {
+            wlr_output_render_software_cursors(PMONITOR->output, NULL);
+            wlr_renderer_end(g_pCompositor->m_sWLRRenderer);
+        }
     }
 
     g_pHyprOpenGL->end();
 
+    g_pProtocolManager->m_pToplevelExportProtocolManager->onMonitorRender(PMONITOR); // dispatch any toplevel sharing
+
     // calc frame damage
     pixman_region32_t frameDamage;
     pixman_region32_init(&frameDamage);
@@ -295,7 +306,7 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     if (*PDEBUGOVERLAY == 1) {
         const float µs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - startRender).count() / 1000.f;
         g_pDebugOverlay->renderData(PMONITOR, µs);
-        if (PMONITOR->ID == 0) {
+        if (PMONITOR == g_pCompositor->m_vMonitors.front().get()) {
             const float µsNoOverlay = µs - std::chrono::duration_cast<std::chrono::nanoseconds>(endRenderOverlay - startRenderOverlay).count() / 1000.f;
             g_pDebugOverlay->renderDataNoOverlay(PMONITOR, µsNoOverlay);
         } else {
@@ -309,8 +320,8 @@ void Events::listener_monitorDestroy(void* owner, void* data) {
 
     CMonitor* pMonitor = nullptr;
 
-    for (auto& m : g_pCompositor->m_vMonitors) {
-        if (m->szName == OUTPUT->name) {
+    for (auto& m : g_pCompositor->m_vRealMonitors) {
+        if (m->output == OUTPUT) {
             pMonitor = m.get();
             break;
         }
@@ -319,11 +330,14 @@ void Events::listener_monitorDestroy(void* owner, void* data) {
     if (!pMonitor)
         return;
 
+    Debug::log(LOG, "Destroy called for monitor %s", pMonitor->output->name);
+
     pMonitor->onDisconnect();
 
     // cleanup if not unsafe
-
     if (!g_pCompositor->m_bUnsafeState) {
+        Debug::log(LOG, "Removing monitor %s from realMonitors", pMonitor->output->name);
+
         g_pCompositor->m_vRealMonitors.erase(std::remove_if(g_pCompositor->m_vRealMonitors.begin(), g_pCompositor->m_vRealMonitors.end(), [&](std::shared_ptr<CMonitor>& el) { return el.get() == pMonitor; }));
 
         if (pMostHzMonitor == pMonitor) {
@@ -341,3 +355,10 @@ 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;
+
+    wlr_output_commit_state(PMONITOR->output, E->state);
+}

src/events/Windows.cpp

@@ -52,11 +52,11 @@ void Events::listener_mapWindow(void* owner, void* data) {
     static auto *const PSWALLOW = &g_pConfigManager->getConfigValuePtr("misc:enable_swallow")->intValue;
     static auto *const PSWALLOWREGEX = &g_pConfigManager->getConfigValuePtr("misc:swallow_regex")->strValue;
 
-    const auto PMONITOR = g_pCompositor->m_pLastMonitor;
-    const auto PWORKSPACE = PMONITOR->specialWorkspaceOpen ? g_pCompositor->getWorkspaceByID(SPECIAL_WORKSPACE_ID) : g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
+    auto PMONITOR = g_pCompositor->m_pLastMonitor;
+    const auto PWORKSPACE = PMONITOR->specialWorkspaceID ? g_pCompositor->getWorkspaceByID(PMONITOR->specialWorkspaceID) : g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
     PWINDOW->m_iMonitorID = PMONITOR->ID;
     PWINDOW->m_bMappedX11 = true;
-    PWINDOW->m_iWorkspaceID = PMONITOR->specialWorkspaceOpen ? SPECIAL_WORKSPACE_ID : PMONITOR->activeWorkspace;
+    PWINDOW->m_iWorkspaceID = PMONITOR->specialWorkspaceID ? PMONITOR->specialWorkspaceID : PMONITOR->activeWorkspace;
     PWINDOW->m_bIsMapped = true;
     PWINDOW->m_bReadyToDelete = false;
     PWINDOW->m_bFadingOut = false;
@@ -65,8 +65,6 @@ void Events::listener_mapWindow(void* owner, void* data) {
     if (PWINDOW->m_iX11Type == 2)
         g_pCompositor->moveUnmanagedX11ToWindows(PWINDOW);
 
-    g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
-
     // Set all windows tiled regardless of anything
     g_pXWaylandManager->setWindowStyleTiled(PWINDOW, WLR_EDGE_LEFT | WLR_EDGE_RIGHT | WLR_EDGE_TOP | WLR_EDGE_BOTTOM);
 
@@ -76,6 +74,9 @@ void Events::listener_mapWindow(void* owner, void* data) {
     // checks if the window wants borders and sets the appriopriate flag
     g_pXWaylandManager->checkBorders(PWINDOW);
 
+    // registers the animated vars and stuff
+    PWINDOW->onMap();
+
     const auto PWINDOWSURFACE = g_pXWaylandManager->getWindowSurface(PWINDOW);
 
     if (!PWINDOWSURFACE) {
@@ -112,8 +113,9 @@ void Events::listener_mapWindow(void* owner, void* data) {
     const auto WINDOWRULES = g_pConfigManager->getMatchingRules(PWINDOW);
     std::string requestedWorkspace = "";
     bool workspaceSilent = false;
-    bool requestsFullscreen = PWINDOW->m_bWantsInitialFullscreen || (!PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xdg->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL && PWINDOW->m_uSurface.xdg->toplevel->requested.fullscreen);
+    bool requestsFullscreen = PWINDOW->m_bWantsInitialFullscreen || (!PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xdg->role == WLR_XDG_SURFACE_ROLE_TOPLEVEL && PWINDOW->m_uSurface.xdg->toplevel->requested.fullscreen) || (PWINDOW->m_bIsX11 && PWINDOW->m_uSurface.xwayland->fullscreen);
     bool shouldFocus = true;
+    bool workspaceSpecial = false;
 
     for (auto& r : WINDOWRULES) {
         if (r.szRule.find("monitor") == 0) {
@@ -131,7 +133,10 @@ void Events::listener_mapWindow(void* owner, void* data) {
                 }
 
                 PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID)->activeWorkspace;
-                g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->m_iMonitorID));
+                if (PWINDOW->m_iMonitorID != PMONITOR->ID) {
+                    g_pKeybindManager->m_mDispatchers["focusmonitor"](std::to_string(PWINDOW->m_iMonitorID));
+                    PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+                }
 
                 Debug::log(ERR, "Rule monitor, applying to window %x -> mon: %i, workspace: %i", PWINDOW, PWINDOW->m_iMonitorID, PWINDOW->m_iWorkspaceID);
             } catch (std::exception& e) {
@@ -147,6 +152,9 @@ void Events::listener_mapWindow(void* owner, void* data) {
                 requestedWorkspace = WORKSPACERQ;
             }
 
+            if (requestedWorkspace == PWORKSPACE->m_szName || requestedWorkspace == "name:" + PWORKSPACE->m_szName)
+                requestedWorkspace = "";
+
             Debug::log(LOG, "Rule workspace matched by window %x, %s applied.", PWINDOW, r.szValue.c_str());
         } else if (r.szRule.find("float") == 0) {
             PWINDOW->m_bIsFloating = true;
@@ -156,42 +164,32 @@ void Events::listener_mapWindow(void* owner, void* data) {
             PWINDOW->m_bIsPseudotiled = true;
         } else if (r.szRule.find("nofocus") == 0) {
             PWINDOW->m_bNoFocus = true;
-        } else if (r.szRule == "noblur") {
-            PWINDOW->m_sAdditionalConfigData.forceNoBlur = true;
+        } else if (r.szRule.find("nofullscreenrequest") == 0) {
+            PWINDOW->m_bNoFullscreenRequest = true;
         } else if (r.szRule == "fullscreen") {
             requestsFullscreen = true;
-        } else if (r.szRule == "opaque") {
-            PWINDOW->m_sAdditionalConfigData.forceOpaque = true;
+        } else if (r.szRule == "windowdance") {
+            PWINDOW->m_sAdditionalConfigData.windowDanceCompat = true;
         } else if (r.szRule == "forceinput") {
             PWINDOW->m_sAdditionalConfigData.forceAllowsInput = true;
         } else if (r.szRule == "pin") {
             PWINDOW->m_bPinned = true;
-        } else if (r.szRule == "noanim") {
-            PWINDOW->m_sAdditionalConfigData.forceNoAnims = true;
-        } else if (r.szRule.find("rounding") == 0) {
-            try {
-                PWINDOW->m_sAdditionalConfigData.rounding = std::stoi(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
-            } catch (std::exception& e) {
-                Debug::log(ERR, "Rounding rule \"%s\" failed with: %s", r.szRule.c_str(), e.what());
-            }
-        } else if (r.szRule.find("opacity") == 0) {
-            try {
-                std::string alphaPart = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
+        } else if (r.szRule.find("idleinhibit") == 0) {
+            auto IDLERULE = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
 
-                if (alphaPart.contains(' ')) {
-                    // we have a comma, 2 values
-                    PWINDOW->m_sSpecialRenderData.alpha = std::stof(alphaPart.substr(0, alphaPart.find_first_of(' ')));
-                    PWINDOW->m_sSpecialRenderData.alphaInactive = std::stof(alphaPart.substr(alphaPart.find_first_of(' ') + 1));
-                } else {
-                    PWINDOW->m_sSpecialRenderData.alpha = std::stof(alphaPart);
-                }
-            } catch(std::exception& e) {
-                Debug::log(ERR, "Opacity rule \"%s\" failed with: %s", r.szRule.c_str(), e.what());
+            if (IDLERULE == "none") {
+                PWINDOW->m_eIdleInhibitMode = IDLEINHIBIT_NONE;
+            } else if (IDLERULE == "always") {
+                PWINDOW->m_eIdleInhibitMode = IDLEINHIBIT_ALWAYS;
+            } else if (IDLERULE == "focus") {
+                PWINDOW->m_eIdleInhibitMode = IDLEINHIBIT_FOCUS;
+            } else if (IDLERULE == "fullscreen") {
+                PWINDOW->m_eIdleInhibitMode = IDLEINHIBIT_FULLSCREEN;
+            } else {
+                Debug::log(ERR, "Rule idleinhibit: unknown mode %s", IDLERULE.c_str());
             }
-        } else if (r.szRule.find("animation") == 0) {
-            auto STYLE = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
-            PWINDOW->m_sAdditionalConfigData.animationStyle = STYLE;
         }
+        PWINDOW->applyDynamicRule(r);
     }
 
     // disallow tiled pinned
@@ -205,16 +203,16 @@ void Events::listener_mapWindow(void* owner, void* data) {
             if (requestedWorkspace.contains("silent")) {
                 workspaceSilent = true;
                 shouldFocus = false;
-            }
 
-            requestedWorkspace = requestedWorkspace.substr(0, requestedWorkspace.find_first_of(' '));
+                requestedWorkspace = requestedWorkspace.substr(0, requestedWorkspace.find_first_of(' '));
+            }
 
             if (!shouldFocus && requestedWorkspace == std::to_string(PMONITOR->activeWorkspace))
                 shouldFocus = true;
+        }
 
-            if (requestedWorkspace == "special") {
-                workspaceSilent = true;
-            }
+        if (requestedWorkspace.find("special" == 0)) {
+            workspaceSpecial = true;
         }
 
         if (!workspaceSilent) {
@@ -222,6 +220,46 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
             PWINDOW->m_iMonitorID = g_pCompositor->m_pLastMonitor->ID;
             PWINDOW->m_iWorkspaceID = g_pCompositor->m_pLastMonitor->activeWorkspace;
+
+            PMONITOR = g_pCompositor->m_pLastMonitor;
+        }
+    }
+
+    if (workspaceSilent) {
+        // get the workspace
+
+        auto PWORKSPACE = g_pCompositor->getWorkspaceByString(requestedWorkspace);
+
+        if (!PWORKSPACE) {
+            std::string workspaceName = "";
+            int workspaceID = 0;
+
+            if (requestedWorkspace.find("name:") == 0) {
+                workspaceName = requestedWorkspace.substr(5);
+                workspaceID = g_pCompositor->getNextAvailableNamedWorkspace();
+            } else if (workspaceSpecial) {
+                workspaceName = "";
+                workspaceID = getWorkspaceIDFromString(requestedWorkspace, workspaceName);
+            } else {
+                try {
+                    workspaceID = std::stoi(requestedWorkspace);
+                } catch (...) {
+                    workspaceID = -1;
+                    Debug::log(ERR, "Invalid workspace requested in workspace silent rule!");
+                }
+
+                if (workspaceID < 1) {
+                    workspaceID = -1; // means invalid
+                }
+            }
+
+            if (workspaceID != -1)
+                PWORKSPACE = g_pCompositor->createNewWorkspace(workspaceID, PWINDOW->m_iMonitorID, workspaceName);
+        }
+
+        if (PWORKSPACE) {
+            PWINDOW->m_iWorkspaceID = PWORKSPACE->m_iID;
+            PWINDOW->m_iMonitorID = PWORKSPACE->m_iMonitorID;
         }
     }
 
@@ -247,7 +285,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     PWINDOW->m_vRealSize = Vector2D(SIZEX, SIZEY);
                     g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
 
-                    PWINDOW->m_bHidden = false;
+                    PWINDOW->setHidden(false);
                 } catch (...) {
                     Debug::log(LOG, "Rule size failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
                 }
@@ -262,24 +300,81 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     PWINDOW->m_vRealSize = SIZE;
                     g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
 
-                    PWINDOW->m_bHidden = false;
+                    PWINDOW->setHidden(false);
                 } catch (...) {
                     Debug::log(LOG, "Rule minsize failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
                 }
-            } else if (r.szRule.find("move") == 0) {
+            } else if (r.szRule.find("maxsize") == 0) {
                 try {
                     const auto VALUE = r.szRule.substr(r.szRule.find(" ") + 1);
-                    const auto POSXSTR = VALUE.substr(0, VALUE.find(" "));
-                    const auto POSYSTR = VALUE.substr(VALUE.find(" ") + 1);
+                    const auto SIZEXSTR = VALUE.substr(0, VALUE.find(" "));
+                    const auto SIZEYSTR = VALUE.substr(VALUE.find(" ") + 1);
 
-                    const auto POSX = !POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stoi(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.x;
-                    const auto POSY = !POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stoi(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.y;
+                    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: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
+                }
+            } else if (r.szRule.find("move") == 0) {
+                try {
+                    auto value = r.szRule.substr(r.szRule.find(" ") + 1);
+
+                    const bool CURSOR = value.find("cursor") == 0;
+
+                    if (CURSOR)
+                        value = value.substr(value.find_first_of(' ') + 1);
+
+                    const auto POSXSTR = value.substr(0, value.find(" "));
+                    const auto POSYSTR = value.substr(value.find(" ") + 1);
+
+                    int posX = 0;
+                    int posY = 0;
+
+                    if (POSXSTR.find("100%-") == 0) {
+                        const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+                        const auto POSXRAW = POSXSTR.substr(5);
+                        posX = PMONITOR->vecSize.x - (!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stoi(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.x);
+
+                        if (CURSOR)
+                            Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
+                    } else if (!CURSOR) {
+                        posX = !POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stoi(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.x;
+                    } else {
+                        // cursor
+                        if (POSXSTR == "cursor") {
+                            posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x;
+                        } else {
+                            posX = g_pInputManager->getMouseCoordsInternal().x - PMONITOR->vecPosition.x + (!POSXSTR.contains('%') ? std::stoi(POSXSTR) : std::stoi(POSXSTR.substr(0, POSXSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goalv().x);
+                        }
+                    }
+
+                    if (POSYSTR.find("100%-") == 0) {
+                        const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+                        const auto POSYRAW = POSYSTR.substr(5);
+                        posY = PMONITOR->vecSize.y - (!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stoi(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.y);
+
+                        if (CURSOR)
+                            Debug::log(ERR, "Cursor is not compatible with 100%-, ignoring cursor!");
+                    } else if (!CURSOR) {
+                        posY = !POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stoi(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.y;
+                    } else {
+                        // cursor
+                        if (POSYSTR == "cursor") {
+                            posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y;
+                        } else {
+                            posY = g_pInputManager->getMouseCoordsInternal().y - PMONITOR->vecPosition.y + (!POSYSTR.contains('%') ? std::stoi(POSYSTR) : std::stoi(POSYSTR.substr(0, POSYSTR.length() - 1)) * 0.01 * PWINDOW->m_vRealSize.goalv().y);
+                        }
+                    }
 
                     Debug::log(LOG, "Rule move, applying to window %x", PWINDOW);
 
-                    PWINDOW->m_vRealPosition = Vector2D(POSX, POSY) + PMONITOR->vecPosition;
+                    PWINDOW->m_vRealPosition = Vector2D(posX, posY) + PMONITOR->vecPosition;
 
-                    PWINDOW->m_bHidden = false;
+                    PWINDOW->setHidden(false);
                 } catch (...) {
                     Debug::log(LOG, "Rule move failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str());
                 }
@@ -293,8 +388,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goalv();
 
         g_pCompositor->moveWindowToTop(PWINDOW);
-    }
-    else {
+    } else {
         g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW);
 
         // Set the pseudo size here too so that it doesnt end up being 0x0
@@ -309,7 +403,12 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->m_bX11ShouldntFocus = false;
     }
 
-    if (!PWINDOW->m_bNoFocus && !PWINDOW->m_bNoInitialFocus && PWINDOW->m_iX11Type != 2) {
+    // check LS focus grab
+    const auto PLSFROMFOCUS = g_pCompositor->getLayerSurfaceFromSurface(g_pCompositor->m_pLastFocus);
+    if (PLSFROMFOCUS && PLSFROMFOCUS->layerSurface->current.keyboard_interactive)
+        PWINDOW->m_bNoInitialFocus = true;
+
+    if (!PWINDOW->m_bNoFocus && !PWINDOW->m_bNoInitialFocus && PWINDOW->m_iX11Type != 2 && !workspaceSilent) {
         g_pCompositor->focusWindow(PWINDOW);
         PWINDOW->m_fActiveInactiveAlpha.setValueAndWarp(*PACTIVEALPHA);
         PWINDOW->m_fDimPercent.setValueAndWarp(*PDIMSTRENGTH);
@@ -334,6 +433,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->hyprListener_activateX11.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_activate, &Events::listener_activateX11, PWINDOW, "XWayland Window Late");
         PWINDOW->hyprListener_configureX11.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_configure, &Events::listener_configureX11, PWINDOW, "XWayland Window Late");
         PWINDOW->hyprListener_setTitleWindow.initCallback(&PWINDOW->m_uSurface.xwayland->events.set_title, &Events::listener_setTitleWindow, PWINDOW, "XWayland Window Late");
+        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_minimize, &Events::listener_requestMinimize, PWINDOW, "Xwayland Window Late");
+        PWINDOW->hyprListener_requestMinimize.initCallback(&PWINDOW->m_uSurface.xwayland->events.request_maximize, &Events::listener_requestMaximize, PWINDOW, "Xwayland Window Late");
 
         if (PWINDOW->m_iX11Type == 2)
             PWINDOW->hyprListener_setGeometryX11U.initCallback(&PWINDOW->m_uSurface.xwayland->events.set_geometry, &Events::listener_unmanagedSetGeometry, PWINDOW, "XWayland Window Late");
@@ -347,23 +448,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
     const auto TIMER = wl_event_loop_add_timer(g_pCompositor->m_sWLEventLoop, setAnimToMove, PWINDOW);
     wl_event_source_timer_update(TIMER, PWINDOW->m_vRealPosition.getDurationLeftMs() + 5);
 
-    if (workspaceSilent) {
-        // move the window
-        const auto OLDWORKSPACE = PWINDOW->m_iWorkspaceID;
-
-        if (g_pCompositor->m_pLastWindow == PWINDOW) {
-            if (requestedWorkspace != "special")
-                g_pKeybindManager->m_mDispatchers["movetoworkspacesilent"](requestedWorkspace);
-            else
-                g_pKeybindManager->m_mDispatchers["movetoworkspace"]("special");
-        } else {
-            Debug::log(ERR, "Tried to set workspace silent rule to a nofocus window!");
-        }
-
-        g_pCompositor->forceReportSizesToWindowsOnWorkspace(OLDWORKSPACE);
-    }
-
-    if (requestsFullscreen) {
+    if (requestsFullscreen && !PWINDOW->m_bNoFullscreenRequest) {
         // fix fullscreen on requested (basically do a switcheroo)
         if (PWORKSPACE->m_bHasFullscreenWindow) {
             const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
@@ -420,7 +505,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
                 std::vector<CWindow*> found;
                 CWindow* finalFound = nullptr;
                 for (auto& w : g_pCompositor->m_vWindows) {
-                    if (!w->m_bIsMapped || w->m_bHidden)
+                    if (!w->m_bIsMapped || w->isHidden())
                         continue;
 
                     if (w->getPID() == ppid) {
@@ -448,7 +533,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
                         g_pLayoutManager->getCurrentLayout()->onWindowRemoved(finalFound);
 
-                        finalFound->m_bHidden = true;
+                        finalFound->setHidden(true);
                     }
                 }
             }
@@ -459,6 +544,9 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
     auto workspaceID = requestedWorkspace != "" ? requestedWorkspace : PWORKSPACE->m_szName;
     g_pEventManager->postEvent(SHyprIPCEvent{"openwindow", getFormat("%x,%s,%s,%s", PWINDOW, workspaceID.c_str(), g_pXWaylandManager->getAppIDClass(PWINDOW).c_str(), PWINDOW->m_szTitle.c_str())});
+
+    // recalc the values for this window
+    g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
 }
 
 void Events::listener_unmapWindow(void* owner, void* data) {
@@ -468,6 +556,8 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
     g_pEventManager->postEvent(SHyprIPCEvent{"closewindow", getFormat("%x", PWINDOW)});
 
+    g_pProtocolManager->m_pToplevelExportProtocolManager->onWindowUnmap(PWINDOW);
+
     if (!PWINDOW->m_bIsX11) {
         Debug::log(LOG, "Unregistered late callbacks XDG");
         PWINDOW->hyprListener_commitWindow.removeCallback();
@@ -485,6 +575,8 @@ void Events::listener_unmapWindow(void* owner, void* data) {
         PWINDOW->hyprListener_configureX11.removeCallback();
         PWINDOW->hyprListener_setTitleWindow.removeCallback();
         PWINDOW->hyprListener_setGeometryX11U.removeCallback();
+        PWINDOW->hyprListener_requestMaximize.removeCallback();
+        PWINDOW->hyprListener_requestMinimize.removeCallback();
     }
 
     if (PWINDOW->m_bIsFullscreen) {
@@ -496,7 +588,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
     // swallowing
     if (PWINDOW->m_pSwallowed && g_pCompositor->windowExists(PWINDOW->m_pSwallowed)) {
-        PWINDOW->m_pSwallowed->m_bHidden = false;
+        PWINDOW->m_pSwallowed->setHidden(false);
         g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW->m_pSwallowed);
         PWINDOW->m_pSwallowed = nullptr;
     }
@@ -524,13 +616,7 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
     // refocus on a new window if needed
     if (wasLastWindow) {
-        auto PWINDOWCANDIDATE = g_pCompositor->vectorToWindowIdeal(PWINDOW->m_vRealPosition.goalv() + PWINDOW->m_vRealSize.goalv() / 2.f);
-
-        if (PWORKSPACE->m_bHasFullscreenWindow && ((!PWINDOWCANDIDATE || !PWINDOWCANDIDATE->m_bCreatedOverFullscreen) || !PWINDOW->m_bIsFloating))
-            PWINDOWCANDIDATE = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
-
-        if (!PWINDOWCANDIDATE || PWINDOW == PWINDOWCANDIDATE || !PWINDOWCANDIDATE->m_bIsMapped || PWINDOWCANDIDATE->m_bHidden || PWINDOWCANDIDATE->m_bX11ShouldntFocus || PWINDOWCANDIDATE->m_iX11Type == 2 || PWINDOWCANDIDATE->m_iMonitorID != g_pCompositor->m_pLastMonitor->ID)
-            PWINDOWCANDIDATE = nullptr;
+        const auto PWINDOWCANDIDATE = g_pLayoutManager->getCurrentLayout()->getNextWindowCandidate(PWINDOW);
 
         Debug::log(LOG, "On closed window, new focused candidate is %x", PWINDOWCANDIDATE);
 
@@ -539,6 +625,8 @@ void Events::listener_unmapWindow(void* owner, void* data) {
                 g_pInputManager->refocus();
             else
                 g_pCompositor->focusWindow(PWINDOWCANDIDATE);
+        } else {
+            g_pInputManager->refocus();
         }
     } else {
         Debug::log(LOG, "Unmapped was not focused, ignoring a refocus.");
@@ -573,12 +661,18 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
     // recheck idle inhibitors
     g_pInputManager->recheckIdleInhibitorStatus();
+
+    // force report all sizes (QT sometimes has an issue with this)
+    g_pCompositor->forceReportSizesToWindowsOnWorkspace(PWINDOW->m_iWorkspaceID);
+
+    // update lastwindow after focus
+    PWINDOW->onUnmap();
 }
 
 void Events::listener_commitWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
-    if (!PWINDOW->m_bMappedX11 || PWINDOW->m_bHidden || (PWINDOW->m_bIsX11 && !PWINDOW->m_bMappedX11))
+    if (!PWINDOW->m_bMappedX11 || PWINDOW->isHidden() || (PWINDOW->m_bIsX11 && !PWINDOW->m_bMappedX11))
         return;
 
     g_pHyprRenderer->damageSurface(g_pXWaylandManager->getWindowSurface(PWINDOW), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y);
@@ -625,6 +719,8 @@ void Events::listener_setTitleWindow(void* owner, void* data) {
     if (PWINDOW == g_pCompositor->m_pLastWindow) // if it's the active, let's post an event to update others
         g_pEventManager->postEvent(SHyprIPCEvent{"activewindow", g_pXWaylandManager->getAppIDClass(PWINDOW) + "," + PWINDOW->m_szTitle});
 
+    PWINDOW->updateDynamicRules();
+    g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
     PWINDOW->updateToplevel();
 
     Debug::log(LOG, "Window %x set title to %s", PWINDOW, PWINDOW->m_szTitle.c_str());
@@ -638,7 +734,7 @@ void Events::listener_fullscreenWindow(void* owner, void* data) {
         return;
     }
 
-    if (PWINDOW->m_bHidden)
+    if (PWINDOW->isHidden() || PWINDOW->m_bNoFullscreenRequest)
         return;
 
     if (!PWINDOW->m_bIsX11) {
@@ -649,26 +745,50 @@ void Events::listener_fullscreenWindow(void* owner, void* data) {
 
         wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);
     } else {
-        g_pCompositor->setWindowFullscreen(PWINDOW, !PWINDOW->m_bIsFullscreen, FULLSCREEN_FULL);
+        if (!PWINDOW->m_uSurface.xwayland->mapped)
+            return;
+
+        g_pCompositor->setWindowFullscreen(PWINDOW, PWINDOW->m_uSurface.xwayland->fullscreen, FULLSCREEN_FULL);
     }
 
     PWINDOW->updateToplevel();
 
     Debug::log(LOG, "Window %x fullscreen to %i", PWINDOW, PWINDOW->m_bIsFullscreen);
-
-    g_pXWaylandManager->setWindowFullscreen(PWINDOW, PWINDOW->m_bIsFullscreen);
 }
 
-void Events::listener_activate(void* owner, void* data) {
-    // TODO
+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;
+
+    Debug::log(LOG, "Activate request for surface at %x", E->surface);
+
+    if (!*PFOCUSONACTIVATE || !wlr_surface_is_xdg_surface(E->surface))
+        return;
+
+    const auto PWINDOW = g_pCompositor->getWindowFromSurface(E->surface);
+
+    if (!PWINDOW || PWINDOW == g_pCompositor->m_pLastWindow)
+        return;
+
+    g_pCompositor->focusWindow(PWINDOW);
+    Vector2D middle = PWINDOW->m_vRealPosition.goalv() + PWINDOW->m_vRealSize.goalv() / 2.f;
+    g_pCompositor->warpCursorTo(middle);
 }
 
 void Events::listener_activateX11(void* owner, void* data) {
-    CWindow* PWINDOW = (CWindow*)owner;
+    const auto PWINDOW = (CWindow*)owner;
 
-    if (PWINDOW->m_iX11Type == 1 /* Managed */) {
-        wlr_xwayland_surface_activate(PWINDOW->m_uSurface.xwayland, 1);
-    }
+    static auto *const PFOCUSONACTIVATE = &g_pConfigManager->getConfigValuePtr("misc:focus_on_activate")->intValue;
+
+    Debug::log(LOG, "X11 Activate request for window %x", PWINDOW);
+
+    if (!*PFOCUSONACTIVATE || PWINDOW->m_iX11Type != 1 || PWINDOW == g_pCompositor->m_pLastWindow)
+        return;
+
+    g_pCompositor->focusWindow(PWINDOW);
+    Vector2D middle = PWINDOW->m_vRealPosition.goalv() + PWINDOW->m_vRealSize.goalv() / 2.f;
+    g_pCompositor->warpCursorTo(middle);
 }
 
 void Events::listener_configureX11(void* owner, void* data) {
@@ -681,21 +801,21 @@ void Events::listener_configureX11(void* owner, void* data) {
     g_pHyprRenderer->damageWindow(PWINDOW);
 
     if (!PWINDOW->m_bIsFloating || PWINDOW->m_bIsFullscreen) {
-        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.vec());
+        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv(), true);
         g_pInputManager->refocus();
         g_pHyprRenderer->damageWindow(PWINDOW);
         return;
     }
 
-    if (!PWINDOW->m_uSurface.xwayland->mapped) {
+    if (!PWINDOW->m_uSurface.xwayland->mapped || !PWINDOW->m_bMappedX11) {
         wlr_xwayland_surface_configure(PWINDOW->m_uSurface.xwayland, E->x, E->y, E->width, E->height);
         return;
     }
 
     if (E->width > 1 && E->height > 1)
-        PWINDOW->m_bHidden = false;
+        PWINDOW->setHidden(false);
     else
-        PWINDOW->m_bHidden = true;
+        PWINDOW->setHidden(true);
 
     PWINDOW->m_vRealPosition.setValueAndWarp(Vector2D(E->x, E->y));
     PWINDOW->m_vRealSize.setValueAndWarp(Vector2D(E->width, E->height));
@@ -710,7 +830,8 @@ void Events::listener_configureX11(void* owner, void* data) {
 
     PWINDOW->m_bCreatedOverFullscreen = true;
 
-    g_pInputManager->refocus();
+    if (!PWINDOW->m_sAdditionalConfigData.windowDanceCompat)
+        g_pInputManager->refocus();
 
     g_pHyprRenderer->damageWindow(PWINDOW);
 
@@ -720,16 +841,22 @@ void Events::listener_configureX11(void* owner, void* data) {
 void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
-    if (!PWINDOW->m_bMappedX11 || PWINDOW->m_bHidden)
+    if (!PWINDOW->m_bMappedX11)
         return;
 
     const auto POS = PWINDOW->m_vRealPosition.goalv();
     const auto SIZ = PWINDOW->m_vRealSize.goalv();
 
     if (PWINDOW->m_uSurface.xwayland->width > 1 && PWINDOW->m_uSurface.xwayland->height > 1)
-        PWINDOW->m_bHidden = false;
+        PWINDOW->setHidden(false);
     else
-        PWINDOW->m_bHidden = true;
+        PWINDOW->setHidden(true);
+
+    if (PWINDOW->m_bIsFullscreen || !PWINDOW->m_bIsFloating) {
+        g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv(), true);
+        g_pHyprRenderer->damageWindow(PWINDOW);
+        return;
+    }
 
     if (abs(std::floor(POS.x) - PWINDOW->m_uSurface.xwayland->x) > 2 || abs(std::floor(POS.y) - PWINDOW->m_uSurface.xwayland->y) > 2 || abs(std::floor(SIZ.x) - PWINDOW->m_uSurface.xwayland->width) > 2 || abs(std::floor(SIZ.y) - PWINDOW->m_uSurface.xwayland->height) > 2) {
         Debug::log(LOG, "Unmanaged window %x requests geometry update to %i %i %i %i", PWINDOW, (int)PWINDOW->m_uSurface.xwayland->x, (int)PWINDOW->m_uSurface.xwayland->y, (int)PWINDOW->m_uSurface.xwayland->width, (int)PWINDOW->m_uSurface.xwayland->height);
@@ -793,15 +920,37 @@ void Events::listener_NewXDGDeco(wl_listener* listener, void* data) {
 void Events::listener_requestMaximize(void* owner, void* data) {
     const auto PWINDOW = (CWindow*)owner;
 
-    const auto EV = (wlr_foreign_toplevel_handle_v1_maximized_event*)data;
+    if (PWINDOW->m_bNoFullscreenRequest)
+        return;
 
-    g_pCompositor->setWindowFullscreen(PWINDOW, EV ? EV->maximized : !PWINDOW->m_bIsFullscreen, FULLSCREEN_MAXIMIZED); // this will be rejected if there already is a fullscreen window
-    
-    wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);
+    Debug::log(LOG, "Maximize request for %x", PWINDOW);
+    if (!PWINDOW->m_bIsX11) {
+        const auto EV = (wlr_foreign_toplevel_handle_v1_maximized_event*)data;
+
+        g_pCompositor->setWindowFullscreen(PWINDOW, EV ? EV->maximized : !PWINDOW->m_bIsFullscreen, FULLSCREEN_MAXIMIZED);  // this will be rejected if there already is a fullscreen window
+
+        wlr_xdg_surface_schedule_configure(PWINDOW->m_uSurface.xdg);
+    } else {
+        if (!PWINDOW->m_bMappedX11 || PWINDOW->m_iX11Type != 1)
+            return;
+
+        g_pCompositor->setWindowFullscreen(PWINDOW, !PWINDOW->m_bIsFullscreen, FULLSCREEN_MAXIMIZED);
+    }
 }
 
 void Events::listener_requestMinimize(void* owner, void* data) {
-    // ignore
+    const auto PWINDOW = (CWindow*)owner;
+
+    Debug::log(LOG, "Minimize request for %x", PWINDOW);
+
+    if (PWINDOW->m_bIsX11) {
+        if (!PWINDOW->m_bMappedX11 || PWINDOW->m_iX11Type != 1)
+            return;
+
+        const auto E = (wlr_xwayland_minimize_event*)data;
+
+        wlr_xwayland_surface_set_minimized(PWINDOW->m_uSurface.xwayland, E->minimize && g_pCompositor->m_pLastWindow != PWINDOW); // fucking DXVK
+    }
 }
 
 void Events::listener_requestMove(void* owner, void* data) {

src/helpers/AnimatedVariable.cpp

@@ -12,8 +12,6 @@ void CAnimatedVariable::create(ANIMATEDVARTYPE type, SAnimationPropertyConfig* p
     m_pConfig = pAnimConfig;
     m_pWindow = pWindow;
 
-    g_pAnimationManager->m_lAnimatedVariables.push_back(this);
-
     m_bDummy = false;
 }
 
@@ -56,8 +54,20 @@ CAnimatedVariable::~CAnimatedVariable() {
 
 void CAnimatedVariable::unregister() {
     g_pAnimationManager->m_lAnimatedVariables.remove(this);
+    m_bIsRegistered = false;
+}
+
+void CAnimatedVariable::registerVar() {
+    if (!m_bIsRegistered)
+        g_pAnimationManager->m_lAnimatedVariables.push_back(this);
+    m_bIsRegistered = true;
 }
 
 int CAnimatedVariable::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() {
+    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);
+}

src/helpers/AnimatedVariable.hpp

@@ -21,6 +21,7 @@ class CAnimationManager;
 class CWorkspace;
 struct SLayerSurface;
 struct SAnimationPropertyConfig;
+class CHyprRenderer;
 
 class CAnimatedVariable {
 public:
@@ -32,6 +33,7 @@ public:
     ~CAnimatedVariable();
 
     void unregister();
+    void registerVar();
 
     // gets the current vector value (real time)
     const Vector2D& vec() const {
@@ -67,18 +69,24 @@ public:
         m_vGoal = v;
         animationBegin = std::chrono::system_clock::now();
         m_vBegun = m_vValue;
+
+        onAnimationBegin();
     }
 
     void operator=(const float& v) {
         m_fGoal = v;
         animationBegin = std::chrono::system_clock::now();
         m_fBegun = m_fValue;
+
+        onAnimationBegin();
     }
 
     void operator=(const CColor& v) {
         m_cGoal = v;
         animationBegin = std::chrono::system_clock::now();
         m_cBegun = m_cValue;
+
+        onAnimationBegin();
     }
 
     // Sets the actual stored value, without affecting the goal, but resets the timer
@@ -86,6 +94,8 @@ public:
         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
@@ -93,6 +103,8 @@ public:
         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
@@ -100,6 +112,8 @@ public:
         m_cValue = v;
         animationBegin = std::chrono::system_clock::now();
         m_vBegun = m_vValue;
+
+        onAnimationBegin();
     }
 
     // Sets the actual value and goal
@@ -138,7 +152,7 @@ public:
         return false; // just so that the warning is suppressed
     }
 
-    void warp() {
+    void warp(bool endCallback = true) {
         switch (m_eVarType) {
             case AVARTYPE_FLOAT: {
                 m_fValue = m_fGoal;
@@ -155,6 +169,9 @@ public:
             default:
                 UNREACHABLE();
         }
+
+        if (endCallback)
+            onAnimationEnd();
     }
 
     void setConfig(SAnimationPropertyConfig* pConfig) {
@@ -167,6 +184,35 @@ public:
 
     int getDurationLeftMs();
 
+    /* returns the spent (completion) % */
+    float getPercent();
+
+    /*  sets a function to be ran when the animation finishes.
+        if an animation is not running, runs instantly.
+        if "remove" is set to true, will remove the callback when ran. */
+    void setCallbackOnEnd(std::function<void(void* thisptr)> func, bool remove = true) {
+        m_fEndCallback = func;
+        m_bRemoveEndAfterRan = remove;
+
+        if (!isBeingAnimated())
+            onAnimationEnd();
+    }
+
+    /*  sets a function to be ran when an animation is started.
+        if "remove" is set to true, will remove the callback when ran. */
+    void setCallbackOnBegin(std::function<void(void* thisptr)> func, bool remove = true) {
+        m_fBeginCallback = func;
+        m_bRemoveBeginAfterRan = remove;
+    }
+
+    /*  resets all callbacks. Does not call any. */
+    void resetAllCallbacks() {
+        m_fBeginCallback = nullptr;
+        m_fEndCallback = nullptr;
+        m_bRemoveBeginAfterRan = false;
+        m_bRemoveEndAfterRan = false;
+    }
+
 private:
 
     Vector2D        m_vValue = Vector2D(0,0);
@@ -189,13 +235,37 @@ private:
     SAnimationPropertyConfig* m_pConfig = nullptr;
 
     bool            m_bDummy = true;
+    bool            m_bIsRegistered = false;
 
     std::chrono::system_clock::time_point animationBegin;
 
     ANIMATEDVARTYPE     m_eVarType      = AVARTYPE_INVALID;
     AVARDAMAGEPOLICY    m_eDamagePolicy = AVARDAMAGE_INVALID;
 
+    bool            m_bRemoveEndAfterRan = true;
+    bool            m_bRemoveBeginAfterRan = true;
+    std::function<void(void* thisptr)> m_fEndCallback;
+    std::function<void(void* thisptr)> m_fBeginCallback;
+
+    // methods
+    void onAnimationEnd() {
+        if (m_fEndCallback) {
+            m_fEndCallback(this);
+            if (m_bRemoveEndAfterRan)
+                m_fEndCallback = nullptr;  // reset
+        }
+    }
+
+    void onAnimationBegin() {
+        if (m_fBeginCallback) {
+            m_fBeginCallback(this);
+            if (m_bRemoveBeginAfterRan)
+                m_fBeginCallback = nullptr;  // reset
+        }
+    }
+
     friend class CAnimationManager;
     friend class CWorkspace;
     friend struct SLayerSurface;
+    friend class CHyprRenderer;
 };

src/helpers/MiscFunctions.cpp

@@ -5,6 +5,31 @@
 #include <sys/utsname.h>
 #include <iomanip>
 
+#if defined(__DragonFly__) || defined(__FreeBSD__) || \
+  defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__)
+# include <sys/sysctl.h>
+# if defined(__DragonFly__)
+#  include <sys/kinfo.h>      // struct kinfo_proc
+# elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#  include <sys/user.h>       // struct kinfo_proc
+# endif
+
+# if defined(__NetBSD__)
+#  undef KERN_PROC
+#  define KERN_PROC KERN_PROC2
+#  define KINFO_PROC struct kinfo_proc2
+# else
+#  define KINFO_PROC struct kinfo_proc
+# endif
+# if defined(__DragonFly__)
+#  define KP_PPID(kp) kp.kp_ppid
+# elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#  define KP_PPID(kp) kp.ki_ppid
+# else
+#  define KP_PPID(kp) kp.p_ppid
+# endif
+#endif
+
 static const float transforms[][9] = {{
 		1.0f, 0.0f, 0.0f,
 		0.0f, 1.0f, 0.0f,
@@ -120,6 +145,9 @@ void scaleBox(wlr_box* box, float scale) {
 }
 
 std::string removeBeginEndSpacesTabs(std::string str) {
+    if (str.empty())
+        return str;
+
     int countBefore = 0;
     while (str[countBefore] == ' ' || str[countBefore] == '\t') {
         countBefore++;
@@ -178,7 +206,7 @@ bool isNumber(const std::string& str, bool allowfloat) {
     std::string copy = str;
     if (*copy.begin() == '-')
         copy = copy.substr(1);
-    
+
     if (copy.empty())
         return false;
 
@@ -206,7 +234,18 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
     int result = INT_MAX;
     if (in.find("special") == 0) {
         outName = "special";
-        return SPECIAL_WORKSPACE_ID;
+
+        if (in.length() > 8) {
+            const auto NAME = in.substr(8);
+
+            const auto WS = g_pCompositor->getWorkspaceByName("special:" + NAME);
+            
+            outName = "special:" + NAME;
+
+            return WS ? WS->m_iID : g_pCompositor->getNewSpecialID();
+        }
+
+        return SPECIAL_WORKSPACE_START;
     } else if (in.find("name:") == 0) {
         const auto WORKSPACENAME = in.substr(in.find_first_of(':') + 1);
         const auto WORKSPACE = g_pCompositor->getWorkspaceByName(WORKSPACENAME);
@@ -216,6 +255,13 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             result = WORKSPACE->m_iID;
         }
         outName = WORKSPACENAME;
+    } else if (in.find("empty") == 0) {
+        int id = 0;
+        while (++id < INT_MAX) {
+            const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(id);
+            if (!PWORKSPACE || (g_pCompositor->getWindowsOnWorkspace(id) == 0))
+                return id;
+        }
     } else {
         if ((in[0] == 'm' || in[0] == 'e') && (in[1] == '-' || in[1] == '+') && isNumber(in.substr(2))) {
             bool onAllMonitors = in[0] == 'e';
@@ -246,7 +292,7 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
                     int highestID = -99999;
 
                     for (auto& w : g_pCompositor->m_vWorkspaces) {
-                        if (w->m_iID == SPECIAL_WORKSPACE_ID)
+                        if (g_pCompositor->isWorkspaceSpecial(w->m_iID))
                             continue;
 
                         if (w->m_iID < lowestID)
@@ -262,7 +308,7 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
                         searchID = lowestID;
                 }
 
-                if (const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(searchID); PWORKSPACE && PWORKSPACE->m_iID != SPECIAL_WORKSPACE_ID) {
+                if (const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(searchID); PWORKSPACE && !PWORKSPACE->m_bIsSpecialWorkspace) {
                     if (onAllMonitors || PWORKSPACE->m_iMonitorID == g_pCompositor->m_pLastMonitor->ID) {
                         currentID = PWORKSPACE->m_iID;
 
@@ -331,7 +377,7 @@ void logSystemInfo() {
     Debug::log(LOG, "Node name: %s", unameInfo.nodename);
     Debug::log(LOG, "Release: %s", unameInfo.release);
     Debug::log(LOG, "Version: %s", unameInfo.version);
-    
+
     Debug::log(NONE, "\n");
 
     const std::string GPUINFO = execAndGet("lspci -vnn | grep VGA");
@@ -357,8 +403,8 @@ void matrixProjection(float mat[9], int w, int h, wl_output_transform tr) {
     // Rotation + reflection
     mat[0] = x * t[0];
     mat[1] = x * t[1];
-    mat[3] = y * -t[3];
-    mat[4] = y * -t[4];
+    mat[3] = y * t[3];
+    mat[4] = y * t[4];
 
     // Translation
     mat[2] = -copysign(1.0f, mat[0] + mat[1]);
@@ -369,6 +415,25 @@ void matrixProjection(float mat[9], int w, int h, wl_output_transform tr) {
 }
 
 int64_t getPPIDof(int64_t pid) {
+#if defined(KERN_PROC_PID)
+    int mib[] = {
+        CTL_KERN,
+        KERN_PROC,
+        KERN_PROC_PID,
+        (int)pid,
+# if defined(__NetBSD__) || defined(__OpenBSD__)
+        sizeof(KINFO_PROC),
+        1,
+# endif
+    };
+    u_int miblen = sizeof(mib) / sizeof(mib[0]);
+    KINFO_PROC kp;
+    size_t sz = sizeof(KINFO_PROC);
+    if (sysctl(mib, miblen, &kp, &sz, NULL, 0) != -1)
+        return KP_PPID(kp);
+
+    return 0;
+#else
     std::string dir = "/proc/" + std::to_string(pid) + "/status";
     FILE* infile;
 
@@ -401,4 +466,41 @@ int64_t getPPIDof(int64_t pid) {
     } catch (std::exception& e) {
         return 0;
     }
-}
+#endif
+}
+
+int64_t configStringToInt(const std::string& VALUE) {
+    if (VALUE.find("0x") == 0) {
+        // Values with 0x are hex
+        const auto VALUEWITHOUTHEX = VALUE.substr(2);
+        return stol(VALUEWITHOUTHEX, nullptr, 16);
+    } else if (VALUE.find("rgba(") == 0 && VALUE.find(")") == VALUE.length() - 1) {
+        const auto VALUEWITHOUTFUNC = VALUE.substr(5, VALUE.length() - 6);
+
+        if (removeBeginEndSpacesTabs(VALUEWITHOUTFUNC).length() != 8) {
+            Debug::log(WARN, "invalid length %i for rgba", VALUEWITHOUTFUNC.length());
+            throw std::invalid_argument("rgba() expects length of 8 characters (4 bytes)");
+        }
+
+        const auto RGBA = std::stol(VALUEWITHOUTFUNC, nullptr, 16);
+
+        // now we need to RGBA -> ARGB. The config holds ARGB only.
+        return (RGBA >> 8) + 0x1000000 * (RGBA & 0xFF);
+    } else if (VALUE.find("rgb(") == 0 && VALUE.find(")") == VALUE.length() - 1) {
+        const auto VALUEWITHOUTFUNC = VALUE.substr(4, VALUE.length() - 5);
+
+        if (removeBeginEndSpacesTabs(VALUEWITHOUTFUNC).length() != 6) {
+            Debug::log(WARN, "invalid length %i for rgb", VALUEWITHOUTFUNC.length());
+            throw std::invalid_argument("rgb() expects length of 6 characters (3 bytes)");
+        }
+
+        const auto RGB = std::stol(VALUEWITHOUTFUNC, nullptr, 16);
+
+        return RGB + 0xFF000000; // 0xFF for opaque
+    } else if (VALUE.find("true") == 0 || VALUE.find("on") == 0 || VALUE.find("yes") == 0) {
+        return 1;
+    } else if (VALUE.find("false") == 0 || VALUE.find("off") == 0 || VALUE.find("no") == 0) {
+        return 0;
+    }
+    return stol(VALUE);
+}

src/helpers/MiscFunctions.hpp

@@ -15,6 +15,7 @@ float vecToRectDistanceSquared(const Vector2D& vec, const Vector2D& p1, const Ve
 void logSystemInfo();
 std::string execAndGet(const char*);
 int64_t getPPIDof(int64_t pid);
+int64_t configStringToInt(const std::string&);
 
 float getPlusMinusKeywordResult(std::string in, float relative);
 

src/helpers/Monitor.cpp

@@ -3,21 +3,30 @@
 #include "../Compositor.hpp"
 
 void CMonitor::onConnect(bool noRule) {
-    if (m_bEnabled)
+    hyprListener_monitorDestroy.removeCallback();
+    hyprListener_monitorFrame.removeCallback();
+    hyprListener_monitorStateRequest.removeCallback();
+    hyprListener_monitorFrame.initCallback(&output->events.frame, &Events::listener_monitorFrame, this);
+    hyprListener_monitorDestroy.initCallback(&output->events.destroy, &Events::listener_monitorDestroy, this);
+    hyprListener_monitorStateRequest.initCallback(&output->events.request_state, &Events::listener_monitorStateRequest, this);
+
+    if (m_bEnabled) {
+        wlr_output_enable(output, 1);
+        wlr_output_commit(output);
         return;
+    }
 
     szName = output->name;
 
+    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 : "");
 
-    hyprListener_monitorFrame.initCallback(&output->events.frame, &Events::listener_monitorFrame, this);
-    hyprListener_monitorDestroy.initCallback(&output->events.destroy, &Events::listener_monitorDestroy, this);
-
     // if it's disabled, disable and ignore
     if (monitorRule.disabled) {
 
-        wlr_output_enable_adaptive_sync(output, 1);
         wlr_output_set_scale(output, 1);
         wlr_output_set_transform(output, WL_OUTPUT_TRANSFORM_NORMAL);
 
@@ -87,10 +96,8 @@ void CMonitor::onConnect(bool noRule) {
     }
 
     m_bEnabled = true;
-
-    wlr_output_set_scale(output, monitorRule.scale);
+    
     wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, monitorRule.scale);
-    wlr_output_set_transform(output, WL_OUTPUT_TRANSFORM_NORMAL);  // TODO: support other transforms
 
     // create it in the arr
     vecPosition = monitorRule.offset;
@@ -99,10 +106,6 @@ void CMonitor::onConnect(bool noRule) {
 
     wlr_output_enable(output, 1);
 
-    // TODO: this doesn't seem to set the X and Y correctly,
-    // wlr_output_layout_output_coords returns invalid values, I think...
-    wlr_output_layout_add(g_pCompositor->m_sWLROutputLayout, output, monitorRule.offset.x, monitorRule.offset.y);
-
     // set mode, also applies
     if (!noRule)
         g_pHyprRenderer->applyMonitorRule(this, &monitorRule, true);
@@ -127,15 +130,18 @@ void CMonitor::onConnect(bool noRule) {
     forceFullFrames = 3;  // force 3 full frames to make sure there is no blinking due to double-buffering.
     //
 
+    g_pEventManager->postEvent(SHyprIPCEvent{"monitoradded", szName});
+
     if (!g_pCompositor->m_pLastMonitor)  // set the last monitor if it isnt set yet
-        g_pCompositor->m_pLastMonitor = this;
+        g_pCompositor->setActiveMonitor(this);
 
     wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, scale);
 
     g_pHyprRenderer->arrangeLayersForMonitor(ID);
     g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
 
-    g_pEventManager->postEvent(SHyprIPCEvent{"monitoradded", szName});
+    // ensure VRR (will enable if necessary)
+    g_pConfigManager->ensureVRR(this);
 }
 
 void CMonitor::onDisconnect() {
@@ -143,6 +149,8 @@ void CMonitor::onDisconnect() {
     if (!m_bEnabled || g_pCompositor->m_bIsShuttingDown)
         return;
 
+    Debug::log(LOG, "onDisconnect called for %s", output->name);
+
     // Cleanup everything. Move windows back, snap cursor, shit.
     CMonitor* BACKUPMON = nullptr;
     for (auto& m : g_pCompositor->m_vMonitors) {
@@ -152,6 +160,9 @@ void CMonitor::onDisconnect() {
         }
     }
 
+    if (g_pCompositor->m_pLastMonitor == this)
+        g_pCompositor->setActiveMonitor(BACKUPMON);
+
     // remove mirror
     if (pMirrorOf) {
         pMirrorOf->mirrors.erase(std::find_if(pMirrorOf->mirrors.begin(), pMirrorOf->mirrors.end(), [&](const auto& other) { return other == this; }));
@@ -174,7 +185,7 @@ void CMonitor::onDisconnect() {
     if (!BACKUPMON) {
         Debug::log(WARN, "Unplugged last monitor, entering an unsafe state. Good luck my friend.");
 
-        hyprListener_monitorMode.removeCallback();
+        hyprListener_monitorStateRequest.removeCallback();
         hyprListener_monitorDestroy.removeCallback();
 
         g_pCompositor->m_bUnsafeState = true;
@@ -182,10 +193,8 @@ void CMonitor::onDisconnect() {
         return;
     }
 
-    const auto BACKUPWORKSPACE = BACKUPMON->activeWorkspace > 0 ? std::to_string(BACKUPMON->activeWorkspace) : "name:" + g_pCompositor->getWorkspaceByID(BACKUPMON->activeWorkspace)->m_szName;
-
     // snap cursor
-    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, BACKUPMON->vecPosition.x + BACKUPMON->vecTransformedSize.x / 2.f, BACKUPMON->vecPosition.y + BACKUPMON->vecTransformedSize.y / 2.f);
+    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, BACKUPMON->vecPosition.x + BACKUPMON->vecTransformedSize.x / 2.f, BACKUPMON->vecPosition.y + BACKUPMON->vecTransformedSize.y / 2.f);
 
     // move workspaces
     std::deque<CWorkspace*> wspToMove;
@@ -210,13 +219,13 @@ void CMonitor::onDisconnect() {
 
     wlr_output_commit(output);
 
-    g_pCompositor->m_vWorkspaces.erase(std::remove_if(g_pCompositor->m_vWorkspaces.begin(), g_pCompositor->m_vWorkspaces.end(), [&](std::unique_ptr<CWorkspace>& el) { return el->m_iMonitorID == ID; }));
+    std::erase_if(g_pCompositor->m_vWorkspaces, [&](std::unique_ptr<CWorkspace>& el) { return el->m_iMonitorID == ID; });
 
     Debug::log(LOG, "Removed monitor %s!", szName.c_str());
 
     g_pEventManager->postEvent(SHyprIPCEvent{"monitorremoved", szName});
 
-    g_pCompositor->m_vMonitors.erase(std::remove_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](std::shared_ptr<CMonitor>& el) { return el.get() == this; }));
+    std::erase_if(g_pCompositor->m_vMonitors, [&](std::shared_ptr<CMonitor>& el) { return el.get() == this; });
 }
 
 void CMonitor::addDamage(pixman_region32_t* rg) {
@@ -234,9 +243,9 @@ bool CMonitor::isMirror() {
 void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
     // Workspace
     std::string newDefaultWorkspaceName = "";
-    auto WORKSPACEID = monitorRule.defaultWorkspace == "" ? g_pCompositor->m_vWorkspaces.size() + 1 : getWorkspaceIDFromString(monitorRule.defaultWorkspace, newDefaultWorkspaceName);
+    int64_t WORKSPACEID = monitorRule.defaultWorkspace == "" ? g_pCompositor->m_vWorkspaces.size() + 1 : getWorkspaceIDFromString(monitorRule.defaultWorkspace, newDefaultWorkspaceName);
 
-    if (WORKSPACEID == INT_MAX || WORKSPACEID == (long unsigned int)SPECIAL_WORKSPACE_ID) {
+    if (WORKSPACEID == INT_MAX || (WORKSPACEID >= SPECIAL_WORKSPACE_START && WORKSPACEID <= -2)) {
         WORKSPACEID = g_pCompositor->m_vWorkspaces.size() + 1;
         newDefaultWorkspaceName = std::to_string(WORKSPACEID);
 
@@ -318,7 +327,7 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
 
         setupDefaultWS(RULE);
 
-        wlr_output_layout_add(g_pCompositor->m_sWLROutputLayout, output, (int)vecPosition.x, (int)vecPosition.y);
+        g_pHyprRenderer->applyMonitorRule(this, (SMonitorRule*)&RULE, true); // will apply the offset and stuff
     } else {
         CMonitor* BACKUPMON = nullptr;
         for (auto& m : g_pCompositor->m_vMonitors) {
@@ -356,6 +365,6 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
             g_pCompositor->m_vMonitors.erase(std::remove_if(g_pCompositor->m_vMonitors.begin(), g_pCompositor->m_vMonitors.end(), [&](const auto& other) { return other.get() == this; }));
         }
 
-        g_pCompositor->m_pLastMonitor = g_pCompositor->m_vMonitors.front().get();
+        g_pCompositor->setActiveMonitor(g_pCompositor->m_vMonitors.front().get());
     }
 }

src/helpers/Monitor.hpp

@@ -11,7 +11,7 @@ struct SMonitorRule;
 
 class CMonitor {
 public:
-    Vector2D    vecPosition         = Vector2D(0,0);
+    Vector2D    vecPosition         = Vector2D(-1,-1); // means unset
     Vector2D    vecSize             = Vector2D(0,0);
     Vector2D    vecPixelSize        = Vector2D(0,0);
     Vector2D    vecTransformedSize  = Vector2D(0,0);
@@ -38,13 +38,16 @@ public:
     wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL;
 
     bool        dpmsStatus = true;
+    bool        vrrActive = false; // this can be TRUE even if VRR is not active in the case that this display does not support it.
+    bool        enabled10bit = false; // as above, this can be TRUE even if 10 bit failed.
+    bool        createdByUser = false;
 
     // mirroring
     CMonitor*   pMirrorOf = nullptr;
     std::vector<CMonitor*> mirrors;
 
-    // for the special workspace
-    bool        specialWorkspaceOpen = false;
+    // for the special workspace. 0 means not open.
+    int         specialWorkspaceID = 0;
 
     // Double-linked list because we need to have constant mem addresses for signals
     // We have to store pointers and use raw new/delete because they might be moved between them
@@ -53,7 +56,7 @@ public:
 
     DYNLISTENER(monitorFrame);
     DYNLISTENER(monitorDestroy);
-    DYNLISTENER(monitorMode);
+    DYNLISTENER(monitorStateRequest);
 
     // hack: a group = workspaces on a monitor.
     // I don't really care lol :P

src/helpers/SubsurfaceTree.cpp

@@ -3,8 +3,8 @@
 #include "../Compositor.hpp"
 
 void addSurfaceGlobalOffset(SSurfaceTreeNode* node, int* lx, int* ly) {
-    *lx += node->pSurface->sx;
-    *ly += node->pSurface->sy;
+    *lx += node->pSurface->current.dx;
+    *ly += node->pSurface->current.dy;
 
     if (node->offsetfn) {
         // This is the root node

src/helpers/WLClasses.cpp

@@ -4,4 +4,5 @@
 SLayerSurface::SLayerSurface() {
     alpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), nullptr, AVARDAMAGE_ENTIRE);
     alpha.m_pLayer = this;
+    alpha.registerVar();
 }

src/helpers/WLClasses.hpp

@@ -70,6 +70,7 @@ struct SRenderData {
 
     // for blurring
     bool blur = false;
+    bool blockBlurOptimization = false;
 
     // only for windows, not popups
     bool squishOversized = true;
@@ -131,6 +132,8 @@ struct SMouse {
 
     bool        virt = false;
 
+    bool        connected = false; // means connected to the cursor
+
     DYNLISTENER(commitConstraint);
     DYNLISTENER(destroyMouse);
 
@@ -326,6 +329,10 @@ struct SIMEPopup {
 struct STouchDevice {
     wlr_input_device* pWlrDevice = nullptr;
 
+    std::string name = "";
+
+    std::string boundOutput = "";
+
     DYNLISTENER(destroy);
 
     bool operator==(const STouchDevice& other) {

src/helpers/Workspace.cpp

@@ -31,6 +31,9 @@ CWorkspace::CWorkspace(int monitorID, std::string name, bool special) {
     m_fAlpha.create(AVARTYPE_FLOAT, special ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspace") : g_pConfigManager->getAnimationPropertyConfig("workspaces"), nullptr, AVARDAMAGE_ENTIRE);
     m_fAlpha.setValueAndWarp(255.f);
 
+    m_vRenderOffset.registerVar();
+    m_fAlpha.registerVar();
+
     g_pEventManager->postEvent({"createworkspace", m_szName}, true);
 }
 
@@ -93,7 +96,7 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
     }
 
     // check LS-es
-    if (in) {
+    if (in && !m_bIsSpecialWorkspace) {
         const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
         for (auto& ls : PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
             if (!ls->fadingOut)

src/helpers/XWaylandStubs.hpp

@@ -0,0 +1,161 @@
+#pragma once
+
+#include <wayland-server.h>
+
+typedef unsigned int xcb_atom_t;
+struct xcb_icccm_wm_hints_t;
+typedef struct {
+    /** User specified flags */
+    uint32_t flags;
+    /** User-specified position */
+    int32_t x, y;
+    /** User-specified size */
+    int32_t width, height;
+    /** Program-specified minimum size */
+    int32_t min_width, min_height;
+    /** Program-specified maximum size */
+    int32_t max_width, max_height;
+    /** Program-specified resize increments */
+    int32_t width_inc, height_inc;
+    /** Program-specified minimum aspect ratios */
+    int32_t min_aspect_num, min_aspect_den;
+    /** Program-specified maximum aspect ratios */
+    int32_t max_aspect_num, max_aspect_den;
+    /** Program-specified base size */
+    int32_t base_width, base_height;
+    /** Program-specified window gravity */
+    uint32_t win_gravity;
+} xcb_size_hints_t;
+typedef unsigned int xcb_window_t;
+
+typedef enum xcb_stack_mode_t {
+    XCB_STACK_MODE_ABOVE = 0,
+    XCB_STACK_MODE_BELOW = 1,
+    XCB_STACK_MODE_TOP_IF = 2,
+    XCB_STACK_MODE_BOTTOM_IF = 3,
+    XCB_STACK_MODE_OPPOSITE = 4
+} xcb_stack_mode_t;
+
+struct wlr_xwayland {
+    struct wlr_xwayland_server *server;
+	struct wlr_xwm *xwm;
+	struct wlr_xwayland_cursor *cursor;
+
+	const char *display_name;
+
+	struct wl_display *wl_display;
+	struct wlr_compositor *compositor;
+	struct wlr_seat *seat;
+
+	void *data;
+};
+
+struct wlr_xwayland_surface {
+    xcb_window_t window_id;
+    struct wlr_xwm *xwm;
+    uint32_t surface_id;
+
+    struct wl_list link;
+    struct wl_list stack_link;
+    struct wl_list unpaired_link;
+
+    struct wlr_surface *surface;
+    int16_t x, y;
+    uint16_t width, height;
+    uint16_t saved_width, saved_height;
+    bool override_redirect;
+    bool mapped;
+
+    char *title;
+    char *_class;
+    char *instance;
+    char *role;
+    char *startup_id;
+    pid_t pid;
+    bool has_utf8_title;
+
+    struct wl_list children;  // wlr_xwayland_surface::parent_link
+    struct wlr_xwayland_surface *parent;
+    struct wl_list parent_link;  // wlr_xwayland_surface::children
+
+    xcb_atom_t *window_type;
+    size_t window_type_len;
+
+    xcb_atom_t *protocols;
+    size_t protocols_len;
+
+    uint32_t decorations;
+    xcb_icccm_wm_hints_t *hints;
+    xcb_size_hints_t *size_hints;
+
+    bool pinging;
+    struct wl_event_source *ping_timer;
+
+    // _NET_WM_STATE
+    bool modal;
+    bool fullscreen;
+    bool maximized_vert, maximized_horz;
+    bool minimized;
+
+    bool has_alpha;
+
+    struct {
+        struct wl_signal destroy;
+        struct wl_signal request_configure;
+        struct wl_signal request_move;
+        struct wl_signal request_resize;
+        struct wl_signal request_minimize;
+        struct wl_signal request_maximize;
+        struct wl_signal request_fullscreen;
+        struct wl_signal request_activate;
+
+        struct wl_signal map;
+        struct wl_signal unmap;
+        struct wl_signal set_title;
+        struct wl_signal set_class;
+        struct wl_signal set_role;
+        struct wl_signal set_parent;
+        struct wl_signal set_pid;
+        struct wl_signal set_startup_id;
+        struct wl_signal set_window_type;
+        struct wl_signal set_hints;
+        struct wl_signal set_decorations;
+        struct wl_signal set_override_redirect;
+        struct wl_signal set_geometry;
+        struct wl_signal ping_timeout;
+    } events;
+};
+
+struct wlr_xwayland_surface_configure_event {
+    struct wlr_xwayland_surface *surface;
+    int16_t x, y;
+    uint16_t width, height;
+    uint16_t mask;  // xcb_config_window_t
+};
+
+struct wlr_xwayland_minimize_event {
+    struct wlr_xwayland_surface *surface;
+    bool minimize;
+};
+
+inline void wlr_xwayland_destroy(wlr_xwayland*) { }
+
+inline void wlr_xwayland_surface_configure(wlr_xwayland_surface*, int, int, int, int) { }
+
+inline bool wlr_surface_is_xwayland_surface(void*) { return false; }
+
+inline void wlr_xwayland_surface_activate(wlr_xwayland_surface*, bool) { }
+
+inline void wlr_xwayland_surface_restack(wlr_xwayland_surface*, int, xcb_stack_mode_t) { }
+
+inline wlr_xwayland_surface* wlr_xwayland_surface_from_wlr_surface(void*) { return nullptr; }
+
+inline void wlr_xwayland_surface_close(wlr_xwayland_surface*) { }
+
+inline void wlr_xwayland_surface_set_fullscreen(wlr_xwayland_surface*, bool) { }
+
+inline void wlr_xwayland_surface_set_minimized(wlr_xwayland_surface *, bool) { }
+
+inline bool wlr_backend_is_x11(void*) { return false; }
+
+inline void wlr_x11_output_create(void*) { }

src/hyprerror/HyprError.cpp

@@ -67,10 +67,10 @@ void CHyprError::createQueued() {
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
-    #ifndef GLES2
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
-    #endif
+#ifndef GLES2
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_R, GL_BLUE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_B, GL_RED);
+#endif
 
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, DATA);
 

src/includes.hpp

@@ -22,7 +22,6 @@
 #include <filesystem>
 #include <climits>
 
-
 #if true
 // wlroots uses dumb-ass shit that makes it not compile on C++, let's fix that.
 // https://github.com/swaywm/wlroots/issues/682
@@ -80,13 +79,11 @@ extern "C" {
 #include <wlr/types/wlr_foreign_toplevel_management_v1.h>
 #include <wlr/types/wlr_idle_inhibit_v1.h>
 #include <wlr/util/log.h>
-#include <wlr/xwayland.h>
 #include <wlr/util/region.h>
 #include <wlr/types/wlr_tablet_pad.h>
 #include <wlr/types/wlr_tablet_tool.h>
 #include <wlr/types/wlr_tablet_v2.h>
 #include <xkbcommon/xkbcommon.h>
-#include <X11/Xproto.h>
 #include <wlr/render/egl.h>
 #include <wlr/render/gles2.h>
 #include <wlr/render/wlr_texture.h>
@@ -102,6 +99,18 @@ extern "C" {
 #include <wlr/types/wlr_text_input_v3.h>
 #include <wlr/types/wlr_touch.h>
 #include <wlr/types/wlr_switch.h>
+#include <wlr/config.h>
+#include <wlr/backend/headless.h>
+#include <wlr/backend/multi.h>
+#include <wlr/backend/wayland.h>
+
+#include <drm_fourcc.h>
+
+#ifndef NO_XWAYLAND
+#include <wlr/backend/x11.h>
+#include <wlr/xwayland.h>
+#include <X11/Xproto.h>
+#endif
 }
 
 #undef delete
@@ -122,13 +131,11 @@ extern "C" {
 
 #ifdef NO_XWAYLAND
 #define XWAYLAND false
+#include "helpers/XWaylandStubs.hpp"
 #else
 #define XWAYLAND true
 #endif
 
 #include "helpers/Vector2D.hpp"
 
-#include "ext-workspace-unstable-v1-protocol.h"
-
-#include <algorithm>
-#include <utility>
+#include "ext-workspace-unstable-v1-protocol.h"

src/layout/DwindleLayout.cpp

@@ -69,7 +69,7 @@ SDwindleNodeData* SDwindleNodeData::getGroupVisible() {
     SDwindleNodeData* current = this->pNextGroupMember;
 
     while (current != this) {
-        if (!current->pWindow->m_bHidden) {
+        if (!current->pWindow->isHidden()) {
             return current;
         }
 
@@ -83,11 +83,11 @@ void SDwindleNodeData::setGroupFocusedNode(SDwindleNodeData* pMember) {
     SDwindleNodeData* current = this->pNextGroupMember;
 
     while (current != this) {
-        current->pWindow->m_bHidden = current != pMember;
+        current->pWindow->setHidden(current != pMember);
         current = current->pNextGroupMember;
     }
 
-    this->pWindow->m_bHidden = pMember != this;
+    this->pWindow->setHidden(pMember != this);
 }
 
 int SDwindleNodeData::getGroupMemberCount() {
@@ -144,9 +144,9 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
 
     CMonitor* PMONITOR = nullptr;
 
-    if (pNode->workspaceID == SPECIAL_WORKSPACE_ID) {
+    if (g_pCompositor->isWorkspaceSpecial(pNode->workspaceID)) {
         for (auto& m : g_pCompositor->m_vMonitors) {
-            if (m->specialWorkspaceOpen) {
+            if (m->specialWorkspaceID == pNode->workspaceID) {
                 PMONITOR = m.get();
                 break;
             }
@@ -188,7 +188,7 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
 
     const auto NODESONWORKSPACE = getNodesOnWorkspace(PWINDOW->m_iWorkspaceID);
 
-    if (*PNOGAPSWHENONLY && PWINDOW->m_iWorkspaceID != SPECIAL_WORKSPACE_ID && (NODESONWORKSPACE == 1 || (pNode->isGroupMember() && pNode->getGroupMemberCount() == NODESONWORKSPACE))) {
+    if (*PNOGAPSWHENONLY && !g_pCompositor->isWorkspaceSpecial(PWINDOW->m_iWorkspaceID) && (NODESONWORKSPACE == 1 || (pNode->isGroupMember() && pNode->getGroupMemberCount() == NODESONWORKSPACE) || (PWINDOW->m_bIsFullscreen && g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_efFullscreenMode == FULLSCREEN_MAXIMIZED))) {
         PWINDOW->m_vRealPosition = calcPos - Vector2D(*PBORDERSIZE, *PBORDERSIZE);
         PWINDOW->m_vRealSize = calcSize + Vector2D(2 * *PBORDERSIZE, 2 * *PBORDERSIZE);
 
@@ -238,7 +238,7 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
         }
     }
 
-    if (PWINDOW->m_iWorkspaceID == SPECIAL_WORKSPACE_ID) {
+    if (g_pCompositor->isWorkspaceSpecial(PWINDOW->m_iWorkspaceID)) {
         // if special, we adjust the coords a bit
         static auto *const PSCALEFACTOR = &g_pConfigManager->getConfigValuePtr("dwindle:special_scale_factor")->floatValue;
 
@@ -293,7 +293,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     SDwindleNodeData* OPENINGON;
     const auto MONFROMCURSOR = g_pCompositor->getMonitorFromCursor();
 
-    if (PMONITOR->ID == MONFROMCURSOR->ID && (PNODE->workspaceID == PMONITOR->activeWorkspace || (PNODE->workspaceID == SPECIAL_WORKSPACE_ID && PMONITOR->specialWorkspaceOpen)) && !*PUSEACTIVE) {
+    if (PMONITOR->ID == MONFROMCURSOR->ID && (PNODE->workspaceID == PMONITOR->activeWorkspace || (g_pCompositor->isWorkspaceSpecial(PNODE->workspaceID) && PMONITOR->specialWorkspaceID)) && !*PUSEACTIVE) {
         OPENINGON = getNodeFromWindow(g_pCompositor->vectorToWindowTiled(g_pInputManager->getMouseCoordsInternal()));
 
         // happens on reserved area
@@ -301,7 +301,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
             OPENINGON = getFirstNodeOnWorkspace(PMONITOR->activeWorkspace);
 
     } else if (*PUSEACTIVE) {
-        if (g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow) && !g_pCompositor->m_pLastWindow->m_bIsFloating && g_pCompositor->m_pLastWindow != pWindow && g_pCompositor->m_pLastWindow->m_iWorkspaceID == pWindow->m_iWorkspaceID && g_pCompositor->m_pLastWindow->m_bIsMapped) {
+        if (g_pCompositor->m_pLastWindow && !g_pCompositor->m_pLastWindow->m_bIsFloating && g_pCompositor->m_pLastWindow != pWindow && g_pCompositor->m_pLastWindow->m_iWorkspaceID == pWindow->m_iWorkspaceID && g_pCompositor->m_pLastWindow->m_bIsMapped) {
             OPENINGON = getNodeFromWindow(g_pCompositor->m_pLastWindow);
         } else {
             OPENINGON = getNodeFromWindow(g_pCompositor->vectorToWindowTiled(g_pInputManager->getMouseCoordsInternal()));
@@ -457,6 +457,10 @@ void CHyprDwindleLayout::onWindowRemovedTiling(CWindow* pWindow) {
         return;
     }
 
+    pWindow->m_sSpecialRenderData.rounding = true;
+    pWindow->m_sSpecialRenderData.border = true;
+    pWindow->m_sSpecialRenderData.decorate = true;
+
     if (pWindow->m_bIsFullscreen)
         g_pCompositor->setWindowFullscreen(pWindow, false, FULLSCREEN_FULL);
 
@@ -491,7 +495,7 @@ void CHyprDwindleLayout::onWindowRemovedTiling(CWindow* pWindow) {
         }
 
         PNEXT->setGroupFocusedNode(PNEXT);
-        PNEXT->pWindow->m_bHidden = false;
+        PNEXT->pWindow->setHidden(false);
 
         m_lDwindleNodesData.remove(*PNODE);
 
@@ -563,8 +567,8 @@ void CHyprDwindleLayout::recalculateMonitor(const int& monid) {
 
     g_pHyprRenderer->damageMonitor(PMONITOR);
 
-    if (PMONITOR->specialWorkspaceOpen) {
-        const auto TOPNODE = getMasterNodeOnWorkspace(SPECIAL_WORKSPACE_ID);
+    if (PMONITOR->specialWorkspaceID) {
+        const auto TOPNODE = getMasterNodeOnWorkspace(PMONITOR->specialWorkspaceID);
 
         if (TOPNODE && PMONITOR) {
             TOPNODE->position = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
@@ -705,7 +709,7 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscree
     if (!g_pCompositor->windowValidMapped(pWindow))
         return;
 
-    if (on == pWindow->m_bIsFullscreen || pWindow->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+    if (on == pWindow->m_bIsFullscreen || g_pCompositor->isWorkspaceSpecial(pWindow->m_iWorkspaceID))
         return; // ignore
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
@@ -829,7 +833,7 @@ void CHyprDwindleLayout::toggleWindowGroup(CWindow* pWindow) {
 
             toAddWindows.push_back(PWINDOW);
 
-            PWINDOW->m_bHidden = false;
+            PWINDOW->setHidden(false);
         }
 
 	if (PHEAD->pPreviousGroupMember)
@@ -997,9 +1001,9 @@ void CHyprDwindleLayout::switchGroupWindow(CWindow* pWindow, bool forward, CWind
     pNewNode->pWindow->m_bIsFloating = PNODE->pWindow->m_bIsFloating;
 
     if (PNODE->pWindow->m_bIsFullscreen) {
-        PNODE->pWindow->m_bHidden = false;
+        PNODE->pWindow->setHidden(false);
         g_pCompositor->setWindowFullscreen(PNODE->pWindow, false, PWORKSPACE->m_efFullscreenMode);
-        PNODE->pWindow->m_bHidden = true;
+        PNODE->pWindow->setHidden(true);
         g_pCompositor->setWindowFullscreen(pNewNode->pWindow, true, PWORKSPACE->m_efFullscreenMode);
 
         pNewNode->pWindow->m_vRealSize.warp();
@@ -1008,6 +1012,8 @@ void CHyprDwindleLayout::switchGroupWindow(CWindow* pWindow, bool forward, CWind
 
     pNewNode->pWindow->updateWindowDecos();
     PNODE->pWindow->updateWindowDecos();
+
+    g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID));
 }
 
 SWindowRenderLayoutHints CHyprDwindleLayout::requestRenderHints(CWindow* pWindow) {
@@ -1132,6 +1138,9 @@ void CHyprDwindleLayout::switchWindows(CWindow* pWindow, CWindow* pWindow2) {
 		ACTIVE2->pWindow->m_vPosition = ACTIVE2->position;
 		ACTIVE2->pWindow->m_vSize = ACTIVE2->size;
 	}
+
+    g_pHyprRenderer->damageWindow(pWindow);
+    g_pHyprRenderer->damageWindow(pWindow2);
 }
 
 void CHyprDwindleLayout::alterSplitRatioBy(CWindow* pWindow, float ratio) {
@@ -1181,7 +1190,7 @@ std::string CHyprDwindleLayout::getLayoutName() {
 
 void CHyprDwindleLayout::onEnable() {
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_bIsFloating || !w->m_bMappedX11 || !w->m_bIsMapped || w->m_bHidden)
+        if (w->m_bIsFloating || !w->m_bMappedX11 || !w->m_bIsMapped || w->isHidden())
             continue;
 
         onWindowCreatedTiling(w.get());

src/layout/IHyprLayout.cpp

@@ -26,6 +26,9 @@ void IHyprLayout::onWindowRemoved(CWindow* pWindow) {
     } else {
         onWindowRemovedTiling(pWindow);
     }
+
+    if (pWindow == m_pLastTiledWindow)
+        m_pLastTiledWindow = nullptr;
 }
 
 void IHyprLayout::onWindowRemovedFloating(CWindow* pWindow) {
@@ -47,7 +50,7 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
         pWindow->m_vRealSize = Vector2D(PWINDOWSURFACE->current.width, PWINDOWSURFACE->current.height);
 
         if ((desiredGeometry.width <= 1 || desiredGeometry.height <= 1) && pWindow->m_bIsX11 && pWindow->m_iX11Type == 2) { // XDG windows should be fine. TODO: check for weird atoms?
-            pWindow->m_bHidden = true;
+            pWindow->setHidden(true);
             return;
         }
 
@@ -131,6 +134,8 @@ void IHyprLayout::onBeginDragWindow() {
         return;
     }
 
+    g_pInputManager->setCursorImageUntilUnset("hand1");
+
     DRAGGINGWINDOW->m_vRealPosition.setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsMove"));
     DRAGGINGWINDOW->m_vRealSize.setConfig(g_pConfigManager->getAnimationPropertyConfig("windowsMove"));
 
@@ -178,12 +183,17 @@ void IHyprLayout::onEndDragWindow() {
     if (!g_pCompositor->windowValidMapped(DRAGGINGWINDOW))
         return;
 
+    g_pInputManager->unsetCursorImage();
+
     if (DRAGGINGWINDOW->m_bDraggingTiled) {
         DRAGGINGWINDOW->m_bIsFloating = false;
+        g_pInputManager->refocus();
         changeWindowFloatingMode(DRAGGINGWINDOW);
     }
 
     g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
+
+    g_pCompositor->focusWindow(DRAGGINGWINDOW);
 }
 
 void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
@@ -208,7 +218,12 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
     g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
 
     if (g_pInputManager->dragMode == MBIND_MOVE) {
-        DRAGGINGWINDOW->m_vRealPosition.setValueAndWarp(m_vBeginDragPositionXY + DELTA);
+
+        if (*PANIMATE) {
+            DRAGGINGWINDOW->m_vRealPosition = m_vBeginDragPositionXY + DELTA;
+        } else {
+            DRAGGINGWINDOW->m_vRealPosition.setValueAndWarp(m_vBeginDragPositionXY + DELTA);
+        }
 
         g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goalv());
     } else if (g_pInputManager->dragMode == MBIND_RESIZE) {
@@ -288,14 +303,17 @@ void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
         pWindow->moveToWorkspace(PNEWMON->activeWorkspace);
 
         // save real pos cuz the func applies the default 5,5 mid
-        const auto PSAVEDPOS = pWindow->m_vRealPosition.vec();
-        const auto PSAVEDSIZE = pWindow->m_vRealSize.vec();
+        const auto PSAVEDPOS = pWindow->m_vRealPosition.goalv();
+        const auto PSAVEDSIZE = pWindow->m_vRealSize.goalv();
 
         // if the window is pseudo, update its size
-        pWindow->m_vPseudoSize = pWindow->m_vRealSize.vec();
+        pWindow->m_vPseudoSize = pWindow->m_vRealSize.goalv();
 
         pWindow->m_vLastFloatingSize = PSAVEDSIZE;
 
+        // move to narnia because we don't wanna find our own node. onWindowCreatedTiling should apply the coords back.
+        pWindow->m_vPosition = Vector2D(-999999, -999999);
+
         onWindowCreatedTiling(pWindow);
 
         pWindow->m_vRealPosition.setValue(PSAVEDPOS);
@@ -303,20 +321,26 @@ void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
 
         // fix pseudo leaving artifacts
         g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID));
-    } else {
-        pWindow->m_vSize = pWindow->m_vRealSize.vec();
-        pWindow->m_vPosition = pWindow->m_vRealPosition.vec();
 
+        if (pWindow == g_pCompositor->m_pLastWindow)
+            m_pLastTiledWindow = pWindow;
+    } else {
         onWindowRemovedTiling(pWindow);
 
         g_pCompositor->moveWindowToTop(pWindow);
 
-        pWindow->m_vRealPosition = pWindow->m_vRealPosition.vec() + (pWindow->m_vRealSize.vec() - pWindow->m_vLastFloatingSize) / 2.f;
+        pWindow->m_vRealPosition = pWindow->m_vRealPosition.goalv() + (pWindow->m_vRealSize.goalv() - pWindow->m_vLastFloatingSize) / 2.f;
         pWindow->m_vRealSize = pWindow->m_vLastFloatingSize;
 
+        pWindow->m_vSize = pWindow->m_vRealSize.goalv();
+        pWindow->m_vPosition = pWindow->m_vRealPosition.goalv();
+
         g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID));
 
         pWindow->m_sSpecialRenderData.rounding = true;
+
+        if (pWindow == m_pLastTiledWindow)
+            m_pLastTiledWindow = nullptr;
     }
 
     g_pCompositor->updateWindowAnimatedDecorationValues(pWindow);
@@ -339,3 +363,59 @@ void IHyprLayout::moveActiveWindow(const Vector2D& delta, CWindow* pWindow) {
 
     g_pHyprRenderer->damageWindow(PWINDOW);
 }
+
+void IHyprLayout::onWindowFocusChange(CWindow* pNewFocus) {
+    m_pLastTiledWindow = pNewFocus && !pNewFocus->m_bIsFloating ? pNewFocus : m_pLastTiledWindow;
+}
+
+CWindow* IHyprLayout::getNextWindowCandidate(CWindow* pWindow) {
+    // although we don't expect nullptrs here, let's verify jic
+    if (!pWindow)
+        return nullptr;
+
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
+
+    // first of all, if this is a fullscreen workspace,
+    if (PWORKSPACE->m_bHasFullscreenWindow)
+        return g_pCompositor->getFullscreenWindowOnWorkspace(pWindow->m_iWorkspaceID);
+
+    if (pWindow->m_bIsFloating) {
+
+        // find whether there is a floating window below this one
+        for (auto& w : g_pCompositor->m_vWindows) {
+            if (w->m_bIsMapped && !w->isHidden() && w->m_bIsFloating && w->m_iX11Type != 2 && w->m_iWorkspaceID == pWindow->m_iWorkspaceID && !w->m_bX11ShouldntFocus && !w->m_bNoFocus) {
+                if (VECINRECT((pWindow->m_vSize / 2.f + pWindow->m_vPosition), w->m_vPosition.x, w->m_vPosition.y, w->m_vPosition.x + w->m_vSize.x, w->m_vPosition.y + w->m_vSize.y)) {
+                    return w.get();
+                }
+            }
+        }
+
+        // let's try the last tiled window.
+        if (m_pLastTiledWindow && m_pLastTiledWindow->m_iWorkspaceID == pWindow->m_iWorkspaceID)
+            return m_pLastTiledWindow;
+
+        // if we don't, let's try to find any window that is in the middle
+        if (const auto PWINDOWCANDIDATE = g_pCompositor->vectorToWindowIdeal(pWindow->m_vRealPosition.goalv() + pWindow->m_vRealSize.goalv() / 2.f); PWINDOWCANDIDATE)
+            return PWINDOWCANDIDATE;
+
+        // if not, floating window
+        for (auto& w : g_pCompositor->m_vWindows) {
+            if (w->m_bIsMapped && !w->isHidden() && w->m_bIsFloating && w->m_iX11Type != 2 && w->m_iWorkspaceID == pWindow->m_iWorkspaceID && !w->m_bX11ShouldntFocus && !w->m_bNoFocus)
+                return w.get();
+        }
+
+        // if there is no candidate, too bad
+        return nullptr;
+    }
+
+    // if it was a tiled window, we first try to find the window that will replace it.
+    const auto PWINDOWCANDIDATE = g_pCompositor->vectorToWindowIdeal(pWindow->m_vRealPosition.goalv() + pWindow->m_vRealSize.goalv() / 2.f);
+
+    if (!PWINDOWCANDIDATE || pWindow == PWINDOWCANDIDATE || !PWINDOWCANDIDATE->m_bIsMapped || PWINDOWCANDIDATE->isHidden() || PWINDOWCANDIDATE->m_bX11ShouldntFocus || PWINDOWCANDIDATE->m_iX11Type == 2 || PWINDOWCANDIDATE->m_iMonitorID != g_pCompositor->m_pLastMonitor->ID)
+        return nullptr;
+
+    return PWINDOWCANDIDATE;
+}
+
+IHyprLayout::~IHyprLayout() {
+}

src/layout/IHyprLayout.hpp

@@ -16,6 +16,7 @@ enum eFullscreenMode : uint8_t;
 
 interface IHyprLayout {
 public:
+    virtual ~IHyprLayout() = 0;
     virtual void        onEnable() = 0;
     virtual void        onDisable() = 0;
 
@@ -123,10 +124,22 @@ public:
     */
     virtual std::string  getLayoutName() = 0;
 
+    /*
+        Called for getting the next candidate for a focus
+    */
+    virtual CWindow*     getNextWindowCandidate(CWindow*);
+
+    /*
+        Internal: called when window focus changes
+    */
+    virtual void         onWindowFocusChange(CWindow*);
+
 private:
     Vector2D                        m_vBeginDragXY;
     Vector2D                        m_vLastDragXY;
     Vector2D                        m_vBeginDragPositionXY;
     Vector2D                        m_vBeginDragSizeXY;
     int                             m_iGrabbedCorner = 0;
+
+    CWindow*                        m_pLastTiledWindow = nullptr;
 };

src/layout/MasterLayout.cpp

@@ -20,6 +20,16 @@ int CHyprMasterLayout::getNodesOnWorkspace(const int& ws) {
     return no;
 }
 
+int CHyprMasterLayout::getMastersOnWorkspace(const int& ws) {
+    int no = 0;
+    for (auto& n : m_lMasterNodesData) {
+        if (n.workspaceID == ws && n.isMaster)
+            no++;
+    }
+
+    return no;
+}
+
 std::string CHyprMasterLayout::getLayoutName() {
     return "Master";
 }
@@ -101,13 +111,19 @@ void CHyprMasterLayout::onWindowRemovedTiling(CWindow* pWindow) {
     if (!PNODE)
         return;
 
+    pWindow->m_sSpecialRenderData.rounding = true;
+    pWindow->m_sSpecialRenderData.border = true;
+    pWindow->m_sSpecialRenderData.decorate = true;
+
     if (pWindow->m_bIsFullscreen)
         g_pCompositor->setWindowFullscreen(pWindow, false, FULLSCREEN_FULL);
 
-    if (PNODE->isMaster) {
+    const auto MASTERSLEFT = getMastersOnWorkspace(PNODE->workspaceID);
+
+    if (PNODE->isMaster && MASTERSLEFT < 2) {
         // find new one
         for (auto& nd : m_lMasterNodesData) {
-            if (!nd.isMaster) {
+            if (!nd.isMaster && nd.workspaceID == PNODE->workspaceID) {
                 nd.isMaster = true;
                 break;
             }
@@ -116,6 +132,15 @@ void CHyprMasterLayout::onWindowRemovedTiling(CWindow* pWindow) {
 
     m_lMasterNodesData.remove(*PNODE);
 
+    if (getMastersOnWorkspace(PNODE->workspaceID) == getNodesOnWorkspace(PNODE->workspaceID) && MASTERSLEFT > 1) {
+        for (auto it = m_lMasterNodesData.rbegin(); it != m_lMasterNodesData.rend(); it++) {
+            if (it->workspaceID == PNODE->workspaceID) {
+                it->isMaster = false;
+                break;
+            }
+        }
+    }
+
     recalculateMonitor(pWindow->m_iMonitorID);
 }
 
@@ -128,8 +153,8 @@ void CHyprMasterLayout::recalculateMonitor(const int& monid) {
 
     g_pHyprRenderer->damageMonitor(PMONITOR);
 
-    if (PMONITOR->specialWorkspaceOpen) {
-        calculateWorkspace(SPECIAL_WORKSPACE_ID);
+    if (PMONITOR->specialWorkspaceID) {
+        calculateWorkspace(PMONITOR->specialWorkspaceID);
     }
 
     if (PWORKSPACE->m_bHasFullscreenWindow) {
@@ -169,32 +194,52 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
     if (!PMASTERNODE)
         return;
 
+    const auto MASTERS = getMastersOnWorkspace(PWORKSPACE->m_iID);
+
     if (getNodesOnWorkspace(PWORKSPACE->m_iID) < 2) {
         PMASTERNODE->position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition;
         PMASTERNODE->size = Vector2D(PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x, PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y);
         applyNodeDataToWindow(PMASTERNODE);
         return;
     } else {
-        PMASTERNODE->position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition;
-        PMASTERNODE->size = Vector2D((PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x) * PMASTERNODE->percMaster, PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y);
+        float heightLeft = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y;
+        int nodesLeft = MASTERS;
+        float nextY = 0;
+
+        for (auto& n : m_lMasterNodesData) {
+            if (n.workspaceID == PWORKSPACE->m_iID && n.isMaster) {
+                n.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition + Vector2D(0, nextY);
+                float HEIGHT = nodesLeft > 1 ? heightLeft / nodesLeft * n.percSize : heightLeft;
+                if (HEIGHT > heightLeft * 0.9f && nodesLeft > 1)
+                    HEIGHT = heightLeft * 0.9f;
+                n.size = Vector2D((PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x) * PMASTERNODE->percMaster, HEIGHT);
+
+                nodesLeft--;
+                heightLeft -= HEIGHT;
+                nextY += HEIGHT;
+
+                applyNodeDataToWindow(&n);
+            }
+        }
     }
 
-    const auto SLAVESIZE = 1.f / (getNodesOnWorkspace(PWORKSPACE->m_iID) - 1) * (PMASTERNODE->size.y);
-    int slavesDone = 0;
+    float heightLeft = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y;
+    int slavesLeft = getNodesOnWorkspace(PWORKSPACE->m_iID) - MASTERS;
+    float nextY = 0;
 
     for (auto& nd : m_lMasterNodesData) {
-        if (nd.workspaceID != PWORKSPACE->m_iID)
+        if (nd.workspaceID != PWORKSPACE->m_iID || nd.isMaster)
             continue;
 
-        if (nd == *PMASTERNODE) {
-            applyNodeDataToWindow(PMASTERNODE);
-            continue;
-        }
+        nd.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition + Vector2D(PMASTERNODE->percMaster * PMONITOR->vecSize.x, nextY);
+        float HEIGHT = slavesLeft > 1 ? heightLeft / slavesLeft * nd.percSize : heightLeft;
+        if (HEIGHT > heightLeft * 0.9f && slavesLeft > 1)
+            HEIGHT = heightLeft * 0.9f;
+        nd.size = Vector2D(PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x - PMASTERNODE->size.x, HEIGHT);
 
-        nd.position = Vector2D(PMASTERNODE->size.x + PMASTERNODE->position.x, slavesDone * SLAVESIZE + PMASTERNODE->position.y);
-        nd.size = Vector2D(PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x - PMASTERNODE->size.x, SLAVESIZE);
-
-        slavesDone++;
+        slavesLeft--;
+        heightLeft -= HEIGHT;
+        nextY += HEIGHT;
 
         applyNodeDataToWindow(&nd);
     }
@@ -203,9 +248,9 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
 void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
     CMonitor* PMONITOR = nullptr;
 
-    if (pNode->workspaceID == SPECIAL_WORKSPACE_ID) {
+    if (g_pCompositor->isWorkspaceSpecial(pNode->workspaceID)) {
         for (auto& m : g_pCompositor->m_vMonitors) {
-            if (m->specialWorkspaceOpen) {
+            if (m->specialWorkspaceID == pNode->workspaceID) {
                 PMONITOR = m.get();
                 break;
             }
@@ -244,7 +289,7 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
     auto calcPos = PWINDOW->m_vPosition + Vector2D(*PBORDERSIZE, *PBORDERSIZE);
     auto calcSize = PWINDOW->m_vSize - Vector2D(2 * *PBORDERSIZE, 2 * *PBORDERSIZE);
 
-    if (*PNOGAPSWHENONLY && PWINDOW->m_iWorkspaceID != SPECIAL_WORKSPACE_ID && getNodesOnWorkspace(PWINDOW->m_iWorkspaceID) == 1) {
+    if (*PNOGAPSWHENONLY && !g_pCompositor->isWorkspaceSpecial(PWINDOW->m_iWorkspaceID) && (getNodesOnWorkspace(PWINDOW->m_iWorkspaceID) == 1 || (PWINDOW->m_bIsFullscreen && g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_efFullscreenMode == FULLSCREEN_MAXIMIZED))) {
         PWINDOW->m_vRealPosition = calcPos - Vector2D(*PBORDERSIZE, *PBORDERSIZE);
         PWINDOW->m_vRealSize = calcSize + Vector2D(2 * *PBORDERSIZE, 2 * *PBORDERSIZE);
 
@@ -270,7 +315,7 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
     calcPos = calcPos + OFFSETTOPLEFT;
     calcSize = calcSize - OFFSETTOPLEFT - OFFSETBOTTOMRIGHT;
 
-    if (PWINDOW->m_iWorkspaceID == SPECIAL_WORKSPACE_ID) {
+    if (g_pCompositor->isWorkspaceSpecial(PWINDOW->m_iWorkspaceID)) {
         static auto *const PSCALEFACTOR = &g_pConfigManager->getConfigValuePtr("master:special_scale_factor")->floatValue;
 
         PWINDOW->m_vRealPosition = calcPos + (calcSize - calcSize * *PSCALEFACTOR) / 2.f;
@@ -309,13 +354,12 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, CWindow* p
     const auto PNODE = getNodeFromWindow(PWINDOW);
 
     if (!PNODE) {
-      PWINDOW->m_vRealSize = Vector2D(std::max((PWINDOW->m_vRealSize.goalv() + pixResize).x, 20.0), std::max((PWINDOW->m_vRealSize.goalv() + pixResize).y, 20.0));
+        PWINDOW->m_vRealSize = Vector2D(std::max((PWINDOW->m_vRealSize.goalv() + pixResize).x, 20.0), std::max((PWINDOW->m_vRealSize.goalv() + pixResize).y, 20.0));
         PWINDOW->updateWindowDecos();
         return;
     }
 
-    // get master
-    const auto PMASTER = getMasterNodeOnWorkspace(PWINDOW->m_iWorkspaceID);
+    // get monitor
     const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
 
     if (getNodesOnWorkspace(PWINDOW->m_iWorkspaceID) < 2)
@@ -323,11 +367,24 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, CWindow* p
 
     m_bForceWarps = true;
 
-    float delta = pixResize.x / PMONITOR->vecSize.x;
+    double delta = pixResize.x / PMONITOR->vecSize.x;
 
-    PMASTER->percMaster += delta;
+    for (auto& n : m_lMasterNodesData) {
+        if (n.isMaster && n.workspaceID == PMONITOR->activeWorkspace)
+            n.percMaster = std::clamp(n.percMaster + delta, 0.05, 0.95);
+    }
 
-    std::clamp(PMASTER->percMaster, 0.05f, 0.95f);
+    // check the up/down resize
+    if (pixResize.y != 0) {
+        if (PNODE->isMaster && getMastersOnWorkspace(PNODE->workspaceID) > 1) {
+            // check master size
+            const auto SIZEY = (PMONITOR->vecSize.y - PMONITOR->vecReservedTopLeft.y - PMONITOR->vecReservedBottomRight.y) / getMastersOnWorkspace(PNODE->workspaceID);
+            PNODE->percSize = std::clamp(PNODE->percSize + pixResize.y / SIZEY, 0.05, 1.95);
+        } else if (!PNODE->isMaster && (getNodesOnWorkspace(PWINDOW->m_iWorkspaceID) - getMastersOnWorkspace(PNODE->workspaceID)) > 1) {
+            const auto SIZEY = (PMONITOR->vecSize.y - PMONITOR->vecReservedTopLeft.y - PMONITOR->vecReservedBottomRight.y) / getNodesOnWorkspace(PNODE->workspaceID);
+            PNODE->percSize = std::clamp(PNODE->percSize + pixResize.y / SIZEY, 0.05, 1.95);
+        }
+    }
 
     recalculateMonitor(PMONITOR->ID);
 
@@ -338,7 +395,7 @@ void CHyprMasterLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreen
     if (!g_pCompositor->windowValidMapped(pWindow))
         return;
 
-    if (on == pWindow->m_bIsFullscreen || pWindow->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+    if (on == pWindow->m_bIsFullscreen || g_pCompositor->isWorkspaceSpecial(pWindow->m_iWorkspaceID))
         return;  // ignore
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
@@ -445,6 +502,9 @@ void CHyprMasterLayout::switchWindows(CWindow* pWindow, CWindow* pWindow2) {
     recalculateMonitor(pWindow->m_iMonitorID);
     if (PNODE2->workspaceID != PNODE->workspaceID)
         recalculateMonitor(pWindow2->m_iMonitorID);
+
+    g_pHyprRenderer->damageWindow(pWindow);
+    g_pHyprRenderer->damageWindow(pWindow2);
 }
 
 void CHyprMasterLayout::alterSplitRatioBy(CWindow* pWindow, float ratio) {
@@ -537,34 +597,73 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
             return;
 
         g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
-        Vector2D middle = PWINDOWTOCHANGETO->m_vRealPosition.goalv() + PWINDOWTOCHANGETO->m_vRealSize.goalv() / 2.f;
-        wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, middle.x, middle.y);
+        g_pCompositor->warpCursorTo(PWINDOWTOCHANGETO->m_vRealPosition.goalv() + PWINDOWTOCHANGETO->m_vRealSize.goalv() / 2.f);
     };
 
     if (message == "swapwithmaster") {
-
         const auto PWINDOW = header.pWindow;
 
+        if (!PWINDOW)
+            return 0;
+
         if (!isWindowTiled(PWINDOW))
             return 0;
 
         const auto PMASTER = getMasterNodeOnWorkspace(PWINDOW->m_iWorkspaceID);
 
-        if (!PMASTER || PMASTER->pWindow == PWINDOW)
+        if (!PMASTER)
             return 0;
 
-        switchWindows(PWINDOW, PMASTER->pWindow);
+        if (PMASTER->pWindow != PWINDOW) {
+            switchWindows(PWINDOW, PMASTER->pWindow);
+            switchToWindow(PWINDOW);
+        } else {
+            for (auto& n : m_lMasterNodesData) {
+                if (n.workspaceID == PMASTER->workspaceID && !n.isMaster) {
+                    switchWindows(n.pWindow, PMASTER->pWindow);
+                    switchToWindow(n.pWindow);
+                    break;
+                }
+            }
+        }
 
-        switchToWindow(PWINDOW);
+        return 0;
+    } else if (message == "focusmaster") {
+        const auto PWINDOW = header.pWindow;
+
+        if (!PWINDOW)
+            return 0;
+
+        const auto PMASTER = getMasterNodeOnWorkspace(PWINDOW->m_iWorkspaceID);
+
+        if (!PMASTER)
+            return 0;
+
+        if (PMASTER->pWindow != PWINDOW)
+            switchToWindow(PMASTER->pWindow);
+        else {
+            for (auto& n : m_lMasterNodesData) {
+                if (n.workspaceID == PMASTER->workspaceID && !n.isMaster) {
+                    switchToWindow(n.pWindow);
+                    break;
+                }
+            }
+        }
 
         return 0;
     } else if (message == "cyclenext") {
         const auto PWINDOW = header.pWindow;
 
+        if (!PWINDOW)
+            return 0;
+
         switchToWindow(getNextWindow(PWINDOW, true));
     } else if (message == "cycleprev") {
         const auto PWINDOW = header.pWindow;
 
+        if (!PWINDOW)
+            return 0;
+
         switchToWindow(getNextWindow(PWINDOW, false));
     } else if (message == "swapnext") {
         if (!g_pCompositor->windowValidMapped(header.pWindow))
@@ -596,6 +695,64 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
             switchWindows(header.pWindow, PWINDOWTOSWAPWITH);
             g_pCompositor->focusWindow(header.pWindow);
         }
+    } else if (message == "addmaster") {
+        if (!g_pCompositor->windowValidMapped(header.pWindow))
+            return 0;
+
+        if (header.pWindow->m_bIsFloating)
+            return 0;
+
+        const auto PNODE   = getNodeFromWindow(header.pWindow);
+
+        const auto WINDOWS = getNodesOnWorkspace(header.pWindow->m_iWorkspaceID);
+        const auto MASTERS = getMastersOnWorkspace(header.pWindow->m_iWorkspaceID);
+
+        if (MASTERS + 2 > WINDOWS)
+            return 0;
+
+        if (!PNODE || PNODE->isMaster) {
+            // first non-master node
+            for (auto& n : m_lMasterNodesData) {
+                if (n.workspaceID == header.pWindow->m_iWorkspaceID && !n.isMaster) {
+                    n.isMaster = true;
+                    break;
+                }
+            }
+        } else {
+            PNODE->isMaster = true;
+        }
+
+        recalculateMonitor(header.pWindow->m_iMonitorID);
+
+    } else if (message == "removemaster") {
+
+        if (!g_pCompositor->windowValidMapped(header.pWindow))
+            return 0;
+
+        if (header.pWindow->m_bIsFloating)
+            return 0;
+
+        const auto PNODE = getNodeFromWindow(header.pWindow);
+
+        const auto WINDOWS = getNodesOnWorkspace(header.pWindow->m_iWorkspaceID);
+        const auto MASTERS = getMastersOnWorkspace(header.pWindow->m_iWorkspaceID);
+
+        if (WINDOWS < 2 || MASTERS < 2)
+            return 0;
+
+        if (!PNODE || !PNODE->isMaster) {
+            // first non-master node
+            for (auto it = m_lMasterNodesData.rbegin(); it != m_lMasterNodesData.rend(); it++) {
+                if (it->workspaceID == header.pWindow->m_iWorkspaceID && it->isMaster) {
+                    it->isMaster = false;
+                    break;
+                }
+            }
+        } else {
+            PNODE->isMaster = false;
+        }
+
+        recalculateMonitor(header.pWindow->m_iMonitorID);
     }
 
     return 0;
@@ -603,7 +760,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
 
 void CHyprMasterLayout::onEnable() {
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_bIsFloating || !w->m_bMappedX11 || !w->m_bIsMapped || w->m_bHidden)
+        if (w->m_bIsFloating || !w->m_bMappedX11 || !w->m_bIsMapped || w->isHidden())
             continue;
 
         onWindowCreatedTiling(w.get());

src/layout/MasterLayout.hpp

@@ -15,6 +15,8 @@ struct SMasterNodeData {
     Vector2D position;
     Vector2D size;
 
+    float percSize = 1.f; // size multiplier for resizing children
+
     int workspaceID = -1;
 
     bool operator==(const SMasterNodeData& rhs) {
@@ -52,6 +54,7 @@ private:
     SMasterNodeData*    getMasterNodeOnWorkspace(const int&);
     void                calculateWorkspace(const int&);
     CWindow*            getNextWindow(CWindow*, bool);
+    int                 getMastersOnWorkspace(const int&);
 
     friend struct SMasterNodeData;
 };

src/main.cpp

@@ -5,10 +5,6 @@
 #include "init/initHelpers.hpp"
 #include <iostream>
 
-// I am a bad bad boy and have used some global vars here,
-// just for this file
-bool ignoreSudo = false;
-
 int main(int argc, char** argv) {
 
     if (!getenv("XDG_RUNTIME_DIR"))
@@ -19,9 +15,12 @@ int main(int argc, char** argv) {
     for (auto i = 0; i < argc; ++i)
         cmd += std::string(i == 0 ? "" : " ") + argv[i];
     setenv("HYPRLAND_CMD", cmd.c_str(), 1);
+    setenv("XDG_BACKEND", "wayland", 1);
+    setenv("_JAVA_AWT_WM_NONREPARENTING", "1", 0);
 
     // parse some args
     std::string configPath;
+    bool ignoreSudo = false;
     for (int i = 1; i < argc; ++i) {
         if (!strcmp(argv[i], "--i-am-really-stupid"))
             ignoreSudo = true;

src/managers/AnimationManager.cpp

@@ -33,6 +33,8 @@ void CAnimationManager::tick() {
 
     const auto DEFAULTBEZIER = m_mBezierCurves.find("default");
 
+    std::vector<CAnimatedVariable*> animationEndedVars;
+
     for (auto& av : m_lAnimatedVariables) {
 
         // first of all, check if we need to update it at all
@@ -40,16 +42,12 @@ void CAnimationManager::tick() {
             continue;
 
         if (av->m_eDamagePolicy == AVARDAMAGE_SHADOW && !*PSHADOWSENABLED) {
-            av->warp();
+            av->warp(false);
             continue;
         }
 
-        // get speed
-        const auto SPEED = av->m_pConfig->pValues->internalSpeed;
-
         // get the spent % (0 - 1)
-        const auto DURATIONPASSED = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - av->animationBegin).count();
-        const float SPENT = std::clamp((DURATIONPASSED / 100.f) / SPEED, 0.f, 1.f);
+        const float SPENT = av->getPercent();
 
         // window stuff
         const auto PWINDOW = (CWindow*)av->m_pWindow;
@@ -78,12 +76,12 @@ void CAnimationManager::tick() {
             case AVARTYPE_FLOAT: {
                 // for disabled anims just warp
                 if (av->m_pConfig->pValues->internalEnabled == 0 || animationsDisabled) {
-                    av->warp();
+                    av->warp(false);
                     break;
                 }
 
                 if (SPENT >= 1.f) {
-                    av->warp();
+                    av->warp(false);
                     break;
                 }
 
@@ -99,12 +97,12 @@ void CAnimationManager::tick() {
             case AVARTYPE_VECTOR: {
                 // for disabled anims just warp
                 if (av->m_pConfig->pValues->internalEnabled == 0 || animationsDisabled) {
-                    av->warp();
+                    av->warp(false);
                     break;
                 }
 
                 if (SPENT >= 1.f) {
-                    av->warp();
+                    av->warp(false);
                     break;
                 }
 
@@ -120,12 +118,12 @@ void CAnimationManager::tick() {
             case AVARTYPE_COLOR: {
                 // for disabled anims just warp
                 if (av->m_pConfig->pValues->internalEnabled == 0 || animationsDisabled) {
-                    av->warp();
+                    av->warp(false);
                     break;
                 }
 
                 if (SPENT >= 1.f) {
-                    av->warp();
+                    av->warp(false);
                     break;
                 }
 
@@ -153,7 +151,7 @@ void CAnimationManager::tick() {
                     g_pHyprRenderer->damageWindow(PWINDOW);
                 } else if (PWORKSPACE) {
                     for (auto& w : g_pCompositor->m_vWindows) {
-                        if (!w->m_bIsMapped || w->m_bHidden)
+                        if (!w->m_bIsMapped || w->isHidden())
                             continue;
 
                         if (w->m_iWorkspaceID != PWORKSPACE->m_iID)
@@ -166,8 +164,7 @@ void CAnimationManager::tick() {
                         g_pHyprOpenGL->markBlurDirtyForMonitor(PMONITOR);
                 }
                 break;
-            }
-            case AVARDAMAGE_BORDER: {
+            } case AVARDAMAGE_BORDER: {
                 RASSERT(PWINDOW, "Tried to AVARDAMAGE_BORDER a non-window AVAR!");
 
                 // damage only the border.
@@ -225,13 +222,21 @@ void CAnimationManager::tick() {
             }
         }
 
-
         // set size and pos if valid, but only if damage policy entire (dont if border for example)
         if (g_pCompositor->windowValidMapped(PWINDOW) && av->m_eDamagePolicy == AVARDAMAGE_ENTIRE && PWINDOW->m_iX11Type != 2)
             g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
 
         // manually schedule a frame
         g_pCompositor->scheduleFrameForMonitor(PMONITOR);
+
+        // check if we did not finish animating. If so, trigger onAnimationEnd.
+        if (!av->isBeingAnimated())
+            animationEndedVars.push_back(av);
+    }
+
+    // do it here, because if this alters the animation vars deque we would be in trouble above.
+    for (auto& ave : animationEndedVars) {
+        ave->onAnimationEnd();
     }
 }
 
@@ -287,7 +292,7 @@ void CAnimationManager::animationPopin(CWindow* pWindow, bool close, float minPe
 }
 
 void CAnimationManager::animationSlide(CWindow* pWindow, std::string force, bool close) {
-    pWindow->m_vRealSize.warp();  // size we preserve in slide
+    pWindow->m_vRealSize.warp(false);  // size we preserve in slide
 
     const auto GOALPOS = pWindow->m_vRealPosition.goalv();
     const auto GOALSIZE = pWindow->m_vRealSize.goalv();
@@ -361,6 +366,10 @@ void CAnimationManager::onWindowPostCreateClose(CWindow* pWindow, bool close) {
     if (!pWindow->m_vRealPosition.isBeingAnimated() && !pWindow->m_vRealSize.isBeingAnimated())
         return;
 
+    // if the animation is disabled and we are leaving, ignore the anim to prevent the snapshot being fucked
+    if (!pWindow->m_vRealPosition.m_pConfig->pValues->internalEnabled)
+        return;
+
     if (pWindow->m_sAdditionalConfigData.animationStyle != "") {
         // the window has config'd special anim
         if (pWindow->m_sAdditionalConfigData.animationStyle.find("slide") == 0) {

src/managers/EventManager.cpp

@@ -18,6 +18,23 @@
 CEventManager::CEventManager() {
 }
 
+int fdHandleWrite(int fd, uint32_t mask, void* data) {
+    if (mask & WL_EVENT_ERROR || mask & WL_EVENT_HANGUP) {
+        // remove, hanged up
+        const auto ACCEPTEDFDS = (std::deque<std::pair<int, wl_event_source*>>*)data;
+        for (auto it = ACCEPTEDFDS->begin(); it != ACCEPTEDFDS->end(); ) {
+            if (it->first == fd) {
+                wl_event_source_remove(it->second); // remove this fd listener
+                it = ACCEPTEDFDS->erase(it);
+            } else {
+                it++;
+            }
+        }
+    }
+
+    return 0;
+}
+
 void CEventManager::startThread() {
     m_tThread = std::thread([&]() {
         const auto SOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
@@ -46,15 +63,15 @@ void CEventManager::startThread() {
 
             if (ACCEPTEDCONNECTION > 0) {
                 // new connection!
-                m_dAcceptedSocketFDs.push_back(ACCEPTEDCONNECTION);
 
                 int flagsNew = fcntl(ACCEPTEDCONNECTION, F_GETFL, 0);
                 fcntl(ACCEPTEDCONNECTION, F_SETFL, flagsNew | O_NONBLOCK);
 
                 Debug::log(LOG, "Socket 2 accepted a new client at FD %d", ACCEPTEDCONNECTION);
-            }
 
-            ensureFDsValid();
+                // add to event loop so we can close it when we need to
+                m_dAcceptedSocketFDs.push_back({ACCEPTEDCONNECTION, wl_event_loop_add_fd(g_pCompositor->m_sWLEventLoop, ACCEPTEDCONNECTION, WL_EVENT_READABLE, fdHandleWrite, &m_dAcceptedSocketFDs)});
+            }
         }
 
         close(SOCKET);
@@ -63,34 +80,13 @@ void CEventManager::startThread() {
     m_tThread.detach();
 }
 
-void CEventManager::ensureFDsValid() {
-    static char readBuf[1024] = {0};
-
-    // pong if all FDs valid
-    for (auto it = m_dAcceptedSocketFDs.begin(); it != m_dAcceptedSocketFDs.end();) {
-        auto sizeRead = recv(*it, &readBuf, 1024, 0);
-
-        if (sizeRead != 0) {
-            it++;
-            continue;
-        }
-
-        // invalid!
-        Debug::log(LOG, "Removed invalid socket (2) FD: %d", *it);
-        it = m_dAcceptedSocketFDs.erase(it);
-    }
-}
-
 void CEventManager::flushEvents() {
-
-    ensureFDsValid();
-    
     eventQueueMutex.lock();
 
     for (auto& ev : m_dQueuedEvents) {
         std::string eventString = (ev.event + ">>" + ev.data).substr(0, 1022) + "\n";
         for (auto& fd : m_dAcceptedSocketFDs) {
-            write(fd, eventString.c_str(), eventString.length());
+            write(fd.first, eventString.c_str(), eventString.length());
         }
     }
 

src/managers/EventManager.hpp

@@ -26,12 +26,11 @@ public:
 private:
 
     void flushEvents();
-    void ensureFDsValid();
 
     std::mutex eventQueueMutex;
     std::deque<SHyprIPCEvent> m_dQueuedEvents;
 
-    std::deque<int> m_dAcceptedSocketFDs;
+    std::deque<std::pair<int, wl_event_source*>> m_dAcceptedSocketFDs;
 };
 
 inline std::unique_ptr<CEventManager> g_pEventManager;

src/managers/KeybindManager.cpp

@@ -16,6 +16,7 @@ CKeybindManager::CKeybindManager() {
     m_mDispatchers["pseudo"]                    = toggleActivePseudo;
     m_mDispatchers["movefocus"]                 = moveFocusTo;
     m_mDispatchers["movewindow"]                = moveActiveTo;
+    m_mDispatchers["centerwindow"]              = centerWindow;
     m_mDispatchers["togglegroup"]               = toggleGroup;
     m_mDispatchers["changegroupactive"]         = changeGroupActive;
     m_mDispatchers["togglesplit"]               = toggleSplit;
@@ -44,6 +45,7 @@ CKeybindManager::CKeybindManager() {
     m_mDispatchers["swapactiveworkspaces"]      = swapActiveWorkspaces;
     m_mDispatchers["pin"]                       = pinActive;
     m_mDispatchers["mouse"]                     = mouse;
+    m_mDispatchers["bringactivetotop"]          = bringActiveToTop;
 
     m_tScrollTimer.reset();
 }
@@ -163,7 +165,7 @@ bool CKeybindManager::onKeyEvent(wlr_keyboard_key_event* e, SKeyboard* pKeyboard
         return true;
     }
 
-    if (pKeyboard->isVirtual)
+    if (pKeyboard->isVirtual && g_pInputManager->shouldIgnoreVirtualKeyboard(pKeyboard))
         return true;
 
     if (!m_pXKBTranslationState) {
@@ -481,6 +483,17 @@ bool CKeybindManager::handleInternalKeybinds(xkb_keysym_t keysym) {
 // Dispatchers
 
 void CKeybindManager::spawn(std::string args) {
+
+    args = removeBeginEndSpacesTabs(args);
+
+    std::string RULES = "";
+
+    if (args[0] == '[') {
+        // we have exec rules
+        RULES = args.substr(1, args.substr(1).find_first_of(']'));
+        args = args.substr(args.find_first_of(']') + 1);
+    }
+
     if (g_pXWaylandManager->m_sWLRXWayland)
         args = "WAYLAND_DISPLAY=" + std::string(g_pCompositor->m_szWLDisplaySocket) + " DISPLAY=" + std::string(g_pXWaylandManager->m_sWLRXWayland->display_name) + " " + args;
     else
@@ -533,7 +546,18 @@ void CKeybindManager::spawn(std::string args) {
         Debug::log(LOG, "Fail to create the second fork");
         return;
     }
+
     Debug::log(LOG, "Process Created with pid %d", grandchild);
+
+    if (!RULES.empty()) {
+        const auto RULESLIST = CVarList(RULES, 0, ';');
+
+        for (auto& r : RULESLIST) {
+            g_pConfigManager->addExecRule({r, (unsigned long)grandchild});
+        }
+
+        Debug::log(LOG, "Applied %i rule arguments for exec.", RULESLIST.size());
+    }
 }
 
 void CKeybindManager::killActive(std::string args) {
@@ -567,23 +591,35 @@ void CKeybindManager::toggleActiveFloating(std::string args) {
     if (!PWINDOW)
         return;
 
-    if (g_pCompositor->windowValidMapped(PWINDOW)) {
-        // remove drag status
-        g_pInputManager->currentlyDraggedWindow = nullptr;
+    // remove drag status
+    g_pInputManager->currentlyDraggedWindow = nullptr;
 
-        if (PWINDOW->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
-            return;
+    if (g_pCompositor->isWorkspaceSpecial(PWINDOW->m_iWorkspaceID))
+        return;
 
-        PWINDOW->m_bIsFloating = !PWINDOW->m_bIsFloating;
+    PWINDOW->m_bIsFloating = !PWINDOW->m_bIsFloating;
 
-        g_pLayoutManager->getCurrentLayout()->changeWindowFloatingMode(PWINDOW);
-    }
+    PWINDOW->updateDynamicRules();
+
+    g_pLayoutManager->getCurrentLayout()->changeWindowFloatingMode(PWINDOW);
+}
+
+void CKeybindManager::centerWindow(std::string args) {
+    const auto PWINDOW = g_pCompositor->m_pLastWindow;
+
+    if (!PWINDOW || !PWINDOW->m_bIsFloating || PWINDOW->m_bIsFullscreen)
+        return;
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+
+    PWINDOW->m_vRealPosition = PMONITOR->vecPosition + PMONITOR->vecSize / 2.f - PWINDOW->m_vRealSize.goalv() / 2.f;
+    PWINDOW->m_vPosition = PWINDOW->m_vRealPosition.goalv();
 }
 
 void CKeybindManager::toggleActivePseudo(std::string args) {
     const auto ACTIVEWINDOW = g_pCompositor->m_pLastWindow;
 
-    if (!g_pCompositor->windowValidMapped(ACTIVEWINDOW))
+    if (!ACTIVEWINDOW)
         return;
 
     ACTIVEWINDOW->m_bIsPseudotiled = !ACTIVEWINDOW->m_bIsPseudotiled;
@@ -610,16 +646,20 @@ void CKeybindManager::changeworkspace(std::string args) {
 
         internal = true;
     } else if (args.find("previous") == 0) {
-        const auto PCURRENTWORKSPACE = g_pCompositor->getWorkspaceByID(
-            g_pCompositor->m_pLastMonitor->activeWorkspace);
+        const auto PCURRENTWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
 
         // Do nothing if there's no previous workspace, otherwise switch to it.
         if (PCURRENTWORKSPACE->m_iPrevWorkspaceID == -1) {
             Debug::log(LOG, "No previous workspace to change to");
             return;
-        }
-        else {
+        } else {
             workspaceToChangeTo = PCURRENTWORKSPACE->m_iPrevWorkspaceID;
+
+            if (const auto PWORKSPACETOCHANGETO = g_pCompositor->getWorkspaceByID(workspaceToChangeTo); PWORKSPACETOCHANGETO)
+                workspaceName = PWORKSPACETOCHANGETO->m_szName;
+            else
+                workspaceName = std::to_string(workspaceToChangeTo);
+
             isSwitchingToPrevious = true;
 
             // If the previous workspace ID isn't reset, cycles can form when continually going
@@ -642,12 +682,12 @@ void CKeybindManager::changeworkspace(std::string args) {
     const auto PCURRENTWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
     static auto *const PBACKANDFORTH = &g_pConfigManager->getConfigValuePtr("binds:workspace_back_and_forth")->intValue;
 
-    if (*PBACKANDFORTH && PCURRENTWORKSPACE->m_iID == workspaceToChangeTo && PCURRENTWORKSPACE->m_iPrevWorkspaceID != -1 && !internal) {
+    if (*PBACKANDFORTH && PCURRENTWORKSPACE && PCURRENTWORKSPACE->m_iID == workspaceToChangeTo && PCURRENTWORKSPACE->m_iPrevWorkspaceID != -1 && !internal) {
 
         const auto PPREVWORKSPACE = g_pCompositor->getWorkspaceByID(PCURRENTWORKSPACE->m_iPrevWorkspaceID);
 
         workspaceToChangeTo = PCURRENTWORKSPACE->m_iPrevWorkspaceID;
-        
+
         if (PPREVWORKSPACE)
             workspaceName = PPREVWORKSPACE->m_szName;
         else
@@ -661,12 +701,14 @@ void CKeybindManager::changeworkspace(std::string args) {
         if (!*PALLOWWORKSPACECYCLES)
             PCURRENTWORKSPACE->m_iPrevWorkspaceID = -1;
 
-    } else if (PCURRENTWORKSPACE->m_iID == workspaceToChangeTo && !internal)
+    } else if (PCURRENTWORKSPACE && PCURRENTWORKSPACE->m_iID == workspaceToChangeTo && !internal)
         return;
 
     // remove constraints
     g_pInputManager->unconstrainMouse();
 
+    g_pInputManager->m_bEmptyFocusCursorSet = false;
+
     // if it's not internal, we will unfocus to prevent stuck focus
     if (!internal)
         g_pCompositor->focusWindow(nullptr);
@@ -681,7 +723,7 @@ void CKeybindManager::changeworkspace(std::string args) {
             // Remember previous workspace.
             PWORKSPACETOCHANGETO->m_iPrevWorkspaceID = g_pCompositor->m_pLastMonitor->activeWorkspace;
 
-        if (workspaceToChangeTo == SPECIAL_WORKSPACE_ID)
+        if (g_pCompositor->isWorkspaceSpecial(workspaceToChangeTo))
             PWORKSPACETOCHANGETO->m_iMonitorID = PMONITOR->ID;
 
         // if it's not visible, make it visible.
@@ -696,10 +738,10 @@ void CKeybindManager::changeworkspace(std::string args) {
             }
 
             // change it
-            if (workspaceToChangeTo != SPECIAL_WORKSPACE_ID)
+            if (!g_pCompositor->isWorkspaceSpecial(workspaceToChangeTo))
                 PMONITOR->activeWorkspace = workspaceToChangeTo;
             else
-                PMONITOR->specialWorkspaceOpen = true;
+                PMONITOR->specialWorkspaceID = workspaceToChangeTo;
 
             // here and only here begin anim. we don't want to anim visible workspaces on other monitors.
             // check if anim left or right
@@ -715,11 +757,9 @@ void CKeybindManager::changeworkspace(std::string args) {
         }
 
         // If the monitor is not the one our cursor's at, warp to it.
-        const bool anotherMonitor = PMONITOR != g_pCompositor->getMonitorFromCursor();
-        if (anotherMonitor) {
-            Vector2D middle = PMONITOR->vecPosition + PMONITOR->vecSize / 2.f;
-            g_pCompositor->warpCursorTo(middle);
-        }
+        const bool anotherMonitor = PMONITOR != g_pCompositor->m_pLastMonitor;
+        if (anotherMonitor)
+            g_pCompositor->warpCursorTo(PMONITOR->vecPosition + PMONITOR->vecSize / 2.f);
 
         // set active and deactivate all other in wlr
         g_pCompositor->deactivateAllWLRWorkspaces(PWORKSPACETOCHANGETO->m_pWlrHandle);
@@ -744,7 +784,7 @@ void CKeybindManager::changeworkspace(std::string args) {
             g_pInputManager->refocus();
 
         // set the new monitor as the last (no warps would bug otherwise)
-        g_pCompositor->m_pLastMonitor = g_pCompositor->getMonitorFromID(PWORKSPACETOCHANGETO->m_iMonitorID);
+        g_pCompositor->setActiveMonitor(g_pCompositor->getMonitorFromID(PWORKSPACETOCHANGETO->m_iMonitorID));
 
         // mark the monitor dirty
         g_pHyprRenderer->damageMonitor(PMONITOR);
@@ -766,7 +806,9 @@ void CKeybindManager::changeworkspace(std::string args) {
     if (const auto POLDWORKSPACE = g_pCompositor->getWorkspaceByID(OLDWORKSPACE); POLDWORKSPACE)
         POLDWORKSPACE->startAnim(false, ANIMTOLEFT);
 
-    const auto PWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(std::make_unique<CWorkspace>(PMONITOR->ID, workspaceName, workspaceToChangeTo == SPECIAL_WORKSPACE_ID)).get();
+    const auto PWORKSPACE = g_pCompositor->createNewWorkspace(workspaceToChangeTo, PMONITOR->ID, workspaceName);
+
+    const bool ANOTHERMONITOR = PMONITOR != g_pCompositor->m_pLastMonitor;
 
     if (!isSwitchingToPrevious)
         // Remember previous workspace.
@@ -775,14 +817,7 @@ void CKeybindManager::changeworkspace(std::string args) {
     // start anim on new workspace
     PWORKSPACE->startAnim(true, ANIMTOLEFT);
 
-    // We are required to set the name here immediately
-    if (workspaceToChangeTo != SPECIAL_WORKSPACE_ID)
-        wlr_ext_workspace_handle_v1_set_name(PWORKSPACE->m_pWlrHandle, workspaceName.c_str());
-
-    PWORKSPACE->m_iID = workspaceToChangeTo;
-    PWORKSPACE->m_iMonitorID = PMONITOR->ID;
-
-    PMONITOR->specialWorkspaceOpen = false;
+    PMONITOR->specialWorkspaceID = 0;
 
     // fix pinned windows
     for (auto& w : g_pCompositor->m_vWindows) {
@@ -791,10 +826,10 @@ void CKeybindManager::changeworkspace(std::string args) {
         }
     }
 
-    if (workspaceToChangeTo != SPECIAL_WORKSPACE_ID)
+    if (!g_pCompositor->isWorkspaceSpecial(workspaceToChangeTo))
         PMONITOR->activeWorkspace = workspaceToChangeTo;
     else
-        PMONITOR->specialWorkspaceOpen = true;
+        PMONITOR->specialWorkspaceID = workspaceToChangeTo;
 
     // set active and deactivate all other
     g_pCompositor->deactivateAllWLRWorkspaces(PWORKSPACE->m_pWlrHandle);
@@ -807,13 +842,16 @@ void CKeybindManager::changeworkspace(std::string args) {
     if (g_pCompositor->m_pLastMonitor != PMONITOR)
         g_pCompositor->warpCursorTo(PMONITOR->vecPosition + PMONITOR->vecSize / 2.f);
 
-    g_pCompositor->m_pLastMonitor = PMONITOR;
+    g_pEventManager->postEvent(SHyprIPCEvent{"workspace", PWORKSPACE->m_szName});
+
+    g_pCompositor->setActiveMonitor(PMONITOR);
 
     // focus (clears the last)
     g_pInputManager->refocus();
 
-    // Event
-    g_pEventManager->postEvent(SHyprIPCEvent{"workspace", PWORKSPACE->m_szName});
+    // Events
+    if (ANOTHERMONITOR)
+        g_pCompositor->warpCursorTo(PMONITOR->vecPosition + PMONITOR->vecSize / 2.f);
 
     Debug::log(LOG, "Changed to workspace %i", workspaceToChangeTo);
 }
@@ -821,10 +859,10 @@ void CKeybindManager::changeworkspace(std::string args) {
 void CKeybindManager::fullscreenActive(std::string args) {
     const auto PWINDOW = g_pCompositor->m_pLastWindow;
 
-    if (!g_pCompositor->windowValidMapped(PWINDOW))
+    if (!PWINDOW)
         return;
 
-    if (PWINDOW->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+    if (g_pCompositor->isWorkspaceSpecial(PWINDOW->m_iWorkspaceID))
         return;
 
     g_pCompositor->setWindowFullscreen(PWINDOW, !PWINDOW->m_bIsFullscreen, args == "1" ? FULLSCREEN_MAXIMIZED : FULLSCREEN_FULL);
@@ -841,14 +879,14 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
         PWINDOW = g_pCompositor->m_pLastWindow;
     }
 
-    if (!g_pCompositor->windowValidMapped(PWINDOW))
+    if (!PWINDOW)
         return;
 
     const auto OLDWORKSPACE = g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID);
 
     // hack
-    std::string unusedName;
-    const auto WORKSPACEID = getWorkspaceIDFromString(args, unusedName);
+    std::string workspaceName;
+    const auto WORKSPACEID = getWorkspaceIDFromString(args, workspaceName);
 
     if (WORKSPACEID == PWINDOW->m_iWorkspaceID) {
         Debug::log(LOG, "Not moving to workspace because it didn't change.");
@@ -857,6 +895,7 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
 
     auto PSAVEDSIZE = PWINDOW->m_vRealSize.goalv();
     auto PSAVEDPOS = PWINDOW->m_vRealPosition.goalv();
+    const bool WASFULLSCREEN = PWINDOW->m_bIsFullscreen;
 
     g_pLayoutManager->getCurrentLayout()->onWindowRemoved(PWINDOW);
 
@@ -874,15 +913,9 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
         return;
     }
 
-    OLDWORKSPACE->m_bHasFullscreenWindow = false;
-
     PWINDOW->moveToWorkspace(PWORKSPACE->m_iID);
     PWINDOW->m_iMonitorID = PWORKSPACE->m_iMonitorID;
 
-    if (PWINDOW->m_bIsFullscreen) {
-        g_pCompositor->setWindowFullscreen(PWINDOW, false, FULLSCREEN_FULL);
-    }
-
     if (PWORKSPACE->m_bHasFullscreenWindow) {
         g_pCompositor->setWindowFullscreen(g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID), false, FULLSCREEN_FULL);
     }
@@ -894,20 +927,24 @@ void CKeybindManager::moveActiveToWorkspace(std::string args) {
 
     // and restore it
     if (PWINDOW->m_bIsFloating) {
-        PWINDOW->m_vRealSize.setValue(PSAVEDSIZE);
+        PWINDOW->m_vRealSize.setValueAndWarp(PSAVEDSIZE);
         PWINDOW->m_vRealPosition.setValueAndWarp(PSAVEDPOS - g_pCompositor->getMonitorFromID(OLDWORKSPACE->m_iMonitorID)->vecPosition + g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID)->vecPosition);
         PWINDOW->m_vPosition = PWINDOW->m_vRealPosition.vec();
     }
 
+    if (WASFULLSCREEN) {
+        g_pCompositor->setWindowFullscreen(PWINDOW, true, OLDWORKSPACE->m_efFullscreenMode);
+    }
+
     // undo the damage if we are moving to the special workspace
-    if (WORKSPACEID == SPECIAL_WORKSPACE_ID) {
+    if (g_pCompositor->isWorkspaceSpecial(WORKSPACEID)) {
         changeworkspace("[internal]" + std::to_string(OLDWORKSPACE->m_iID));
         OLDWORKSPACE->startAnim(true, true, true);
-        toggleSpecialWorkspace("");
-        g_pCompositor->getWorkspaceByID(SPECIAL_WORKSPACE_ID)->startAnim(false, false, true);
+        toggleSpecialWorkspace(workspaceName.length() > 7 ? workspaceName.substr(8) : workspaceName /* remove special: */);
+        g_pCompositor->getWorkspaceByID(WORKSPACEID)->startAnim(false, false, true);
 
         for (auto& m : g_pCompositor->m_vMonitors)
-            m->specialWorkspaceOpen = false;
+            m->specialWorkspaceID = 0;
     } else {
         g_pCompositor->focusWindow(PWINDOW);
     }
@@ -929,7 +966,7 @@ void CKeybindManager::moveActiveToWorkspaceSilent(std::string args) {
         PWINDOW = g_pCompositor->m_pLastWindow;
     }
 
-    if (!g_pCompositor->windowValidMapped(PWINDOW))
+    if (!PWINDOW)
         return;
 
     int workspaceToMoveTo = 0;
@@ -1027,24 +1064,12 @@ void CKeybindManager::moveFocusTo(std::string args) {
             if (PLASTWINDOW->m_iMonitorID != PWINDOWTOCHANGETO->m_iMonitorID) {
                 // event
                 const auto PNEWMON = g_pCompositor->getMonitorFromID(PWINDOWTOCHANGETO->m_iMonitorID);
-                const auto PNEWWS = g_pCompositor->getWorkspaceByID(PNEWMON->activeWorkspace);
-                g_pEventManager->postEvent(SHyprIPCEvent{"focusedmon", PNEWMON->szName + "," + PNEWWS->m_szName});
 
-                g_pCompositor->m_pLastMonitor = PNEWMON;
+                g_pCompositor->setActiveMonitor(PNEWMON);
             }
         }
     };
 
-    if (!g_pCompositor->windowValidMapped(PLASTWINDOW)) {
-        const auto PWINDOWTOCHANGETO = g_pCompositor->getFirstWindowOnWorkspace(g_pCompositor->m_pLastMonitor->activeWorkspace);
-        if (!PWINDOWTOCHANGETO)
-            return;
-
-        switchToWindow(PWINDOWTOCHANGETO);
-
-        return;
-    }
-
     const auto PWINDOWTOCHANGETO = g_pCompositor->getWindowInDirection(PLASTWINDOW, arg);
 
     if (PWINDOWTOCHANGETO) {
@@ -1089,12 +1114,12 @@ void CKeybindManager::moveActiveTo(std::string args) {
 
     const auto PLASTWINDOW = g_pCompositor->m_pLastWindow;
 
-    if (!g_pCompositor->windowValidMapped(PLASTWINDOW) || PLASTWINDOW->m_bIsFullscreen)
+    if (!PLASTWINDOW || PLASTWINDOW->m_bIsFullscreen)
         return;
 
     const auto PWINDOWTOCHANGETO = g_pCompositor->getWindowInDirection(PLASTWINDOW, arg);
 
-    if (!g_pCompositor->windowValidMapped(PWINDOWTOCHANGETO))
+    if (!PWINDOWTOCHANGETO)
         return;
 
     g_pLayoutManager->getCurrentLayout()->switchWindows(PLASTWINDOW, PWINDOWTOCHANGETO);
@@ -1140,7 +1165,7 @@ void CKeybindManager::alterSplitRatio(std::string args) {
 
     const auto PLASTWINDOW = g_pCompositor->m_pLastWindow;
 
-    if (!g_pCompositor->windowValidMapped(PLASTWINDOW))
+    if (!PLASTWINDOW)
         return;
 
     g_pLayoutManager->getCurrentLayout()->alterSplitRatioBy(PLASTWINDOW, splitratio);
@@ -1149,7 +1174,7 @@ void CKeybindManager::alterSplitRatio(std::string args) {
 void CKeybindManager::focusMonitor(std::string arg) {
     const auto PMONITOR = g_pCompositor->getMonitorFromString(arg);
 
-    if (!PMONITOR)
+    if (!PMONITOR || PMONITOR == g_pCompositor->m_pLastMonitor)
         return;
 
     changeworkspace("[internal]" + std::to_string(PMONITOR->activeWorkspace));
@@ -1170,7 +1195,7 @@ void CKeybindManager::moveCursorToCorner(std::string arg) {
 
     const auto PWINDOW = g_pCompositor->m_pLastWindow;
 
-    if (!g_pCompositor->windowValidMapped(PWINDOW))
+    if (!PWINDOW)
         return;
 
     switch (CORNER) {
@@ -1302,48 +1327,85 @@ void CKeybindManager::moveWorkspaceToMonitor(std::string args) {
 
 void CKeybindManager::toggleSpecialWorkspace(std::string args) {
 
-    if (g_pCompositor->getWindowsOnWorkspace(SPECIAL_WORKSPACE_ID) == 0) {
+    std::string workspaceName = "";
+    int workspaceID = getWorkspaceIDFromString("special:" + args, workspaceName);
+
+    if (workspaceID == INT_MAX || !g_pCompositor->isWorkspaceSpecial(workspaceID)) {
+        Debug::log(ERR, "Invalid workspace passed to special");
+        return;
+    }
+
+    if (g_pCompositor->getWindowsOnWorkspace(workspaceID) == 0) {
         Debug::log(LOG, "Can't open empty special workspace!");
         return;
     }
 
-    bool open = false;
+    bool requestedWorkspaceIsAlreadyOpen = false;
+    int specialOpenOnMonitor = g_pCompositor->m_pLastMonitor->specialWorkspaceID;
 
     for (auto& m : g_pCompositor->m_vMonitors) {
-        if (m->specialWorkspaceOpen) {
-            open = true;
+        if (m->specialWorkspaceID == workspaceID) {
+            requestedWorkspaceIsAlreadyOpen = true;
             break;
         }
     }
 
-    if (open)
-        Debug::log(LOG, "Toggling special workspace to closed");
+    if (requestedWorkspaceIsAlreadyOpen && specialOpenOnMonitor == workspaceID)
+        Debug::log(LOG, "Toggling special workspace %d to closed");
     else
-        Debug::log(LOG, "Toggling special workspace to open");
+        Debug::log(LOG, "Toggling special workspace %d to open");
 
-    if (open) {
-        for (auto& m : g_pCompositor->m_vMonitors) {
-            if (m->specialWorkspaceOpen != !open) {
-                m->specialWorkspaceOpen = !open;
-                g_pLayoutManager->getCurrentLayout()->recalculateMonitor(m->ID);
+    if (requestedWorkspaceIsAlreadyOpen && specialOpenOnMonitor == workspaceID) {
+        // already open on this monitor
 
-                g_pCompositor->getWorkspaceByID(SPECIAL_WORKSPACE_ID)->startAnim(false, false);
-            }
-        }
+        g_pCompositor->m_pLastMonitor->specialWorkspaceID = 0;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_pLastMonitor->ID);
+
+        g_pCompositor->getWorkspaceByID(workspaceID)->startAnim(false, false);
 
         if (const auto PWINDOW = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace)->getLastFocusedWindow(); PWINDOW)
             g_pCompositor->focusWindow(PWINDOW);
         else
             g_pInputManager->refocus();
+    } else if (requestedWorkspaceIsAlreadyOpen) {
+        // already open on another monitor
+
+        if (specialOpenOnMonitor) {
+            g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->specialWorkspaceID)->startAnim(false, false);
+            g_pCompositor->m_pLastMonitor->specialWorkspaceID = 0;
+            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_pLastMonitor->ID);
+        }
+
+        // move to current
+        const auto PSPECIALWORKSPACE = g_pCompositor->getWorkspaceByID(workspaceID);
+        const auto POLDMON = g_pCompositor->getMonitorFromID(PSPECIALWORKSPACE->m_iMonitorID);
+
+        POLDMON->specialWorkspaceID = 0;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(POLDMON->ID);
+        g_pCompositor->m_pLastMonitor->specialWorkspaceID = workspaceID;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_pLastMonitor->ID);
+
+        if (const auto PWINDOW = PSPECIALWORKSPACE->getLastFocusedWindow(); PWINDOW)
+            g_pCompositor->focusWindow(PWINDOW);
+        else
+            g_pInputManager->refocus();
     } else {
-        auto PSPECIALWORKSPACE = g_pCompositor->getWorkspaceByID(SPECIAL_WORKSPACE_ID);
+        // not open anywhere
+
+        if (specialOpenOnMonitor) {
+            g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->specialWorkspaceID)->startAnim(false, false);
+            g_pCompositor->m_pLastMonitor->specialWorkspaceID = 0;
+            g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_pLastMonitor->ID);
+        }
+
+        auto PSPECIALWORKSPACE = g_pCompositor->getWorkspaceByID(workspaceID);
 
         if (!PSPECIALWORKSPACE) {
             // ??? happens sometimes...?
-            PSPECIALWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(std::make_unique<CWorkspace>(g_pCompositor->m_pLastMonitor->ID, "special", true)).get();
+            PSPECIALWORKSPACE = g_pCompositor->createNewWorkspace(workspaceID, g_pCompositor->m_pLastMonitor->ID, workspaceName);
         }
 
-        g_pCompositor->m_pLastMonitor->specialWorkspaceOpen = true;
+        g_pCompositor->m_pLastMonitor->specialWorkspaceID = workspaceID;
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(g_pCompositor->m_pLastMonitor->ID);
 
         PSPECIALWORKSPACE->startAnim(true, true);
@@ -1372,7 +1434,7 @@ void CKeybindManager::forceRendererReload(std::string args) {
 }
 
 void CKeybindManager::resizeActive(std::string args) {
-    if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow) || g_pCompositor->m_pLastWindow->m_bIsFullscreen)
+    if (!g_pCompositor->m_pLastWindow || g_pCompositor->m_pLastWindow->m_bIsFullscreen)
         return;
 
     const auto SIZ = g_pCompositor->parseWindowVectorArgsRelative(args, g_pCompositor->m_pLastWindow->m_vRealSize.goalv());
@@ -1380,11 +1442,11 @@ void CKeybindManager::resizeActive(std::string args) {
     g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(SIZ - g_pCompositor->m_pLastWindow->m_vRealSize.goalv());
 
     if (g_pCompositor->m_pLastWindow->m_vRealSize.goalv().x > 1 && g_pCompositor->m_pLastWindow->m_vRealSize.goalv().y > 1)
-        g_pCompositor->m_pLastWindow->m_bHidden = false;
+        g_pCompositor->m_pLastWindow->setHidden(false);
 }
 
 void CKeybindManager::moveActive(std::string args) {
-	if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow) || g_pCompositor->m_pLastWindow->m_bIsFullscreen)
+	if (!g_pCompositor->m_pLastWindow || g_pCompositor->m_pLastWindow->m_bIsFullscreen)
 		return;
 
     const auto POS = g_pCompositor->parseWindowVectorArgsRelative(args, g_pCompositor->m_pLastWindow->m_vRealPosition.goalv());
@@ -1432,18 +1494,15 @@ void CKeybindManager::resizeWindow(std::string args) {
     g_pLayoutManager->getCurrentLayout()->resizeActiveWindow(SIZ - PWINDOW->m_vRealSize.goalv(), PWINDOW);
 
     if (PWINDOW->m_vRealSize.goalv().x > 1 && PWINDOW->m_vRealSize.goalv().y > 1)
-        PWINDOW->m_bHidden = false;
+        PWINDOW->setHidden(false);
 }
 
 void CKeybindManager::circleNext(std::string arg) {
-    if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow))
-        return;
-
     auto switchToWindow = [&](CWindow* PWINDOWTOCHANGETO) {
         if (PWINDOWTOCHANGETO == g_pCompositor->m_pLastWindow || !PWINDOWTOCHANGETO)
             return;
 
-        if (g_pCompositor->m_pLastWindow->m_iWorkspaceID == PWINDOWTOCHANGETO->m_iWorkspaceID && g_pCompositor->m_pLastWindow->m_bIsFullscreen) {
+        if (g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->m_iWorkspaceID == PWINDOWTOCHANGETO->m_iWorkspaceID && g_pCompositor->m_pLastWindow->m_bIsFullscreen) {
             const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastWindow->m_iWorkspaceID);
             const auto FSMODE = PWORKSPACE->m_efFullscreenMode;
 
@@ -1461,6 +1520,17 @@ void CKeybindManager::circleNext(std::string arg) {
         }
     };
 
+    if (!g_pCompositor->m_pLastWindow) {
+        // if we have a clear focus, find the first window and get the next focusable.
+        if (g_pCompositor->getWindowsOnWorkspace(g_pCompositor->m_pLastMonitor->activeWorkspace) > 0) {
+            const auto PWINDOW = g_pCompositor->getNextWindowOnWorkspace(g_pCompositor->getFirstWindowOnWorkspace(g_pCompositor->m_pLastMonitor->activeWorkspace), true);
+
+            switchToWindow(PWINDOW);
+        }
+
+        return;
+    }
+
     if (arg == "last" || arg == "l" || arg == "prev" || arg == "p")
         switchToWindow(g_pCompositor->getPrevWindowOnWorkspace(g_pCompositor->m_pLastWindow, true));
     else
@@ -1587,10 +1657,11 @@ void CKeybindManager::layoutmsg(std::string msg) {
 void CKeybindManager::toggleOpaque(std::string unused) {
     const auto PWINDOW = g_pCompositor->m_pLastWindow;
 
-    if (!g_pCompositor->windowValidMapped(PWINDOW))
+    if (!PWINDOW)
         return;
 
     PWINDOW->m_sAdditionalConfigData.forceOpaque = !PWINDOW->m_sAdditionalConfigData.forceOpaque;
+    PWINDOW->m_sAdditionalConfigData.forceOpaqueOverriden = true;
 
     g_pHyprRenderer->damageWindow(PWINDOW);
 }
@@ -1627,7 +1698,7 @@ void CKeybindManager::swapnext(std::string arg) {
 
     CWindow* toSwap = nullptr;
 
-    if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow))
+    if (!g_pCompositor->m_pLastWindow)
         return;
 
     const auto PLASTWINDOW = g_pCompositor->m_pLastWindow;
@@ -1668,12 +1739,15 @@ void CKeybindManager::swapActiveWorkspaces(std::string args) {
 }
 
 void CKeybindManager::pinActive(std::string args) {
-    if (!g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow) || !g_pCompositor->m_pLastWindow->m_bIsFloating || g_pCompositor->m_pLastWindow->m_bIsFullscreen)
+    if (!g_pCompositor->m_pLastWindow || !g_pCompositor->m_pLastWindow->m_bIsFloating || g_pCompositor->m_pLastWindow->m_bIsFullscreen)
         return;
 
     g_pCompositor->m_pLastWindow->m_bPinned = !g_pCompositor->m_pLastWindow->m_bPinned;
     g_pCompositor->m_pLastWindow->m_iWorkspaceID = g_pCompositor->getMonitorFromID(g_pCompositor->m_pLastWindow->m_iMonitorID)->activeWorkspace;
 
+    g_pCompositor->m_pLastWindow->updateDynamicRules();
+    g_pCompositor->updateWindowAnimatedDecorationValues(g_pCompositor->m_pLastWindow);
+
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastWindow->m_iWorkspaceID);
 
     PWORKSPACE->m_pLastFocusedWindow = g_pCompositor->vectorToWindowTiled(g_pInputManager->getMouseCoordsInternal());
@@ -1719,3 +1793,8 @@ void CKeybindManager::mouse(std::string args) {
         }
     }
 }
+
+void CKeybindManager::bringActiveToTop(std::string args) {
+    if (g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->m_bIsFloating)
+        g_pCompositor->moveWindowToTop(g_pCompositor->m_pLastWindow);
+}

src/managers/KeybindManager.hpp

@@ -7,6 +7,7 @@
 #include <functional>
 
 class CInputManager;
+class CConfigManager;
 
 struct SKeybind {
     std::string       key = "";
@@ -92,6 +93,7 @@ private:
     static void         moveActiveToWorkspace(std::string);
     static void         moveActiveToWorkspaceSilent(std::string);
     static void         moveFocusTo(std::string);
+    static void         centerWindow(std::string);
     static void         moveActiveTo(std::string);
     static void         toggleGroup(std::string);
     static void         changeGroupActive(std::string);
@@ -120,9 +122,11 @@ private:
     static void         swapActiveWorkspaces(std::string);
     static void         pinActive(std::string);
     static void         mouse(std::string);
+    static void         bringActiveToTop(std::string);
 
     friend class CCompositor;
     friend class CInputManager;
+    friend class CConfigManager;
 };
 
 inline std::unique_ptr<CKeybindManager> g_pKeybindManager;

src/managers/ProtocolManager.cpp

@@ -0,0 +1,5 @@
+#include "ProtocolManager.hpp"
+
+CProtocolManager::CProtocolManager() {
+    m_pToplevelExportProtocolManager = std::make_unique<CToplevelExportProtocolManager>();
+}

src/managers/ProtocolManager.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "../defines.hpp"
+#include "../protocols/ToplevelExport.hpp"
+
+class CProtocolManager {
+public:
+    CProtocolManager();
+
+    std::unique_ptr<CToplevelExportProtocolManager> m_pToplevelExportProtocolManager;
+};
+
+inline std::unique_ptr<CProtocolManager> g_pProtocolManager;

src/managers/XWaylandManager.cpp

@@ -3,21 +3,23 @@
 #include "../events/Events.hpp"
 
 CHyprXWaylandManager::CHyprXWaylandManager() {
-    if (XWAYLAND) {
-        m_sWLRXWayland = wlr_xwayland_create(g_pCompositor->m_sWLDisplay, g_pCompositor->m_sWLRCompositor, 1);
+#ifndef NO_XWAYLAND
+    m_sWLRXWayland = wlr_xwayland_create(g_pCompositor->m_sWLDisplay, g_pCompositor->m_sWLRCompositor, 1);
 
-        if (!m_sWLRXWayland) {
-            Debug::log(ERR, "Couldn't start up the XWaylandManager because wlr_xwayland_create returned a nullptr!");
-            return;
-        }
-
-        addWLSignal(&m_sWLRXWayland->events.ready, &Events::listen_readyXWayland, m_sWLRXWayland, "XWayland Manager");
-        addWLSignal(&m_sWLRXWayland->events.new_surface, &Events::listen_surfaceXWayland, m_sWLRXWayland, "XWayland Manager");
-
-        setenv("DISPLAY", m_sWLRXWayland->display_name, 1);
-
-        Debug::log(LOG, "CHyprXWaylandManager started on display %s", m_sWLRXWayland->display_name);
+    if (!m_sWLRXWayland) {
+        Debug::log(ERR, "Couldn't start up the XWaylandManager because wlr_xwayland_create returned a nullptr!");
+        return;
     }
+
+    addWLSignal(&m_sWLRXWayland->events.ready, &Events::listen_readyXWayland, m_sWLRXWayland, "XWayland Manager");
+    addWLSignal(&m_sWLRXWayland->events.new_surface, &Events::listen_surfaceXWayland, m_sWLRXWayland, "XWayland Manager");
+
+    setenv("DISPLAY", m_sWLRXWayland->display_name, 1);
+
+    Debug::log(LOG, "CHyprXWaylandManager started on display %s", m_sWLRXWayland->display_name);
+#else
+    unsetenv("DISPLAY");  // unset DISPLAY so that X11 apps do not try to start on a different/invalid DISPLAY
+#endif
 }
 
 CHyprXWaylandManager::~CHyprXWaylandManager() {
@@ -51,17 +53,21 @@ void CHyprXWaylandManager::activateSurface(wlr_surface* pSurface, bool activate)
 
 void CHyprXWaylandManager::activateWindow(CWindow* pWindow, bool activate) {
     if (pWindow->m_bIsX11) {
-        if (pWindow->m_uSurface.xwayland->minimized)
-            wlr_xwayland_surface_set_minimized(pWindow->m_uSurface.xwayland, false);
 
+        if (activate) {
+            wlr_xwayland_surface_set_minimized(pWindow->m_uSurface.xwayland, false);
+            wlr_xwayland_surface_restack(pWindow->m_uSurface.xwayland, NULL, XCB_STACK_MODE_ABOVE);
+        }
+        
         wlr_xwayland_surface_activate(pWindow->m_uSurface.xwayland, activate);
-        wlr_xwayland_surface_restack(pWindow->m_uSurface.xwayland, NULL, XCB_STACK_MODE_ABOVE);
     }
     else
         wlr_xdg_toplevel_set_activated(pWindow->m_uSurface.xdg->toplevel, activate);
 
-    g_pCompositor->m_pLastFocus = getWindowSurface(pWindow);
-    g_pCompositor->m_pLastWindow = pWindow;
+    if (activate) {
+        g_pCompositor->m_pLastFocus = getWindowSurface(pWindow);
+        g_pCompositor->m_pLastWindow = pWindow;
+    }
 
     if (!pWindow->m_bPinned)
         g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID)->m_pLastFocusedWindow = pWindow;
@@ -69,10 +75,19 @@ void CHyprXWaylandManager::activateWindow(CWindow* pWindow, bool activate) {
 
 void CHyprXWaylandManager::getGeometryForWindow(CWindow* pWindow, wlr_box* pbox) {
     if (pWindow->m_bIsX11) {
-        pbox->x = pWindow->m_uSurface.xwayland->x;
-        pbox->y = pWindow->m_uSurface.xwayland->y;
-        pbox->width = pWindow->m_uSurface.xwayland->width;
-        pbox->height = pWindow->m_uSurface.xwayland->height;
+        const auto SIZEHINTS = pWindow->m_uSurface.xwayland->size_hints;
+
+        if (SIZEHINTS && pWindow->m_iX11Type != 2) {
+            pbox->x = SIZEHINTS->x;
+            pbox->y = SIZEHINTS->y;
+            pbox->width = SIZEHINTS->width;
+            pbox->height = SIZEHINTS->height;
+        } else {
+            pbox->x = pWindow->m_uSurface.xwayland->x;
+            pbox->y = pWindow->m_uSurface.xwayland->y;
+            pbox->width = pWindow->m_uSurface.xwayland->width;
+            pbox->height = pWindow->m_uSurface.xwayland->height;
+        }
     } else {
         wlr_xdg_surface_get_geometry(pWindow->m_uSurface.xdg, pbox);
     }

src/managers/input/IdleInhibitor.cpp

@@ -49,6 +49,27 @@ void CInputManager::recheckIdleInhibitorStatus() {
         }
     }
 
+    // check manual user-set inhibitors
+    for (auto& w : g_pCompositor->m_vWindows) {
+        if (w->m_eIdleInhibitMode == IDLEINHIBIT_NONE)
+            continue;
+
+        if (w->m_eIdleInhibitMode == IDLEINHIBIT_ALWAYS) {
+            wlr_idle_set_enabled(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat, false);
+            return;
+        }
+
+        if (w->m_eIdleInhibitMode == IDLEINHIBIT_FOCUS && g_pCompositor->isWindowActive(w.get())) {
+            wlr_idle_set_enabled(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat, false);
+            return;
+        }
+
+        if (w->m_eIdleInhibitMode == IDLEINHIBIT_FULLSCREEN && w->m_bIsFullscreen && g_pCompositor->isWorkspaceVisible(w->m_iWorkspaceID)) {
+            wlr_idle_set_enabled(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat, false);
+            return;
+        }
+    }
+
     wlr_idle_set_enabled(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat, true);
     return;
 }

src/managers/input/InputManager.cpp

@@ -35,7 +35,16 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
     static auto *const PHOGFOCUS = &g_pConfigManager->getConfigValuePtr("misc:layers_hog_keyboard_focus")->intValue;
     static auto *const PFLOATBEHAVIOR = &g_pConfigManager->getConfigValuePtr("input:float_switch_override_focus")->intValue;
 
-    if (!g_pCompositor->m_bReadyToProcess)
+    m_pFoundSurfaceToFocus = nullptr;
+    m_pFoundLSToFocus = nullptr;
+    m_pFoundWindowToFocus = nullptr;
+    wlr_surface* foundSurface = nullptr;
+    Vector2D surfaceCoords;
+    Vector2D surfacePos = Vector2D(-1337, -1337);
+    CWindow* pFoundWindow = nullptr;
+    SLayerSurface* pFoundLayerSurface = nullptr;
+
+    if (!g_pCompositor->m_bReadyToProcess || g_pCompositor->m_bIsShuttingDown)
         return;
 
     if (!g_pCompositor->m_sSeat.mouse) {
@@ -43,9 +52,6 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
         return;
     }
 
-    if (g_pCompositor->m_sSeat.mouse->virt)
-        return; // don't refocus on virt
-
     if (!g_pCompositor->m_bDPMSStateON && *PMOUSEDPMS) {
         // enable dpms
         g_pKeybindManager->dpms("on");
@@ -61,14 +67,13 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
 
     const auto PMONITOR = g_pCompositor->getMonitorFromCursor();
 
-    bool didConstraintOnCursor = false;
-
     // constraints
     // All constraints TODO: multiple mice?
-    if (g_pCompositor->m_sSeat.mouse->currentConstraint) {
+    if (g_pCompositor->m_sSeat.mouse->currentConstraint && !g_pCompositor->m_sSeat.exclusiveClient) {
         // XWayland windows sometimes issue constraints weirdly.
         // TODO: We probably should search their parent. wlr_xwayland_surface->parent
         const auto CONSTRAINTWINDOW = g_pCompositor->getConstraintWindow(g_pCompositor->m_sSeat.mouse);
+        const auto PCONSTRAINT = g_pCompositor->m_sSeat.mouse->currentConstraint;
 
         if (!CONSTRAINTWINDOW) {
             unconstrainMouse();
@@ -78,32 +83,37 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
             const auto CONSTRAINTPOS = CONSTRAINTWINDOW->m_bIsX11 ? Vector2D(CONSTRAINTWINDOW->m_uSurface.xwayland->x, CONSTRAINTWINDOW->m_uSurface.xwayland->y) : CONSTRAINTWINDOW->m_vRealPosition.vec();
             const auto CONSTRAINTSIZE = CONSTRAINTWINDOW->m_bIsX11 ? Vector2D(CONSTRAINTWINDOW->m_uSurface.xwayland->width, CONSTRAINTWINDOW->m_uSurface.xwayland->height) : CONSTRAINTWINDOW->m_vRealSize.vec();
 
-            if (!VECINRECT(mouseCoords, CONSTRAINTPOS.x, CONSTRAINTPOS.y, CONSTRAINTPOS.x + CONSTRAINTSIZE.x - 1.0, CONSTRAINTPOS.y + CONSTRAINTSIZE.y - 1.0)) {
-                if (g_pCompositor->m_sSeat.mouse->constraintActive) {
-                    Vector2D newConstrainedCoords = mouseCoords;
+            if (g_pCompositor->m_sSeat.mouse->currentConstraint->type == WLR_POINTER_CONSTRAINT_V1_LOCKED) {
+                // we just snap the cursor to where it should be.
 
-                    if (mouseCoords.x < CONSTRAINTPOS.x)
-                        newConstrainedCoords.x = CONSTRAINTPOS.x;
-                    else if (mouseCoords.x >= CONSTRAINTPOS.x + CONSTRAINTSIZE.x)
-                        newConstrainedCoords.x = CONSTRAINTPOS.x + CONSTRAINTSIZE.x - 1.0;
+                Vector2D hint = { PCONSTRAINT->current.cursor_hint.x, PCONSTRAINT->current.cursor_hint.y };
 
-                    if (mouseCoords.y < CONSTRAINTPOS.y)
-                        newConstrainedCoords.y = CONSTRAINTPOS.y;
-                    else if (mouseCoords.y >= CONSTRAINTPOS.y + CONSTRAINTSIZE.y)
-                        newConstrainedCoords.y = CONSTRAINTPOS.y + CONSTRAINTSIZE.y - 1.0;
+                wlr_cursor_warp_closest(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, CONSTRAINTPOS.x + hint.x, CONSTRAINTPOS.y + hint.y);
 
-                    wlr_cursor_warp_closest(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, newConstrainedCoords.x, newConstrainedCoords.y);
-
-                    mouseCoords = newConstrainedCoords;
-
-                    didConstraintOnCursor = true;
-                }
+                return; // don't process anything else, the cursor is locked. The surface should not receive any further events.
+                        // these are usually FPS games. They will use the relative motion.
             } else {
-                if ((!CONSTRAINTWINDOW->m_bIsX11 && PMONITOR && CONSTRAINTWINDOW->m_iWorkspaceID == PMONITOR->activeWorkspace) || (CONSTRAINTWINDOW->m_bIsX11)) {
-                    g_pCompositor->m_sSeat.mouse->constraintActive = true;
-                    didConstraintOnCursor = true;
+                // we restrict the cursor to the confined region
+                if (!pixman_region32_contains_point(&PCONSTRAINT->region, mouseCoords.x - CONSTRAINTPOS.x, mouseCoords.y - CONSTRAINTPOS.y, nullptr)) {
+                    if (g_pCompositor->m_sSeat.mouse->constraintActive) {
+                        wlr_cursor_warp_closest(g_pCompositor->m_sWLRCursor, NULL, mouseCoords.x, mouseCoords.y);
+                        mouseCoords = getMouseCoordsInternal();
+                    }
+                } else {
+                    if ((!CONSTRAINTWINDOW->m_bIsX11 && PMONITOR && CONSTRAINTWINDOW->m_iWorkspaceID == PMONITOR->activeWorkspace) || (CONSTRAINTWINDOW->m_bIsX11)) {
+                        g_pCompositor->m_sSeat.mouse->constraintActive = true;
+                    }
                 }
             }
+
+            if (CONSTRAINTWINDOW->m_bIsX11) {
+                foundSurface = g_pXWaylandManager->getWindowSurface(CONSTRAINTWINDOW);
+                surfacePos = CONSTRAINTWINDOW->m_vRealPosition.vec();
+            } else {
+                g_pCompositor->vectorWindowToSurface(mouseCoords, CONSTRAINTWINDOW, surfaceCoords);
+            }
+
+            pFoundWindow = CONSTRAINTWINDOW;
         }
     }
 
@@ -112,29 +122,15 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
 
     g_pLayoutManager->getCurrentLayout()->onMouseMove(getMouseCoordsInternal());
 
-    // focus
-    wlr_surface* foundSurface = nullptr;
-
-    if (didConstraintOnCursor)
-        return; // don't process when cursor constrained
-
     if (PMONITOR && PMONITOR != g_pCompositor->m_pLastMonitor) {
-        g_pCompositor->m_pLastMonitor = PMONITOR;
+        g_pCompositor->setActiveMonitor(PMONITOR);
 
         // set active workspace and deactivate all other in wlr
         const auto ACTIVEWORKSPACE = g_pCompositor->getWorkspaceByID(PMONITOR->activeWorkspace);
         g_pCompositor->deactivateAllWLRWorkspaces(ACTIVEWORKSPACE->m_pWlrHandle);
         ACTIVEWORKSPACE->setActive(true);
-
-        // event
-        g_pEventManager->postEvent(SHyprIPCEvent{"focusedmon", PMONITOR->szName + "," + ACTIVEWORKSPACE->m_szName});
     }
 
-    Vector2D surfaceCoords;
-    Vector2D surfacePos = Vector2D(-1337, -1337);
-    CWindow* pFoundWindow = nullptr;
-    SLayerSurface* pFoundLayerSurface = nullptr;
-
     // overlay is above fullscreen
     if (!foundSurface)
         foundSurface = g_pCompositor->vectorToLayerSurface(mouseCoords, &PMONITOR->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &surfaceCoords, &pFoundLayerSurface);
@@ -153,36 +149,32 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
             return;
         }
 
-        foundSurface = g_pXWaylandManager->getWindowSurface(pFoundWindow);
-        surfacePos = pFoundWindow->m_vRealPosition.vec();
-
         // only check floating because tiled cant be over fullscreen
         for (auto w = g_pCompositor->m_vWindows.rbegin(); w != g_pCompositor->m_vWindows.rend(); w++) {
             wlr_box box = {(*w)->m_vRealPosition.vec().x, (*w)->m_vRealPosition.vec().y, (*w)->m_vRealSize.vec().x, (*w)->m_vRealSize.vec().y};
-            if ((((*w)->m_bIsFloating && (*w)->m_bIsMapped && ((*w)->m_bCreatedOverFullscreen || (*w)->m_bPinned)) || ((*w)->m_iWorkspaceID == SPECIAL_WORKSPACE_ID && PMONITOR->specialWorkspaceOpen)) && wlr_box_contains_point(&box, mouseCoords.x, mouseCoords.y) && g_pCompositor->isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->m_bHidden) {
+            if ((((*w)->m_bIsFloating && (*w)->m_bIsMapped && ((*w)->m_bCreatedOverFullscreen || (*w)->m_bPinned)) || (g_pCompositor->isWorkspaceSpecial((*w)->m_iWorkspaceID) && PMONITOR->specialWorkspaceID)) && wlr_box_contains_point(&box, mouseCoords.x, mouseCoords.y) && g_pCompositor->isWorkspaceVisible((*w)->m_iWorkspaceID) && !(*w)->isHidden()) {
                 pFoundWindow = (*w).get();
-
-                if (!pFoundWindow->m_bIsX11) {
-                    foundSurface = g_pCompositor->vectorWindowToSurface(mouseCoords, pFoundWindow, surfaceCoords);
-                    surfacePos = Vector2D(-1337, -1337);
-                } else {
-                    foundSurface = g_pXWaylandManager->getWindowSurface(pFoundWindow);
-                    surfacePos = pFoundWindow->m_vRealPosition.vec();
-                }
-
                 break;
             }
         }
+
+        if (!pFoundWindow->m_bIsX11) {
+            foundSurface = g_pCompositor->vectorWindowToSurface(mouseCoords, pFoundWindow, surfaceCoords);
+            surfacePos = Vector2D(-1337, -1337);
+        } else {
+            foundSurface = g_pXWaylandManager->getWindowSurface(pFoundWindow);
+            surfacePos = pFoundWindow->m_vRealPosition.vec();
+        }
     }
 
     // then windows
     if (!foundSurface) {
         if (PWORKSPACE->m_bHasFullscreenWindow && PWORKSPACE->m_efFullscreenMode == FULLSCREEN_MAXIMIZED) {
 
-            if (PMONITOR->specialWorkspaceOpen) {
+            if (PMONITOR->specialWorkspaceID) {
                 pFoundWindow = g_pCompositor->vectorToWindowIdeal(mouseCoords);
 
-                if (pFoundWindow && pFoundWindow->m_iWorkspaceID != SPECIAL_WORKSPACE_ID) {
+                if (pFoundWindow && !g_pCompositor->isWorkspaceSpecial(pFoundWindow->m_iWorkspaceID)) {
                     pFoundWindow = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
                 }
             } else {
@@ -226,7 +218,7 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
                 wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "crosshair", g_pCompositor->m_sWLRCursor);
             else
                 wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "left_ptr", g_pCompositor->m_sWLRCursor);
-
+                
             m_bEmptyFocusCursorSet = true;
         }
 
@@ -264,14 +256,21 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
         }
     }
 
+    // set the values for use
+    if (refocus) {
+        m_pFoundLSToFocus = pFoundLayerSurface;
+        m_pFoundWindowToFocus = pFoundWindow;
+        m_pFoundSurfaceToFocus = foundSurface;
+    }
+
     if (pFoundWindow) {
         if (*PFOLLOWMOUSE != 1 && !refocus) {
-            if (pFoundWindow != g_pCompositor->m_pLastWindow && g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow) && g_pCompositor->m_pLastWindow->m_bIsFloating != pFoundWindow->m_bIsFloating && *PFLOATBEHAVIOR) {
+            if (pFoundWindow != g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow && ((pFoundWindow->m_bIsFloating && *PFLOATBEHAVIOR == 2) || (g_pCompositor->m_pLastWindow->m_bIsFloating != pFoundWindow->m_bIsFloating && *PFLOATBEHAVIOR != 0))) {
                 // enter if change floating style
                 if (*PFOLLOWMOUSE != 3 && allowKeyboardRefocus)
                     g_pCompositor->focusWindow(pFoundWindow, foundSurface);
                 wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, foundSurface, surfaceLocal.x, surfaceLocal.y);
-            } else if (*PFOLLOWMOUSE == 2) {
+            } else if (*PFOLLOWMOUSE == 2 || *PFOLLOWMOUSE == 3) {
                 wlr_seat_pointer_notify_enter(g_pCompositor->m_sSeat.seat, foundSurface, surfaceLocal.x, surfaceLocal.y);
             }
 
@@ -300,7 +299,6 @@ void CInputManager::mouseMoveUnified(uint32_t time, bool refocus) {
     } else {
         if (pFoundLayerSurface && pFoundLayerSurface->layerSurface->current.keyboard_interactive && *PFOLLOWMOUSE != 3 && allowKeyboardRefocus) {
             g_pCompositor->focusSurface(foundSurface);
-            g_pCompositor->m_pLastWindow = nullptr; // reset last window as we have a full focus on a LS
         }
 
         if (pFoundLayerSurface)
@@ -338,6 +336,10 @@ void CInputManager::processMouseRequest(wlr_seat_pointer_request_set_cursor_even
         g_pHyprRenderer->m_bWindowRequestedCursorHide = false;
     }
 
+    if (m_bCursorImageOverriden) {
+        return;
+    }
+
     if (m_ecbClickBehavior == CLICKMODE_KILL) {
         wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "crosshair", g_pCompositor->m_sWLRCursor);
         return;
@@ -376,27 +378,25 @@ void CInputManager::setClickMode(eClickBehaviorMode mode) {
 }
 
 void CInputManager::processMouseDownNormal(wlr_pointer_button_event* e) {
-    const auto PKEYBOARD = wlr_seat_get_keyboard(g_pCompositor->m_sSeat.seat);
-
-    if (!PKEYBOARD) {  // ???
-        Debug::log(ERR, "No active keyboard in processMouseDownNormal??");
-        return;
-    }
-
+    
     // notify the keybind manager
     static auto *const PPASSMOUSE = &g_pConfigManager->getConfigValuePtr("binds:pass_mouse_when_bound")->intValue;
     const auto PASS = g_pKeybindManager->onMouseEvent(e);
+    static auto *const PFOLLOWMOUSE = &g_pConfigManager->getConfigValuePtr("input:follow_mouse")->intValue;
 
     if (!PASS && !*PPASSMOUSE)
         return;
 
     switch (e->state) {
         case WLR_BUTTON_PRESSED:
+            if (*PFOLLOWMOUSE == 3) // don't refocus on full loose
+                break;
+
             if (!g_pCompositor->m_sSeat.mouse->currentConstraint)
                 refocus();
 
             // if clicked on a floating window make it top
-            if (g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow) && g_pCompositor->m_pLastWindow->m_bIsFloating)
+            if (g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->m_bIsFloating)
                 g_pCompositor->moveWindowToTop(g_pCompositor->m_pLastWindow);
 
             break;
@@ -415,7 +415,7 @@ void CInputManager::processMouseDownKill(wlr_pointer_button_event* e) {
         case WLR_BUTTON_PRESSED: {
             const auto PWINDOW = g_pCompositor->m_pLastWindow;
 
-            if (!g_pCompositor->windowValidMapped(PWINDOW)){
+            if (!PWINDOW) {
                 Debug::log(ERR, "Cannot kill invalid window!");
                 break;
             }
@@ -459,7 +459,7 @@ void CInputManager::newKeyboard(wlr_input_device* keyboard) {
     PNEWKEYBOARD->keyboard = keyboard;
 
     try {
-        PNEWKEYBOARD->name = std::string(keyboard->name);
+        PNEWKEYBOARD->name = getNameForNewDevice(keyboard->name);
     } catch (std::exception& e) {
         Debug::log(ERR, "Keyboard had no name???");  // logic error
     }
@@ -495,7 +495,7 @@ void CInputManager::newVirtualKeyboard(wlr_input_device* keyboard) {
     PNEWKEYBOARD->isVirtual = true;
 
     try {
-        PNEWKEYBOARD->name = std::string(keyboard->name);
+        PNEWKEYBOARD->name = getNameForNewDevice(keyboard->name);
     } catch (std::exception& e) {
         Debug::log(ERR, "Keyboard had no name???");  // logic error
     }
@@ -532,7 +532,6 @@ void CInputManager::setKeyboardLayout() {
 
 void CInputManager::applyConfigToKeyboard(SKeyboard* pKeyboard) {
     auto devname = pKeyboard->name;
-    transform(devname.begin(), devname.end(), devname.begin(), ::tolower);
 
     const auto HASCONFIG = g_pConfigManager->deviceConfigExists(devname);
 
@@ -656,7 +655,7 @@ void CInputManager::newMouse(wlr_input_device* mouse, bool virt) {
     PMOUSE->mouse = mouse;
     PMOUSE->virt = virt;
     try {
-        PMOUSE->name = std::string(mouse->name);
+        PMOUSE->name = getNameForNewDevice(mouse->name);
     } catch(std::exception& e) {
         Debug::log(ERR, "Mouse had no name???"); // logic error
     }
@@ -667,12 +666,14 @@ void CInputManager::newMouse(wlr_input_device* mouse, bool virt) {
         Debug::log(LOG, "New mouse has libinput sens %.2f (%.2f) with accel profile %i (%i)", libinput_device_config_accel_get_speed(LIBINPUTDEV), libinput_device_config_accel_get_default_speed(LIBINPUTDEV), libinput_device_config_accel_get_profile(LIBINPUTDEV), libinput_device_config_accel_get_default_profile(LIBINPUTDEV));
     }
 
+    wlr_cursor_attach_input_device(g_pCompositor->m_sWLRCursor, mouse);
+
+    PMOUSE->connected = true;
+
     setPointerConfigs();
 
     PMOUSE->hyprListener_destroyMouse.initCallback(&mouse->events.destroy, &Events::listener_destroyMouse, PMOUSE, "Mouse");
 
-    wlr_cursor_attach_input_device(g_pCompositor->m_sWLRCursor, mouse);
-
     g_pCompositor->m_sSeat.mouse = PMOUSE;
 
     m_tmrLastCursorMovement.reset();
@@ -685,10 +686,20 @@ void CInputManager::setPointerConfigs() {
         const auto PPOINTER = &m;
 
         auto devname = PPOINTER->name;
-        transform(devname.begin(), devname.end(), devname.begin(), ::tolower);
 
         const auto HASCONFIG = g_pConfigManager->deviceConfigExists(devname);
 
+        if (HASCONFIG) {
+            const auto ENABLED = g_pConfigManager->getDeviceInt(devname, "enabled");
+            if (ENABLED && !m.connected) {
+                wlr_cursor_attach_input_device(g_pCompositor->m_sWLRCursor, m.mouse);
+                m.connected = true;
+            } else if (!ENABLED && m.connected) {
+                wlr_cursor_detach_input_device(g_pCompositor->m_sWLRCursor, m.mouse);
+                m.connected = false;
+            }
+        }
+
         if (wlr_input_device_is_libinput(m.mouse)) {
             const auto LIBINPUTDEV = (libinput_device*)wlr_libinput_get_device_handle(m.mouse);
 
@@ -710,7 +721,7 @@ void CInputManager::setPointerConfigs() {
             }
 
             const auto SCROLLMETHOD = HASCONFIG ? g_pConfigManager->getDeviceString(devname, "scroll_method") : g_pConfigManager->getString("input:scroll_method");
-            if (SCROLLMETHOD == "" || SCROLLMETHOD == STRVAL_EMPTY) {
+            if (SCROLLMETHOD == "") {
                 libinput_device_config_scroll_set_method(LIBINPUTDEV, libinput_device_config_scroll_get_default_method(LIBINPUTDEV));
             } else if (SCROLLMETHOD == "no_scroll") {
                 libinput_device_config_scroll_set_method(LIBINPUTDEV, LIBINPUT_CONFIG_SCROLL_NO_SCROLL);
@@ -752,7 +763,7 @@ void CInputManager::setPointerConfigs() {
 
             const auto ACCELPROFILE = HASCONFIG ? g_pConfigManager->getDeviceString(devname, "accel_profile") : g_pConfigManager->getString("input:accel_profile");
 
-            if (ACCELPROFILE == "" || ACCELPROFILE == STRVAL_EMPTY) {
+            if (ACCELPROFILE == "") {
                 libinput_device_config_accel_set_profile(LIBINPUTDEV, libinput_device_config_accel_get_default_profile(LIBINPUTDEV));
             } else if (ACCELPROFILE == "adaptive") {
                 libinput_device_config_accel_set_profile(LIBINPUTDEV, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
@@ -760,7 +771,11 @@ void CInputManager::setPointerConfigs() {
                 libinput_device_config_accel_set_profile(LIBINPUTDEV, LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
             } else {
                 Debug::log(WARN, "Unknown acceleration profile, falling back to default");
-            } 
+            }
+
+            const auto SCROLLBUTTON = HASCONFIG ? g_pConfigManager->getDeviceInt(devname, "scroll_button") : g_pConfigManager->getInt("input:scroll_button");
+
+            libinput_device_config_scroll_set_button(LIBINPUTDEV, SCROLLBUTTON == 0 ? libinput_device_config_scroll_get_default_button(LIBINPUTDEV) : SCROLLBUTTON);
 
             Debug::log(LOG, "Applied config to mouse %s, sens %.2f", m.name.c_str(), LIBINPUTSENS);
         }
@@ -800,6 +815,31 @@ void CInputManager::destroyMouse(wlr_input_device* mouse) {
         unconstrainMouse();
 }
 
+
+void CInputManager::updateKeyboardsLeds(wlr_input_device* pKeyboard) {    
+    auto keyboard = wlr_keyboard_from_input_device(pKeyboard);
+    
+    if (keyboard->xkb_state == NULL) {
+		return;
+	}
+
+	uint32_t leds = 0;
+	for (uint32_t i = 0; i < WLR_LED_COUNT; ++i) {
+		if (xkb_state_led_index_is_active(keyboard->xkb_state,
+				keyboard->led_indexes[i])) {
+			leds |= (1 << i);
+		}
+	}
+    
+    for (auto& kb : m_lKeyboards) {
+        if ((kb.isVirtual && shouldIgnoreVirtualKeyboard(&kb)) || kb.keyboard == pKeyboard)
+            continue;
+
+        wlr_keyboard_led_update(wlr_keyboard_from_input_device(kb.keyboard), leds);
+    }
+}
+
+
 void CInputManager::onKeyboardKey(wlr_keyboard_key_event* e, SKeyboard* pKeyboard) {
     bool passEvent = g_pKeybindManager->onKeyEvent(e, pKeyboard);
 
@@ -816,6 +856,8 @@ void CInputManager::onKeyboardKey(wlr_keyboard_key_event* e, SKeyboard* pKeyboar
             wlr_seat_set_keyboard(g_pCompositor->m_sSeat.seat, wlr_keyboard_from_input_device(pKeyboard->keyboard));
             wlr_seat_keyboard_notify_key(g_pCompositor->m_sSeat.seat, e->time_msec, e->keycode, e->state);
         }
+
+        updateKeyboardsLeds(pKeyboard->keyboard);
     }
 }
 
@@ -835,6 +877,8 @@ void CInputManager::onKeyboardMod(void* data, SKeyboard* pKeyboard) {
         wlr_seat_keyboard_notify_modifiers(g_pCompositor->m_sSeat.seat, &MODS);
     }
 
+    updateKeyboardsLeds(pKeyboard->keyboard);
+
     const auto PWLRKB = wlr_keyboard_from_input_device(pKeyboard->keyboard);
 
     if (PWLRKB->modifiers.group != pKeyboard->activeLayout) {
@@ -844,6 +888,10 @@ void CInputManager::onKeyboardMod(void* data, SKeyboard* pKeyboard) {
 	}
 }
 
+bool CInputManager::shouldIgnoreVirtualKeyboard(SKeyboard* pKeyboard) {
+    return !pKeyboard || (m_sIMERelay.m_pKeyboardGrab && wl_resource_get_client(m_sIMERelay.m_pKeyboardGrab->pWlrKbGrab->resource) == wl_resource_get_client(wlr_input_device_get_virtual_keyboard(pKeyboard->keyboard)->resource));
+}
+
 void CInputManager::refocus() {
     mouseMoveUnified(0, true);
 }
@@ -960,24 +1008,20 @@ void Events::listener_commitConstraint(void* owner, void* data) {
     //g_pInputManager->recheckConstraint((SMouse*)owner);
 }
 
-void CInputManager::updateCapabilities(wlr_input_device* pDev) {
-    // TODO: this is dumb
+void CInputManager::updateCapabilities() {
+    uint32_t caps = 0;
 
-    switch (pDev->type) {
-        case WLR_INPUT_DEVICE_KEYBOARD:
-            m_uiCapabilities |= WL_SEAT_CAPABILITY_KEYBOARD;
-            break;
-        case WLR_INPUT_DEVICE_POINTER:
-            m_uiCapabilities |= WL_SEAT_CAPABILITY_POINTER;
-            break;
-        case WLR_INPUT_DEVICE_TOUCH:
-            m_uiCapabilities |= WL_SEAT_CAPABILITY_TOUCH;
-            break;
-        default:
-            break;
-    }
+    if (!m_lKeyboards.empty())
+        caps |= WL_SEAT_CAPABILITY_KEYBOARD;
+    if (!m_lMice.empty())
+        caps |= WL_SEAT_CAPABILITY_POINTER;
+    if (!m_lTouchDevices.empty())
+        caps |= WL_SEAT_CAPABILITY_TOUCH;
+    if (!m_lTabletTools.empty())
+        caps |= WL_SEAT_CAPABILITY_POINTER;
 
-    wlr_seat_set_capabilities(g_pCompositor->m_sSeat.seat, m_uiCapabilities);
+    wlr_seat_set_capabilities(g_pCompositor->m_sSeat.seat, caps);
+    m_uiCapabilities = caps;
 }
 
 uint32_t CInputManager::accumulateModsFromAllKBs() {
@@ -985,7 +1029,7 @@ uint32_t CInputManager::accumulateModsFromAllKBs() {
     uint32_t finalMask = 0;
 
     for (auto& kb : m_lKeyboards) {
-        if (kb.isVirtual)
+        if (kb.isVirtual && shouldIgnoreVirtualKeyboard(&kb))
             continue;
 
         finalMask |= wlr_keyboard_get_modifiers(wlr_keyboard_from_input_device(kb.keyboard));
@@ -1027,6 +1071,13 @@ void CInputManager::newTouchDevice(wlr_input_device* pDevice) {
     const auto PNEWDEV = &m_lTouchDevices.emplace_back();
     PNEWDEV->pWlrDevice = pDevice;
 
+    try {
+        PNEWDEV->name = getNameForNewDevice(pDevice->name);
+    } catch(std::exception& e) {
+        Debug::log(ERR, "Touch Device had no name???"); // logic error
+    }
+
+    setTouchDeviceConfigs();
     wlr_cursor_attach_input_device(g_pCompositor->m_sWLRCursor, pDevice);
 
     Debug::log(LOG, "New touch device added at %x", PNEWDEV);
@@ -1036,6 +1087,62 @@ void CInputManager::newTouchDevice(wlr_input_device* pDevice) {
     }, PNEWDEV, "TouchDevice");
 }
 
+void CInputManager::setTouchDeviceConfigs() {
+    // The third row is always 0 0 1 and is not expected by `libinput_device_config_calibration_set_matrix`
+    static const float MATRICES[8][6] = {
+       { // normal
+        1, 0, 0,
+        0, 1, 0
+       },
+       { // rotation 90°
+        0, -1, 1,
+        1, 0, 0
+       },
+       { // rotation 180°
+        -1, 0, 1,
+        0, -1, 1
+       },
+       { // rotation 270°
+        0, 1, 0,
+        -1, 0, 1
+       },
+       { // flipped
+        -1, 0, 1,
+        0, 1, 0
+       },
+       { // flipped + rotation 90°
+        0, 1, 0,
+        1, 0, 0
+       },
+       { // flipped + rotation 180°
+        1, 0, 0,
+        0, -1, 1
+       },
+       { // flipped + rotation 270°
+        0, -1, 1,
+        -1, 0, 1
+       }
+    };
+    for (auto& m : m_lTouchDevices) {
+        const auto PTOUCHDEV = &m;
+
+        const auto HASCONFIG = g_pConfigManager->deviceConfigExists(PTOUCHDEV->name);
+
+        if (wlr_input_device_is_libinput(m.pWlrDevice)) {
+            const auto LIBINPUTDEV = (libinput_device*)wlr_libinput_get_device_handle(m.pWlrDevice);
+
+            const int ROTATION = std::clamp(HASCONFIG ? g_pConfigManager->getDeviceInt(PTOUCHDEV->name, "touch_transform") : g_pConfigManager->getInt("input:touchdevice:transform"), 0, 7);
+            libinput_device_config_calibration_set_matrix(LIBINPUTDEV, MATRICES[ROTATION]);
+
+            const auto OUTPUT = HASCONFIG ? g_pConfigManager->getDeviceString(PTOUCHDEV->name, "touch_output") : g_pConfigManager->getString("input:touchdevice:output");
+            if (!OUTPUT.empty() && OUTPUT != STRVAL_EMPTY)
+                PTOUCHDEV->boundOutput = OUTPUT;
+            else
+                PTOUCHDEV->boundOutput = "";
+        }
+    }
+}
+
 void CInputManager::destroyTouchDevice(STouchDevice* pDevice) {
     Debug::log(LOG, "Touch device at %x removed", pDevice);
 
@@ -1067,3 +1174,49 @@ void CInputManager::newSwitch(wlr_input_device* pDevice) {
 void CInputManager::destroySwitch(SSwitchDevice* pDevice) {
     m_lSwitches.remove(*pDevice);
 }
+
+void CInputManager::setCursorImageUntilUnset(std::string name) {
+    wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, name.c_str(), g_pCompositor->m_sWLRCursor);
+    m_bCursorImageOverriden = true;
+}
+
+void CInputManager::unsetCursorImage() {
+    if (!m_bCursorImageOverriden)
+        return;
+
+    m_bCursorImageOverriden = false;
+    if (!g_pHyprRenderer->m_bWindowRequestedCursorHide)
+        wlr_xcursor_manager_set_cursor_image(g_pCompositor->m_sWLRXCursorMgr, "left_ptr", g_pCompositor->m_sWLRCursor);
+}
+
+std::string CInputManager::deviceNameToInternalString(std::string in) {
+    std::replace(in.begin(), in.end(), ' ', '-');
+    std::transform(in.begin(), in.end(), in.begin(), ::tolower);
+    return in;
+}
+
+std::string CInputManager::getNameForNewDevice(std::string internalName) {
+
+    auto proposedNewName = deviceNameToInternalString(internalName);
+    int dupeno = 0;
+
+    while (std::find_if(m_lKeyboards.begin(), m_lKeyboards.end(), [&] (const SKeyboard& other) { return other.name == proposedNewName + (dupeno == 0 ? "" : ("-" + std::to_string(dupeno))); }) != m_lKeyboards.end())
+        dupeno++;
+
+    while (std::find_if(m_lMice.begin(), m_lMice.end(), [&] (const SMouse& other) { return other.name == proposedNewName + (dupeno == 0 ? "" : ("-" + std::to_string(dupeno))); }) != m_lMice.end())
+        dupeno++;
+
+    while (std::find_if(m_lTouchDevices.begin(), m_lTouchDevices.end(), [&] (const STouchDevice& other) { return other.name == proposedNewName + (dupeno == 0 ? "" : ("-" + std::to_string(dupeno))); }) != m_lTouchDevices.end())
+        dupeno++;
+
+    while (std::find_if(m_lTabletPads.begin(), m_lTabletPads.end(), [&] (const STabletPad& other) { return other.name == proposedNewName + (dupeno == 0 ? "" : ("-" + std::to_string(dupeno))); }) != m_lTabletPads.end())
+        dupeno++;
+
+    while (std::find_if(m_lTablets.begin(), m_lTablets.end(), [&] (const STablet& other) { return other.name == proposedNewName + (dupeno == 0 ? "" : ("-" + std::to_string(dupeno))); }) != m_lTablets.end())
+        dupeno++;
+
+    while (std::find_if(m_lTabletTools.begin(), m_lTabletTools.end(), [&] (const STabletTool& other) { return other.name == proposedNewName + (dupeno == 0 ? "" : ("-" + std::to_string(dupeno))); }) != m_lTabletTools.end())
+        dupeno++;
+
+    return proposedNewName + (dupeno == 0 ? "" : ("-" + std::to_string(dupeno)));
+}

src/managers/input/InputManager.hpp

@@ -20,9 +20,13 @@ enum eMouseBindMode {
 
 struct STouchData {
     CWindow* touchFocusWindow = nullptr;
+    SLayerSurface* touchFocusLS = nullptr;
+    wlr_surface* touchFocusSurface = nullptr;
     Vector2D touchSurfaceOrigin;
 };
 
+class CKeybindManager;
+
 class CInputManager {
 public:
 
@@ -53,9 +57,10 @@ public:
 
     void            setKeyboardLayout();
     void            setPointerConfigs();
+    void            setTouchDeviceConfigs();
 
     void            updateDragIcon();
-    void            updateCapabilities(wlr_input_device*);
+    void            updateCapabilities();
 
     void            setClickMode(eClickBehaviorMode);
     eClickBehaviorMode getClickMode();
@@ -112,13 +117,27 @@ public:
 
     CInputMethodRelay m_sIMERelay;
 
+    void            updateKeyboardsLeds(wlr_input_device* pKeyboard);
+
     // for shared mods
     uint32_t        accumulateModsFromAllKBs();
 
     CWindow*        m_pFollowOnDnDBegin = nullptr;
 
+    // for virtual keyboards: whether we should respect them as normal ones
+    bool            shouldIgnoreVirtualKeyboard(SKeyboard*);
+
+    // for special cursors that we choose
+    void            setCursorImageUntilUnset(std::string);
+    void            unsetCursorImage();
+
+    std::string     deviceNameToInternalString(std::string);
+    std::string     getNameForNewDevice(std::string);
+
 private:
 
+    bool            m_bCursorImageOverriden = false;
+
     // for click behavior override
     eClickBehaviorMode m_ecbClickBehavior = CLICKMODE_DEFAULT;
     bool            m_bEmptyFocusCursorSet = false;
@@ -139,6 +158,16 @@ private:
     STabletTool*    ensureTabletToolPresent(wlr_tablet_tool*);
 
     void            applyConfigToKeyboard(SKeyboard*);
+
+    // this will be set after a refocus()
+    wlr_surface*    m_pFoundSurfaceToFocus = nullptr;
+    SLayerSurface*  m_pFoundLSToFocus = nullptr;
+    CWindow*        m_pFoundWindowToFocus = nullptr;
+
+    // swipe
+    void            beginWorkspaceSwipe();
+
+    friend class CKeybindManager;
 };
 
 inline std::unique_ptr<CInputManager> g_pInputManager;

src/managers/input/InputMethodRelay.cpp

@@ -301,7 +301,7 @@ void CInputMethodRelay::createNewTextInput(wlr_text_input_v3* pInput) {
         const auto PINPUT = (STextInput*)owner;
 
         if (!g_pInputManager->m_sIMERelay.m_pWLRIME) {
-            Debug::log(ERR, "Enabling TextInput on no IME!");
+           // Debug::log(WARN, "Enabling TextInput on no IME!");
             return;
         }
 
@@ -317,12 +317,12 @@ void CInputMethodRelay::createNewTextInput(wlr_text_input_v3* pInput) {
         const auto PINPUT = (STextInput*)owner;
 
         if (!g_pInputManager->m_sIMERelay.m_pWLRIME) {
-            Debug::log(ERR, "Committing TextInput on no IME!");
+         //   Debug::log(WARN, "Committing TextInput on no IME!");
             return;
         }
 
         if (!PINPUT->pWlrInput->current_enabled) {
-            Debug::log(ERR, "Disabled TextInput commit?");
+            Debug::log(WARN, "Disabled TextInput commit?");
             return;
         }
 
@@ -335,7 +335,7 @@ void CInputMethodRelay::createNewTextInput(wlr_text_input_v3* pInput) {
         const auto PINPUT = (STextInput*)owner;
 
         if (!g_pInputManager->m_sIMERelay.m_pWLRIME) {
-            Debug::log(ERR, "Disabling TextInput on no IME!");
+          //  Debug::log(WARN, "Disabling TextInput on no IME!");
             return;
         }
 
@@ -352,7 +352,7 @@ void CInputMethodRelay::createNewTextInput(wlr_text_input_v3* pInput) {
         const auto PINPUT = (STextInput*)owner;
 
         if (!g_pInputManager->m_sIMERelay.m_pWLRIME) {
-            Debug::log(ERR, "Disabling TextInput on no IME!");
+          //  Debug::log(WARN, "Disabling TextInput on no IME!");
             return;
         }
 

src/managers/input/InputMethodRelay.hpp

@@ -3,6 +3,8 @@
 #include "../../defines.hpp"
 #include "../../helpers/WLClasses.hpp"
 
+class CInputManager;
+
 class CInputMethodRelay {
 public:
     CInputMethodRelay();
@@ -45,4 +47,5 @@ private:
     void        createNewTextInput(wlr_text_input_v3*);
 
     friend class CHyprRenderer;
+    friend class CInputManager;
 };

src/managers/input/Swipe.cpp

@@ -4,20 +4,25 @@
 void CInputManager::onSwipeBegin(wlr_pointer_swipe_begin_event* e) {
     static auto *const PSWIPE = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe")->intValue;
     static auto *const PSWIPEFINGERS = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_fingers")->intValue;
+    static auto *const PSWIPENEW  = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_create_new")->intValue;
 
     if (e->fingers != *PSWIPEFINGERS || *PSWIPE == 0)
         return;
 
     int onMonitor = 0;
     for (auto& w : g_pCompositor->m_vWorkspaces) {
-        if (w->m_iMonitorID == g_pCompositor->m_pLastMonitor->ID && w->m_iID != SPECIAL_WORKSPACE_ID) {
+        if (w->m_iMonitorID == g_pCompositor->m_pLastMonitor->ID && !g_pCompositor->isWorkspaceSpecial(w->m_iID)) {
             onMonitor++;
         }
     }
 
-    if (onMonitor < 2)
+    if (onMonitor < 2 && !*PSWIPENEW)
         return; // disallow swiping when there's 1 workspace on a monitor
 
+    beginWorkspaceSwipe();
+}
+
+void CInputManager::beginWorkspaceSwipe() {
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
 
     Debug::log(LOG, "Starting a swipe from %s", PWORKSPACE->m_szName.c_str());
@@ -42,6 +47,7 @@ void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
     static auto *const PSWIPEPERC = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_cancel_ratio")->floatValue;
     static auto *const PSWIPEDIST = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_distance")->intValue;
     static auto *const PSWIPEFORC = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_min_speed_to_force")->intValue;
+    static auto *const PSWIPENEW  = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_create_new")->intValue;
     const bool VERTANIMS = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle == "slidevert";
 
     // commit
@@ -49,7 +55,11 @@ void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
     auto workspaceIDLeft = getWorkspaceIDFromString("m-1", wsname);
     auto workspaceIDRight = getWorkspaceIDFromString("m+1", wsname);
 
-    const auto PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight);
+    if ((workspaceIDRight <= m_sActiveSwipe.pWorkspaceBegin->m_iID || (workspaceIDRight == workspaceIDLeft && workspaceIDLeft == m_sActiveSwipe.pWorkspaceBegin->m_iID)) && *PSWIPENEW) {
+        workspaceIDRight = m_sActiveSwipe.pWorkspaceBegin->m_iID > 0 ? m_sActiveSwipe.pWorkspaceBegin->m_iID + 1 : 1;
+    }
+
+    auto PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight); // not guaranteed if PSWIPENEW
     const auto PWORKSPACEL = g_pCompositor->getWorkspaceByID(workspaceIDLeft);
 
     const auto RENDEROFFSETMIDDLE = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.vec();
@@ -60,7 +70,8 @@ void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
         // revert
         if (abs(m_sActiveSwipe.delta) < 2) {
             PWORKSPACEL->m_vRenderOffset.setValueAndWarp(Vector2D(0,0));
-            PWORKSPACER->m_vRenderOffset.setValueAndWarp(Vector2D(0,0));
+            if (PWORKSPACER)
+                PWORKSPACER->m_vRenderOffset.setValueAndWarp(Vector2D(0,0));
             m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0,0));
         } else {
             if (m_sActiveSwipe.delta < 0) {
@@ -69,7 +80,7 @@ void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
                     PWORKSPACEL->m_vRenderOffset = Vector2D({0, -m_sActiveSwipe.pMonitor->vecSize.y});
                 else
                     PWORKSPACEL->m_vRenderOffset = Vector2D({-m_sActiveSwipe.pMonitor->vecSize.x, 0});
-            } else {
+            } else if (PWORKSPACER) {
                 // to right
                 if (VERTANIMS)
                     PWORKSPACER->m_vRenderOffset = Vector2D({0, m_sActiveSwipe.pMonitor->vecSize.y});
@@ -104,9 +115,15 @@ void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
         pSwitchedTo = PWORKSPACEL;
     } else {
         // switch to right
-        const auto RENDEROFFSET = PWORKSPACER->m_vRenderOffset.vec();
+        const auto RENDEROFFSET = PWORKSPACER ? PWORKSPACER->m_vRenderOffset.vec() : Vector2D();
 
-        g_pKeybindManager->m_mDispatchers["workspace"]("[internal]" + std::to_string(workspaceIDRight));
+        if (PWORKSPACER)
+            g_pKeybindManager->m_mDispatchers["workspace"]("[internal]" + std::to_string(workspaceIDRight));
+        else
+            g_pKeybindManager->m_mDispatchers["workspace"](std::to_string(workspaceIDRight)); // so that the ID is created properly
+
+        if (!PWORKSPACER)
+            PWORKSPACER = g_pCompositor->getWorkspaceByID(workspaceIDRight); // not guaranteed on PSWIPENEW
 
         PWORKSPACER->m_vRenderOffset.setValue(RENDEROFFSET);
         PWORKSPACER->m_fAlpha.setValueAndWarp(255.f);
@@ -128,7 +145,8 @@ void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
     g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor);
 
     PWORKSPACEL->m_bForceRendering = false;
-    PWORKSPACER->m_bForceRendering = false;
+    if (PWORKSPACER)
+        PWORKSPACER->m_bForceRendering = false;
     m_sActiveSwipe.pWorkspaceBegin->m_bForceRendering = false;
 
     m_sActiveSwipe.pWorkspaceBegin = nullptr;
@@ -137,7 +155,7 @@ void CInputManager::onSwipeEnd(wlr_pointer_swipe_end_event* e) {
 
     // apply alpha
     for (auto& ls : g_pCompositor->m_pLastMonitor->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
-        ls->alpha = pSwitchedTo->m_bHasFullscreenWindow ? 0.f : 255.f;
+        ls->alpha = pSwitchedTo->m_bHasFullscreenWindow && pSwitchedTo->m_efFullscreenMode == FULLSCREEN_FULL ? 0.f : 255.f;
     }
 }
 
@@ -147,6 +165,8 @@ void CInputManager::onSwipeUpdate(wlr_pointer_swipe_update_event* e) {
 
     static auto *const PSWIPEDIST = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_distance")->intValue;
     static auto *const PSWIPEINVR = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_invert")->intValue;
+    static auto *const PSWIPENEW  = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_create_new")->intValue;
+    static auto *const PSWIPEFOREVER = &g_pConfigManager->getConfigValuePtr("gestures:workspace_swipe_forever")->intValue;
 
     const bool VERTANIMS = m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.getConfig()->pValues->internalStyle == "slidevert";
 
@@ -159,7 +179,7 @@ void CInputManager::onSwipeUpdate(wlr_pointer_swipe_update_event* e) {
     auto workspaceIDLeft = getWorkspaceIDFromString("m-1", wsname);
     auto workspaceIDRight = getWorkspaceIDFromString("m+1", wsname);
 
-    if (workspaceIDLeft == INT_MAX || workspaceIDRight == INT_MAX || workspaceIDLeft == m_sActiveSwipe.pWorkspaceBegin->m_iID) {
+    if ((workspaceIDLeft == INT_MAX || workspaceIDRight == INT_MAX || workspaceIDLeft == m_sActiveSwipe.pWorkspaceBegin->m_iID) && !*PSWIPENEW) {
         m_sActiveSwipe.pWorkspaceBegin = nullptr; // invalidate the swipe
         return;
     }
@@ -168,8 +188,16 @@ void CInputManager::onSwipeUpdate(wlr_pointer_swipe_update_event* e) {
 
     m_sActiveSwipe.delta = std::clamp(m_sActiveSwipe.delta, (double)-*PSWIPEDIST, (double)*PSWIPEDIST);
 
+    if ((m_sActiveSwipe.pWorkspaceBegin->m_iID == workspaceIDLeft && *PSWIPENEW && (m_sActiveSwipe.delta < 0)) ||
+        (m_sActiveSwipe.delta > 0 && g_pCompositor->getWindowsOnWorkspace(m_sActiveSwipe.pWorkspaceBegin->m_iID) == 0 && workspaceIDRight <= m_sActiveSwipe.pWorkspaceBegin->m_iID) ||
+        (m_sActiveSwipe.delta < 0 && m_sActiveSwipe.pWorkspaceBegin->m_iID <= workspaceIDLeft)) {
+
+        m_sActiveSwipe.delta = 0;
+        return;
+    }
+
     if (m_sActiveSwipe.delta < 0) {
-        if (workspaceIDLeft > m_sActiveSwipe.pWorkspaceBegin->m_iID){
+        if (workspaceIDLeft > m_sActiveSwipe.pWorkspaceBegin->m_iID && !*PSWIPENEW){
             m_sActiveSwipe.delta = 0;
             return;
         }
@@ -196,7 +224,18 @@ void CInputManager::onSwipeUpdate(wlr_pointer_swipe_update_event* e) {
 
         g_pCompositor->updateWorkspaceWindowDecos(workspaceIDLeft);
     } else {
-        if (workspaceIDRight < m_sActiveSwipe.pWorkspaceBegin->m_iID){
+        if (workspaceIDRight < m_sActiveSwipe.pWorkspaceBegin->m_iID) {
+            if (*PSWIPENEW) {
+                g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor);
+
+                if (VERTANIMS)
+                    m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(0, ((-m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.y));
+                else
+                    m_sActiveSwipe.pWorkspaceBegin->m_vRenderOffset.setValueAndWarp(Vector2D(((-m_sActiveSwipe.delta) / *PSWIPEDIST) * m_sActiveSwipe.pMonitor->vecSize.x, 0));
+
+                g_pCompositor->updateWorkspaceWindowDecos(m_sActiveSwipe.pWorkspaceBegin->m_iID);
+                return;
+            }
             m_sActiveSwipe.delta = 0;
             return;
         }
@@ -227,4 +266,11 @@ void CInputManager::onSwipeUpdate(wlr_pointer_swipe_update_event* e) {
     g_pHyprRenderer->damageMonitor(m_sActiveSwipe.pMonitor);
 
     g_pCompositor->updateWorkspaceWindowDecos(m_sActiveSwipe.pWorkspaceBegin->m_iID);
+
+    if (*PSWIPEFOREVER) {
+        if (abs(m_sActiveSwipe.delta) >= *PSWIPEDIST) {
+            onSwipeEnd(nullptr);
+            beginWorkspaceSwipe();
+        }
+    }
 }

src/managers/input/Tablets.cpp

@@ -5,7 +5,7 @@ void CInputManager::newTabletTool(wlr_input_device* pDevice) {
     const auto PNEWTABLET = &m_lTablets.emplace_back();
 
     try {
-        PNEWTABLET->name = std::string(pDevice->name);
+        PNEWTABLET->name = deviceNameToInternalString(pDevice->name);
     } catch (std::exception& e) {
         Debug::log(ERR, "Tablet had no name???");  // logic error
     }
@@ -158,7 +158,7 @@ void CInputManager::newTabletPad(wlr_input_device* pDevice) {
     const auto PNEWPAD = &m_lTabletPads.emplace_back();
 
     try {
-        PNEWPAD->name = std::string(pDevice->name);
+        PNEWPAD->name = deviceNameToInternalString(pDevice->name);
     } catch (std::exception& e) {
         Debug::log(ERR, "Pad had no name???");  // logic error
     }
@@ -219,7 +219,7 @@ void CInputManager::newTabletPad(wlr_input_device* pDevice) {
 void CInputManager::focusTablet(STablet* pTab, wlr_tablet_tool* pTool, bool motion) {
     const auto PTOOL = g_pInputManager->ensureTabletToolPresent(pTool);
 
-    if (const auto PWINDOW = g_pCompositor->m_pLastWindow; g_pCompositor->windowValidMapped(PWINDOW)) {
+    if (const auto PWINDOW = g_pCompositor->m_pLastWindow; PWINDOW) {
         const auto CURSORPOS = g_pInputManager->getMouseCoordsInternal();
 
         const auto LOCAL = CURSORPOS - PWINDOW->m_vRealPosition.goalv();

src/managers/input/Touch.cpp

@@ -3,44 +3,67 @@
 
 void CInputManager::onTouchDown(wlr_touch_down_event* e) {
     auto PMONITOR = g_pCompositor->getMonitorFromName(e->touch->output_name ? e->touch->output_name : "");
+
+    const auto PDEVIT = std::find_if(m_lTouchDevices.begin(), m_lTouchDevices.end(), [&](const STouchDevice& other) { return other.pWlrDevice == &e->touch->base; });
+
+    if (PDEVIT != m_lTouchDevices.end() && !PDEVIT->boundOutput.empty())
+        PMONITOR = g_pCompositor->getMonitorFromName(PDEVIT->boundOutput);
+
     PMONITOR = PMONITOR ? PMONITOR : g_pCompositor->m_pLastMonitor;
 
-    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, PMONITOR->vecPosition.x + e->x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e->y * PMONITOR->vecSize.y);
+    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, PMONITOR->vecPosition.x + e->x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e->y * PMONITOR->vecSize.y);
 
     refocus();
 
-    m_sTouchData.touchFocusWindow = nullptr;
+    m_sTouchData.touchFocusWindow = m_pFoundWindowToFocus;
+    m_sTouchData.touchFocusSurface = m_pFoundSurfaceToFocus;
+    m_sTouchData.touchFocusLS = m_pFoundLSToFocus;
 
-    if (g_pCompositor->windowValidMapped(g_pCompositor->m_pLastWindow)) {
-        Vector2D local;
-        if (g_pCompositor->m_pLastWindow->m_bIsX11) {
-            local = g_pInputManager->getMouseCoordsInternal() - g_pCompositor->m_pLastWindow->m_vRealPosition.goalv();
+    Vector2D local;
+
+    if (m_sTouchData.touchFocusWindow) {
+        if (m_sTouchData.touchFocusWindow->m_bIsX11) {
+            local = g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchFocusWindow->m_vRealPosition.goalv();
         } else {
-            g_pCompositor->vectorWindowToSurface(g_pInputManager->getMouseCoordsInternal(), g_pCompositor->m_pLastWindow, local);
+            g_pCompositor->vectorWindowToSurface(g_pInputManager->getMouseCoordsInternal(), m_sTouchData.touchFocusWindow, local);
         }
 
         m_sTouchData.touchSurfaceOrigin = g_pInputManager->getMouseCoordsInternal() - local;
+    } else if (m_sTouchData.touchFocusLS) {
+        local = g_pInputManager->getMouseCoordsInternal() - Vector2D(m_sTouchData.touchFocusLS->geometry.x, m_sTouchData.touchFocusLS->geometry.y) - g_pCompositor->m_pLastMonitor->vecPosition;
 
-        wlr_seat_touch_notify_down(g_pCompositor->m_sSeat.seat, g_pCompositor->m_pLastFocus, e->time_msec, e->touch_id, local.x, local.y);
-
-        m_sTouchData.touchFocusWindow = g_pCompositor->m_pLastWindow;
+        m_sTouchData.touchSurfaceOrigin = g_pInputManager->getMouseCoordsInternal() - local;
+    } else {
+        return; // oops, nothing found.
     }
+
+    wlr_seat_touch_notify_down(g_pCompositor->m_sSeat.seat, m_sTouchData.touchFocusSurface, e->time_msec, e->touch_id, local.x, local.y);
+
+    wlr_idle_notify_activity(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat);
 }
 
 void CInputManager::onTouchUp(wlr_touch_up_event* e){
-    if (m_sTouchData.touchFocusWindow) {
+    if (m_sTouchData.touchFocusSurface) {
         wlr_seat_touch_notify_up(g_pCompositor->m_sSeat.seat, e->time_msec, e->touch_id);
     }
 }
 
 void CInputManager::onTouchMove(wlr_touch_motion_event* e){
-    if (g_pCompositor->windowValidMapped(m_sTouchData.touchFocusWindow)) {
+    if (m_sTouchData.touchFocusWindow && g_pCompositor->windowValidMapped(m_sTouchData.touchFocusWindow)) {
         const auto PMONITOR = g_pCompositor->getMonitorFromID(m_sTouchData.touchFocusWindow->m_iMonitorID);
 
         wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, PMONITOR->vecPosition.x + e->x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e->y * PMONITOR->vecSize.y);
 
         const auto local = g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchSurfaceOrigin;
 
+        wlr_seat_touch_notify_motion(g_pCompositor->m_sSeat.seat, e->time_msec, e->touch_id, local.x, local.y);
+    } else if (m_sTouchData.touchFocusLS) {
+        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_sTouchData.touchFocusLS->monitorID);
+
+        wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, PMONITOR->vecPosition.x + e->x * PMONITOR->vecSize.x, PMONITOR->vecPosition.y + e->y * PMONITOR->vecSize.y);
+
+        const auto local = g_pInputManager->getMouseCoordsInternal() - m_sTouchData.touchSurfaceOrigin;
+
         wlr_seat_touch_notify_motion(g_pCompositor->m_sSeat.seat, e->time_msec, e->touch_id, local.x, local.y);
     }
 }

src/meson.build

@@ -1,4 +1,4 @@
-globber = run_command('find', '-name', '*.cpp', check: true)
+globber = run_command('find', '.', '-name', '*.cpp', check: true)
 src = globber.stdout().strip().split('\n')
 
 executable('Hyprland', src,
@@ -18,7 +18,7 @@ executable('Hyprland', src,
     xcb_dep,
 
     dependency('pixman-1'),
-    dependency('GL'),
+    dependency('gl', 'opengl'),
     dependency('threads')
   ],
   install : true

src/protocols/ToplevelExport.cpp

@@ -0,0 +1,384 @@
+#include "ToplevelExport.hpp"
+#include "../Compositor.hpp"
+#include <drm_fourcc.h>
+
+#include <algorithm>
+
+#include "ToplevelExportWlrFuncs.hpp"
+
+#define TOPLEVEL_EXPORT_VERSION 1
+
+static void bindManagerInt(wl_client* client, void* data, uint32_t version, uint32_t id) {
+    g_pProtocolManager->m_pToplevelExportProtocolManager->bindManager(client, data, version, id);
+}
+
+static void handleDisplayDestroy(struct wl_listener* listener, void* data) {
+    g_pProtocolManager->m_pToplevelExportProtocolManager->displayDestroy();
+}
+
+void CToplevelExportProtocolManager::displayDestroy() {
+    wl_global_destroy(m_pGlobal);
+}
+
+CToplevelExportProtocolManager::CToplevelExportProtocolManager() {
+
+#ifndef GLES32
+    Debug::log(WARN, "Toplevel sharing is not supported on LEGACY_RENDERER!");
+    return;
+#endif
+
+    m_pGlobal = wl_global_create(g_pCompositor->m_sWLDisplay, &hyprland_toplevel_export_manager_v1_interface,
+                                 TOPLEVEL_EXPORT_VERSION, this, bindManagerInt);
+
+    if (!m_pGlobal) {
+        Debug::log(ERR, "ToplevelExportManager could not start! Sharing windows will not work!");
+        return;
+    }
+
+    m_liDisplayDestroy.notify = handleDisplayDestroy;
+    wl_display_add_destroy_listener(g_pCompositor->m_sWLDisplay, &m_liDisplayDestroy);
+
+    Debug::log(LOG, "ToplevelExportManager started successfully!");
+}
+
+void handleCaptureToplevel(wl_client* client, wl_resource* resource, uint32_t frame, int32_t overlay_cursor, uint32_t handle) {
+    g_pProtocolManager->m_pToplevelExportProtocolManager->captureToplevel(client, resource, frame, overlay_cursor, handle);
+}
+
+void handleDestroy(wl_client* client, wl_resource* resource) {
+    wl_resource_destroy(resource);
+}
+
+void handleCopyFrame(wl_client* client, wl_resource* resource, wl_resource* buffer, int32_t ignore_damage) {
+    g_pProtocolManager->m_pToplevelExportProtocolManager->copyFrame(client, resource, buffer, ignore_damage);
+}
+
+void handleDestroyFrame(wl_client* client, wl_resource* resource) {
+    wl_resource_destroy(resource);
+}
+
+static const struct hyprland_toplevel_export_manager_v1_interface toplevelExportManagerImpl = {
+    .capture_toplevel = handleCaptureToplevel,
+    .destroy = handleDestroy
+};
+
+static const struct hyprland_toplevel_export_frame_v1_interface toplevelFrameImpl = {
+    .copy = handleCopyFrame,
+    .destroy = handleDestroyFrame
+};
+
+SToplevelClient* clientFromResource(wl_resource* resource) {
+    ASSERT(wl_resource_instance_of(resource, &hyprland_toplevel_export_manager_v1_interface, &toplevelExportManagerImpl));
+    return (SToplevelClient*)wl_resource_get_user_data(resource);
+}
+
+SToplevelFrame* frameFromResource(wl_resource* resource) {
+    ASSERT(wl_resource_instance_of(resource, &hyprland_toplevel_export_frame_v1_interface, &toplevelFrameImpl));
+    return (SToplevelFrame*)wl_resource_get_user_data(resource);
+}
+
+void CToplevelExportProtocolManager::removeClient(SToplevelClient* client, bool force) {
+    if (!force) {
+        if (!client || client->ref <= 0)
+            return;
+
+        if (--client->ref != 0)
+            return;
+    }
+
+    m_lClients.remove(*client); // TODO: this doesn't get cleaned up after sharing app exits???
+}
+
+void handleManagerResourceDestroy(wl_resource* resource) {
+    const auto PCLIENT = clientFromResource(resource);
+
+    g_pProtocolManager->m_pToplevelExportProtocolManager->removeClient(PCLIENT);
+}
+
+void CToplevelExportProtocolManager::bindManager(wl_client* client, void* data, uint32_t version, uint32_t id) {
+    const auto PCLIENT = &m_lClients.emplace_back();
+
+    PCLIENT->resource = wl_resource_create(client, &hyprland_toplevel_export_manager_v1_interface,
+                                            version, id);
+
+    if (!PCLIENT->resource) {
+        Debug::log(ERR, "ToplevelExportManager could not bind! (out of memory?)");
+        m_lClients.remove(*PCLIENT);
+        wl_client_post_no_memory(client);
+        return;
+    }
+
+    PCLIENT->ref = 1;
+
+    wl_resource_set_implementation(PCLIENT->resource, &toplevelExportManagerImpl, PCLIENT, handleManagerResourceDestroy);
+
+    Debug::log(LOG, "ToplevelExportManager bound successfully!");
+}
+
+void handleFrameResourceDestroy(wl_resource* resource) {
+    const auto PFRAME = frameFromResource(resource);
+
+    g_pProtocolManager->m_pToplevelExportProtocolManager->removeFrame(PFRAME);
+}
+
+void CToplevelExportProtocolManager::removeFrame(SToplevelFrame* frame, bool force) {
+    if (!frame)
+        return;
+
+    std::erase_if(m_vFramesAwaitingWrite, [&] (const auto& other) { return other == frame; });
+
+    wl_resource_set_user_data(frame->resource, nullptr);
+    wlr_buffer_unlock(frame->buffer);
+    removeClient(frame->client, force);
+    m_lFrames.remove(*frame);
+}
+
+void CToplevelExportProtocolManager::captureToplevel(wl_client* client, wl_resource* resource, uint32_t frame, int32_t overlay_cursor, uint32_t handle) {
+    const auto PCLIENT = clientFromResource(resource);
+
+    const auto PWINDOW = g_pCompositor->getWindowFromHandle(handle);
+
+    // create a frame
+    const auto PFRAME = &m_lFrames.emplace_back();
+    PFRAME->overlayCursor = !!overlay_cursor;
+    PFRAME->resource = wl_resource_create(client, &hyprland_toplevel_export_frame_v1_interface, wl_resource_get_version(resource), frame);
+    PFRAME->pWindow = PWINDOW;
+
+    if (!PWINDOW) {
+        Debug::log(ERR, "Client requested sharing of window handle %x which does not exist!", handle);
+        hyprland_toplevel_export_frame_v1_send_failed(PFRAME->resource);
+        removeFrame(PFRAME);
+        return;
+    }
+
+    if (!PWINDOW->m_bIsMapped || PWINDOW->isHidden()) {
+        Debug::log(ERR, "Client requested sharing of window handle %x which is not shareable!", handle);
+        hyprland_toplevel_export_frame_v1_send_failed(PFRAME->resource);
+        removeFrame(PFRAME);
+        return;
+    }
+
+    if (!PFRAME->resource) {
+        Debug::log(ERR, "Couldn't alloc frame for sharing! (no memory)");
+        m_lFrames.remove(*PFRAME);
+        wl_client_post_no_memory(client);
+        return;
+    }
+
+    wl_resource_set_implementation(PFRAME->resource, &toplevelFrameImpl, PFRAME, handleFrameResourceDestroy);
+
+    PFRAME->client = PCLIENT;
+    PCLIENT->ref++;
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+
+    PFRAME->shmFormat = wlr_output_preferred_read_format(PMONITOR->output);
+    if (PFRAME->shmFormat == DRM_FORMAT_INVALID) {
+        Debug::log(ERR, "No format supported by renderer in capture toplevel");
+        hyprland_toplevel_export_frame_v1_send_failed(resource);
+        removeFrame(PFRAME);
+        return;
+    }
+
+    const auto PSHMINFO = drm_get_pixel_format_info(PFRAME->shmFormat);
+    if (!PSHMINFO) {
+        Debug::log(ERR, "No pixel format supported by renderer in capture toplevel");
+        hyprland_toplevel_export_frame_v1_send_failed(resource);
+        removeFrame(PFRAME);
+        return;
+    }
+
+    if (PMONITOR->output->allocator && (PMONITOR->output->allocator->buffer_caps & WLR_BUFFER_CAP_DMABUF)) {
+        PFRAME->dmabufFormat = PMONITOR->output->render_format;
+    } else {
+        PFRAME->dmabufFormat = DRM_FORMAT_INVALID;
+    }
+
+    PFRAME->box = {0, 0, (int)PWINDOW->m_vRealSize.vec().x, (int)PWINDOW->m_vRealSize.vec().y};
+    int ow, oh;
+    wlr_output_effective_resolution(PMONITOR->output, &ow, &oh);
+    wlr_box_transform(&PFRAME->box, &PFRAME->box, PMONITOR->transform, ow, oh);
+
+    PFRAME->shmStride = (PSHMINFO->bpp / 8) * PFRAME->box.width;
+
+    hyprland_toplevel_export_frame_v1_send_buffer(PFRAME->resource, convert_drm_format_to_wl_shm(PFRAME->shmFormat), PFRAME->box.width, PFRAME->box.height, PFRAME->shmStride);
+}
+
+void CToplevelExportProtocolManager::copyFrame(wl_client* client, wl_resource* resource, wl_resource* buffer, int32_t ignore_damage) {
+    const auto PFRAME = frameFromResource(resource);
+
+    if (!PFRAME) {
+        Debug::log(ERR, "No frame in copyFrame??");
+        return;
+    }
+
+    if (!PFRAME->pWindow->m_bIsMapped || PFRAME->pWindow->isHidden()) {
+        Debug::log(ERR, "Client requested sharing of window handle %x which is not shareable (2)!", PFRAME->pWindow);
+        hyprland_toplevel_export_frame_v1_send_failed(PFRAME->resource);
+        return;
+    }
+
+    const auto PBUFFER = wlr_buffer_from_resource(buffer);
+    if (!PBUFFER) {
+        wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer");
+        return;
+    }
+
+    if (PBUFFER->width != PFRAME->box.width || PBUFFER->height != PFRAME->box.height) {
+        wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer dimensions");
+        return;
+    }
+
+    if (PFRAME->buffer) {
+        wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_ALREADY_USED, "frame already used");
+        return;
+    }
+
+    wlr_dmabuf_attributes dmabufAttrs;
+    void* wlrBufferAccessData;
+    uint32_t wlrBufferAccessFormat;
+    size_t wlrBufferAccessStride;
+    if (wlr_buffer_get_dmabuf(PBUFFER, &dmabufAttrs)) {
+        PFRAME->bufferCap = WLR_BUFFER_CAP_DMABUF;
+
+        if (dmabufAttrs.format != PFRAME->dmabufFormat) {
+            wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer format");
+            return;
+        }
+    } else if (wlr_buffer_begin_data_ptr_access(PBUFFER, WLR_BUFFER_DATA_PTR_ACCESS_WRITE, &wlrBufferAccessData, &wlrBufferAccessFormat, &wlrBufferAccessStride)) {
+        wlr_buffer_end_data_ptr_access(PBUFFER);
+
+        if (wlrBufferAccessFormat != PFRAME->shmFormat) {
+            wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer format");
+            return;
+        } else if ((int)wlrBufferAccessStride != PFRAME->shmStride) {
+            wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer stride");
+            return;
+        }
+    } else {
+        wl_resource_post_error(PFRAME->resource, HYPRLAND_TOPLEVEL_EXPORT_FRAME_V1_ERROR_INVALID_BUFFER, "invalid buffer type");
+        return;
+    }
+
+    PFRAME->buffer = PBUFFER;
+
+    m_vFramesAwaitingWrite.emplace_back(PFRAME);
+}
+
+void CToplevelExportProtocolManager::onMonitorRender(CMonitor* pMonitor) {
+
+    if (m_vFramesAwaitingWrite.empty())
+        return; // nothing to share
+
+    std::vector<SToplevelFrame*> framesToRemove;
+    
+    // share frame if correct output
+    for (auto& f : m_vFramesAwaitingWrite) {
+        if (!f->pWindow) {
+            framesToRemove.push_back(f);
+            continue;
+        }
+
+        wlr_box geometry = { f->pWindow->m_vRealPosition.vec().x, f->pWindow->m_vRealPosition.vec().y,
+                             f->pWindow->m_vRealSize.vec().x, f->pWindow->m_vRealSize.vec().y };
+
+        if (!wlr_output_layout_intersects(g_pCompositor->m_sWLROutputLayout, pMonitor->output, &geometry))
+            continue;
+        
+        shareFrame(f);
+
+        framesToRemove.push_back(f);
+    }
+
+    for (auto& f : framesToRemove) {
+        removeFrame(f);
+    }
+}
+
+void CToplevelExportProtocolManager::shareFrame(SToplevelFrame* frame) {
+    if (!frame->buffer) {
+        return;
+    }
+
+    // TODO: damage
+
+    timespec now;
+    clock_gettime(CLOCK_MONOTONIC, &now);
+
+    uint32_t flags = 0;
+    if (frame->bufferCap == WLR_BUFFER_CAP_DMABUF) {
+        if (!copyFrameDmabuf(frame)) {
+            hyprland_toplevel_export_frame_v1_send_failed(frame->resource);
+            return;
+        }
+    } else {
+        if (!copyFrameShm(frame, &now)) {
+            hyprland_toplevel_export_frame_v1_send_failed(frame->resource);
+            return;
+        }
+    }
+
+    hyprland_toplevel_export_frame_v1_send_flags(frame->resource, flags);
+    // todo: send damage
+    uint32_t tvSecHi = (sizeof(now.tv_sec) > 4) ? now.tv_sec >> 32 : 0;
+    uint32_t tvSecLo = now.tv_sec & 0xFFFFFFFF;
+    hyprland_toplevel_export_frame_v1_send_ready(frame->resource, tvSecHi, tvSecLo, now.tv_nsec);
+}
+
+bool CToplevelExportProtocolManager::copyFrameShm(SToplevelFrame* frame, timespec* now) {
+    void* data;
+    uint32_t format;
+    size_t stride;
+    if (!wlr_buffer_begin_data_ptr_access(frame->buffer, WLR_BUFFER_DATA_PTR_ACCESS_WRITE, &data, &format, &stride))
+        return false;
+
+    // render the client
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(frame->pWindow->m_iMonitorID);
+    pixman_region32_t fakeDamage;
+    pixman_region32_init_rect(&fakeDamage, 0, 0, PMONITOR->vecPixelSize.x * 10, PMONITOR->vecPixelSize.y * 10);
+
+    g_pHyprOpenGL->begin(PMONITOR, &fakeDamage, true);
+    g_pHyprOpenGL->clear(CColor(0, 0, 0, 255));
+
+    // render client at 0,0
+    g_pHyprRenderer->m_bBlockSurfaceFeedback = g_pHyprRenderer->shouldRenderWindow(frame->pWindow); // block the feedback to avoid spamming the surface if it's visible
+    g_pHyprRenderer->renderWindow(frame->pWindow, PMONITOR, now, false, RENDER_PASS_ALL, true, true);
+    g_pHyprRenderer->m_bBlockSurfaceFeedback = false;
+
+    // copy pixels
+    const auto PFORMAT = get_gles2_format_from_drm(format);
+    if (!PFORMAT) {
+        Debug::log(ERR, "Cannot read pixels, unsupported format %x", PFORMAT);
+        g_pHyprOpenGL->end();
+        pixman_region32_fini(&fakeDamage);
+        wlr_buffer_end_data_ptr_access(frame->buffer);
+        return false;
+    }
+
+    glBindFramebuffer(GL_FRAMEBUFFER, g_pHyprOpenGL->m_RenderData.pCurrentMonData->primaryFB.m_iFb);
+
+    glFinish(); // flush
+
+    glReadPixels(0, 0, frame->box.width, frame->box.height, PFORMAT->gl_format, PFORMAT->gl_type, data);
+
+    g_pHyprOpenGL->end();
+
+    pixman_region32_fini(&fakeDamage);
+
+    wlr_buffer_end_data_ptr_access(frame->buffer);
+
+    return true;
+}
+
+bool CToplevelExportProtocolManager::copyFrameDmabuf(SToplevelFrame* frame) {
+    // todo
+    Debug::log(ERR, "DMABUF copying not impl'd!");
+    return false;
+}
+
+void CToplevelExportProtocolManager::onWindowUnmap(CWindow* pWindow) {
+    for (auto& f : m_lFrames) {
+        if (f.pWindow == pWindow)
+            f.pWindow = nullptr;
+    }
+}

src/protocols/ToplevelExport.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "../defines.hpp"
+#include "hyprland-toplevel-export-v1-protocol.h"
+
+#include <list>
+#include <vector>
+
+class CMonitor;
+class CWindow;
+
+struct SToplevelClient {
+    int ref = 0;
+    wl_resource* resource = nullptr;
+
+    bool operator==(const SToplevelClient& other) {
+        return resource == other.resource;
+    }
+};
+
+struct SToplevelFrame {
+    wl_resource* resource = nullptr;
+    SToplevelClient* client = nullptr;
+
+    uint32_t    shmFormat = 0;
+    uint32_t    dmabufFormat = 0;
+    wlr_box     box = { 0 };
+    int         shmStride = 0;
+
+    bool        overlayCursor = false;
+
+    wlr_buffer_cap bufferCap = WLR_BUFFER_CAP_SHM;
+
+    wlr_buffer* buffer = nullptr;
+
+    CWindow*    pWindow = nullptr;
+
+    bool operator==(const SToplevelFrame& other) { 
+        return resource == other.resource && client == other.client;
+    }
+};
+
+class CToplevelExportProtocolManager {
+public:
+    CToplevelExportProtocolManager();
+
+    void        bindManager(wl_client* client, void* data, uint32_t version, uint32_t id);
+    void        captureToplevel(wl_client* client, wl_resource* resource, uint32_t frame, int32_t overlay_cursor, uint32_t handle);
+    void        removeClient(SToplevelClient* client, bool force = false);
+    void        removeFrame(SToplevelFrame* frame, bool force = false);
+    void        copyFrame(wl_client* client, wl_resource* resource, wl_resource* buffer, int32_t ignore_damage);
+
+    void        onMonitorRender(CMonitor* pMonitor);
+    void        displayDestroy();
+    void        onWindowUnmap(CWindow* pWindow);
+
+private:
+    wl_global*                  m_pGlobal = nullptr;
+    std::list<SToplevelFrame>   m_lFrames;
+    std::list<SToplevelClient>  m_lClients;
+
+    wl_listener                 m_liDisplayDestroy;
+
+    std::vector<SToplevelFrame*> m_vFramesAwaitingWrite;
+
+    void        shareFrame(SToplevelFrame* frame);
+    bool        copyFrameDmabuf(SToplevelFrame* frame);
+    bool        copyFrameShm(SToplevelFrame* frame, timespec* now);
+};

src/protocols/ToplevelExportWlrFuncs.hpp

@@ -0,0 +1,312 @@
+#include <GLES2/gl2ext.h>
+
+struct wlr_pixel_format_info {
+    uint32_t drm_format;
+
+    /* Equivalent of the format if it has an alpha channel,
+	 * DRM_FORMAT_INVALID (0) if NA
+	 */
+    uint32_t opaque_substitute;
+
+    /* Bits per pixels */
+    uint32_t bpp;
+
+    /* True if the format has an alpha channel */
+    bool has_alpha;
+};
+
+static const struct wlr_pixel_format_info pixel_format_info[] = {
+    {
+        .drm_format = DRM_FORMAT_XRGB8888,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ARGB8888,
+        .opaque_substitute = DRM_FORMAT_XRGB8888,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR8888,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR8888,
+        .opaque_substitute = DRM_FORMAT_XBGR8888,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBX8888,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBA8888,
+        .opaque_substitute = DRM_FORMAT_RGBX8888,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_BGRX8888,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_BGRA8888,
+        .opaque_substitute = DRM_FORMAT_BGRX8888,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_BGR888,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 24,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBX4444,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 16,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBA4444,
+        .opaque_substitute = DRM_FORMAT_RGBX4444,
+        .bpp = 16,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBX5551,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 16,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBA5551,
+        .opaque_substitute = DRM_FORMAT_RGBX5551,
+        .bpp = 16,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGB565,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 16,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_BGR565,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 16,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_XRGB2101010,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ARGB2101010,
+        .opaque_substitute = DRM_FORMAT_XRGB2101010,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR2101010,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 32,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR2101010,
+        .opaque_substitute = DRM_FORMAT_XBGR2101010,
+        .bpp = 32,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR16161616F,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 64,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR16161616F,
+        .opaque_substitute = DRM_FORMAT_XBGR16161616F,
+        .bpp = 64,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR16161616,
+        .opaque_substitute = DRM_FORMAT_INVALID,
+        .bpp = 64,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR16161616,
+        .opaque_substitute = DRM_FORMAT_XBGR16161616,
+        .bpp = 64,
+        .has_alpha = true,
+    },
+};
+
+static const size_t pixel_format_info_size =
+    sizeof(pixel_format_info) / sizeof(pixel_format_info[0]);
+
+const struct wlr_pixel_format_info* drm_get_pixel_format_info(uint32_t fmt) {
+    for (size_t i = 0; i < pixel_format_info_size; ++i) {
+        if (pixel_format_info[i].drm_format == fmt) {
+            return &pixel_format_info[i];
+        }
+    }
+
+    return NULL;
+}
+
+uint32_t convert_wl_shm_format_to_drm(enum wl_shm_format fmt) {
+    switch (fmt) {
+        case WL_SHM_FORMAT_XRGB8888:
+            return DRM_FORMAT_XRGB8888;
+        case WL_SHM_FORMAT_ARGB8888:
+            return DRM_FORMAT_ARGB8888;
+        default:
+            return (uint32_t)fmt;
+    }
+}
+
+enum wl_shm_format convert_drm_format_to_wl_shm(uint32_t fmt) {
+    switch (fmt) {
+        case DRM_FORMAT_XRGB8888:
+            return WL_SHM_FORMAT_XRGB8888;
+        case DRM_FORMAT_ARGB8888:
+            return WL_SHM_FORMAT_ARGB8888;
+        default:
+            return (enum wl_shm_format)fmt;
+    }
+}
+
+struct wlr_gles2_pixel_format {
+    uint32_t drm_format;
+    // optional field, if empty then internalformat = format
+    GLint gl_internalformat;
+    GLint gl_format, gl_type;
+    bool has_alpha;
+};
+
+static const struct wlr_gles2_pixel_format formats[] = {
+    {
+        .drm_format = DRM_FORMAT_ARGB8888,
+        .gl_format = GL_BGRA_EXT,
+        .gl_type = GL_UNSIGNED_BYTE,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XRGB8888,
+        .gl_format = GL_BGRA_EXT,
+        .gl_type = GL_UNSIGNED_BYTE,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR8888,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_BYTE,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR8888,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_BYTE,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_BGR888,
+        .gl_format = GL_RGB,
+        .gl_type = GL_UNSIGNED_BYTE,
+        .has_alpha = false,
+    },
+#if WLR_LITTLE_ENDIAN
+    {
+        .drm_format = DRM_FORMAT_RGBX4444,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT_4_4_4_4,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBA4444,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT_4_4_4_4,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBX5551,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT_5_5_5_1,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGBA5551,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT_5_5_5_1,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_RGB565,
+        .gl_format = GL_RGB,
+        .gl_type = GL_UNSIGNED_SHORT_5_6_5,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR2101010,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_INT_2_10_10_10_REV_EXT,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR2101010,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_INT_2_10_10_10_REV_EXT,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR16161616F,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_HALF_FLOAT_OES,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR16161616F,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_HALF_FLOAT_OES,
+        .has_alpha = true,
+    },
+    {
+        .drm_format = DRM_FORMAT_XBGR16161616,
+        .gl_internalformat = GL_RGBA16_EXT,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT,
+        .has_alpha = false,
+    },
+    {
+        .drm_format = DRM_FORMAT_ABGR16161616,
+        .gl_internalformat = GL_RGBA16_EXT,
+        .gl_format = GL_RGBA,
+        .gl_type = GL_UNSIGNED_SHORT,
+        .has_alpha = true,
+    },
+#endif
+};
+
+const struct wlr_gles2_pixel_format* get_gles2_format_from_drm(uint32_t fmt) {
+    for (size_t i = 0; i < sizeof(formats) / sizeof(*formats); ++i) {
+        if (formats[i].drm_format == fmt) {
+            return &formats[i];
+        }
+    }
+    return NULL;
+}

src/render/Framebuffer.cpp

@@ -27,7 +27,6 @@ bool CFramebuffer::alloc(int w, int h) {
         glBindFramebuffer(GL_FRAMEBUFFER, m_iFb);
         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_cTex.m_iTexID, 0);
 
-
         // TODO: Allow this with gles2
         #ifndef GLES2
         if (m_pStencilTex) {
@@ -74,8 +73,13 @@ void CFramebuffer::release() {
 
     m_cTex.m_iTexID = 0;
     m_iFb = -1;
+    m_Size = Vector2D();
 }
 
 CFramebuffer::~CFramebuffer() {
     release();
 }
+
+bool CFramebuffer::isAllocated() {
+    return m_iFb != (GLuint)-1;
+}

src/render/Framebuffer.hpp

@@ -12,6 +12,7 @@ public:
     void bind();
     void release();
     void reset();
+    bool isAllocated();
 
     Vector2D        m_Position;
     Vector2D        m_Size;

src/render/OpenGL.cpp

@@ -25,23 +25,27 @@ CHyprOpenGLImpl::CHyprOpenGLImpl() {
     Debug::log(WARN, "!RENDERER: Using the legacy GLES2 renderer!");
     #endif
 
-    // End shaders
-
     pixman_region32_init(&m_rOriginalDamageRegion);
 
-    // End
-
     RASSERT(eglMakeCurrent(wlr_egl_get_display(g_pCompositor->m_sWLREGL), EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT), "Couldn't unset current EGL!");
-
-    // Done!
 }
 
-GLuint CHyprOpenGLImpl::createProgram(const std::string& vert, const std::string& frag) {
-    auto vertCompiled = compileShader(GL_VERTEX_SHADER, vert);
-    RASSERT(vertCompiled, "Compiling shader failed. VERTEX NULL! Shader source:\n\n%s", vert.c_str());
+GLuint CHyprOpenGLImpl::createProgram(const std::string& vert, const std::string& frag, bool dynamic) {
+    auto vertCompiled = compileShader(GL_VERTEX_SHADER, vert, dynamic);
+    if (dynamic) {
+        if (vertCompiled == 0)
+            return 0;
+    } else {
+        RASSERT(vertCompiled, "Compiling shader failed. VERTEX NULL! Shader source:\n\n%s", vert.c_str());
+    }
 
-    auto fragCompiled = compileShader(GL_FRAGMENT_SHADER, frag);
-    RASSERT(fragCompiled, "Compiling shader failed. FRAGMENT NULL! Shader source:\n\n%s", frag.c_str());
+    auto fragCompiled = compileShader(GL_FRAGMENT_SHADER, frag, dynamic);
+    if (dynamic) {
+        if (fragCompiled == 0)
+            return 0;
+    } else {
+        RASSERT(fragCompiled, "Compiling shader failed. FRAGMENT NULL! Shader source:\n\n%s", frag.c_str());
+    }
 
     auto prog = glCreateProgram();
     glAttachShader(prog, vertCompiled);
@@ -55,12 +59,17 @@ GLuint CHyprOpenGLImpl::createProgram(const std::string& vert, const std::string
 
     GLint ok;
     glGetProgramiv(prog, GL_LINK_STATUS, &ok);
-    RASSERT(ok != GL_FALSE, "createProgram() failed! GL_LINK_STATUS not OK!");
+    if (dynamic) {
+        if (ok == GL_FALSE)
+            return 0;
+    } else {
+        RASSERT(ok != GL_FALSE, "createProgram() failed! GL_LINK_STATUS not OK!");
+    }
 
     return prog;
 }
 
-GLuint CHyprOpenGLImpl::compileShader(const GLuint& type, std::string src) {
+GLuint CHyprOpenGLImpl::compileShader(const GLuint& type, std::string src, bool dynamic) {
     auto shader = glCreateShader(type);
 
     auto shaderSource = src.c_str();
@@ -70,7 +79,12 @@ GLuint CHyprOpenGLImpl::compileShader(const GLuint& type, std::string src) {
 
     GLint ok;
     glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
-    RASSERT(ok != GL_FALSE, "compileShader() failed! GL_COMPILE_STATUS not OK!");
+    if (dynamic) {
+        if (ok == GL_FALSE)
+            return 0;
+    } else {
+        RASSERT(ok != GL_FALSE, "compileShader() failed! GL_COMPILE_STATUS not OK!");
+    }
 
     return shader;
 }
@@ -118,6 +132,11 @@ void CHyprOpenGLImpl::begin(CMonitor* pMonitor, pixman_region32_t* pDamage, bool
     m_RenderData.pDamage = pDamage;
 
     m_bFakeFrame = fake;
+
+    if (m_bReloadScreenShader) {
+        m_bReloadScreenShader = false;
+        applyScreenShader(g_pConfigManager->getString("decoration:screen_shader"));
+    }
 }
 
 void CHyprOpenGLImpl::end() {
@@ -134,9 +153,11 @@ void CHyprOpenGLImpl::end() {
         clear(CColor(11, 11, 11, 255));
 
         m_bEndFrame = true;
+        m_bApplyFinalShader = true;
 
         renderTexture(m_RenderData.pCurrentMonData->primaryFB.m_cTex, &monbox, 255.f, 0);
 
+        m_bApplyFinalShader = false;
         m_bEndFrame = false;
     }
 
@@ -243,15 +264,48 @@ void CHyprOpenGLImpl::initShaders() {
     m_RenderData.pCurrentMonData->m_shBORDER1.topLeft = glGetUniformLocation(prog, "topLeft");
     m_RenderData.pCurrentMonData->m_shBORDER1.bottomRight = glGetUniformLocation(prog, "bottomRight");
     m_RenderData.pCurrentMonData->m_shBORDER1.fullSize = glGetUniformLocation(prog, "fullSize");
+    m_RenderData.pCurrentMonData->m_shBORDER1.fullSizeUntransformed = glGetUniformLocation(prog, "fullSizeUntransformed");
     m_RenderData.pCurrentMonData->m_shBORDER1.radius = glGetUniformLocation(prog, "radius");
     m_RenderData.pCurrentMonData->m_shBORDER1.primitiveMultisample = glGetUniformLocation(prog, "primitiveMultisample");
-    m_RenderData.pCurrentMonData->m_shBORDER1.color = glGetUniformLocation(prog, "color");
+    m_RenderData.pCurrentMonData->m_shBORDER1.gradient = glGetUniformLocation(prog, "gradient");
+    m_RenderData.pCurrentMonData->m_shBORDER1.gradientLength = glGetUniformLocation(prog, "gradientLength");
+    m_RenderData.pCurrentMonData->m_shBORDER1.angle = glGetUniformLocation(prog, "angle");
+    m_RenderData.pCurrentMonData->m_shBORDER1.alpha = glGetUniformLocation(prog, "alpha");
 
     m_RenderData.pCurrentMonData->m_bShadersInitialized = true;
 
     Debug::log(LOG, "Shaders initialized successfully.");
 }
 
+void CHyprOpenGLImpl::applyScreenShader(const std::string& path) {
+
+    m_sFinalScreenShader.destroy();
+
+    if (path == "" || path == STRVAL_EMPTY)
+        return;
+
+    std::ifstream infile(absolutePath(path, std::string(getenv("HOME")) + "/.config/hypr"));
+
+    if (!infile.good()) {
+        g_pConfigManager->addParseError("Screen shader parser: Screen shader path not found");
+        return;
+    }
+
+    std::string fragmentShader((std::istreambuf_iterator<char>(infile)), (std::istreambuf_iterator<char>()));
+
+    m_sFinalScreenShader.program = createProgram(TEXVERTSRC, fragmentShader, true);
+    
+    if (!m_sFinalScreenShader.program) {
+        g_pConfigManager->addParseError("Screen shader parser: Screen shader parse failed");
+        return;
+    }
+
+    m_sFinalScreenShader.proj = glGetUniformLocation(m_sFinalScreenShader.program, "proj");
+    m_sFinalScreenShader.tex = glGetUniformLocation(m_sFinalScreenShader.program, "tex");
+    m_sFinalScreenShader.texAttrib = glGetAttribLocation(m_sFinalScreenShader.program, "texcoord");
+    m_sFinalScreenShader.posAttrib = glGetAttribLocation(m_sFinalScreenShader.program, "pos");
+}
+
 void CHyprOpenGLImpl::clear(const CColor& color) {
     RASSERT(m_RenderData.pMonitor, "Tried to render without begin()!");
 
@@ -323,16 +377,18 @@ void CHyprOpenGLImpl::renderRectWithDamage(wlr_box* box, const CColor& col, pixm
 
     float glMatrix[9];
     wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
-    wlr_matrix_multiply(glMatrix, matrixFlip180, glMatrix);
-
-    wlr_matrix_transpose(glMatrix, glMatrix);
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     glUseProgram(m_RenderData.pCurrentMonData->m_shQUAD.program);
 
+#ifndef GLES2
+    glUniformMatrix3fv(m_RenderData.pCurrentMonData->m_shQUAD.proj, 1, GL_TRUE, glMatrix);
+#else
+    wlr_matrix_transpose(glMatrix, glMatrix);
     glUniformMatrix3fv(m_RenderData.pCurrentMonData->m_shQUAD.proj, 1, GL_FALSE, glMatrix);
+#endif
     glUniform4f(m_RenderData.pCurrentMonData->m_shQUAD.color, col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f);
 
     wlr_box transformedBox;
@@ -414,27 +470,31 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
 
     float glMatrix[9];
     wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
-    wlr_matrix_multiply(glMatrix, matrixFlip180, glMatrix);
-
-    wlr_matrix_transpose(glMatrix, glMatrix);
 
     CShader* shader = nullptr;
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
-    switch (tex.m_iType) {
-        case TEXTURE_RGBA:
-            shader = &m_RenderData.pCurrentMonData->m_shRGBA;
-            break;
-        case TEXTURE_RGBX:
-            shader = &m_RenderData.pCurrentMonData->m_shRGBX;
-            break;
-        case TEXTURE_EXTERNAL:
-            shader = &m_RenderData.pCurrentMonData->m_shEXT;
-            break;
-        default:
-            RASSERT(false, "tex.m_iTarget unsupported!");
+    bool usingFinalShader = false;
+
+    if (m_bApplyFinalShader && m_sFinalScreenShader.program) {
+        shader = &m_sFinalScreenShader;
+        usingFinalShader = true;
+    } else {
+        switch (tex.m_iType) {
+            case TEXTURE_RGBA:
+                shader = &m_RenderData.pCurrentMonData->m_shRGBA;
+                break;
+            case TEXTURE_RGBX:
+                shader = &m_RenderData.pCurrentMonData->m_shRGBX;
+                break;
+            case TEXTURE_EXTERNAL:
+                shader = &m_RenderData.pCurrentMonData->m_shEXT;
+                break;
+            default:
+                RASSERT(false, "tex.m_iTarget unsupported!");
+        }
     }
 
     glActiveTexture(GL_TEXTURE0);
@@ -444,10 +504,17 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
 
     glUseProgram(shader->program);
 
+#ifndef GLES2
+    glUniformMatrix3fv(shader->proj, 1, GL_TRUE, glMatrix);
+#else
+    wlr_matrix_transpose(glMatrix, glMatrix);
     glUniformMatrix3fv(shader->proj, 1, GL_FALSE, glMatrix);
+#endif
     glUniform1i(shader->tex, 0);
-    glUniform1f(shader->alpha, alpha / 255.f);
-    glUniform1i(shader->discardOpaque, (int)discardOpaque);
+    if (!usingFinalShader) {
+        glUniform1f(shader->alpha, alpha / 255.f);
+        glUniform1i(shader->discardOpaque, (int)discardOpaque);
+    }
 
     wlr_box transformedBox;
     wlr_box_transform(&transformedBox, pBox, wlr_output_transform_invert(m_RenderData.pMonitor->transform),
@@ -457,18 +524,20 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
     const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
     static auto *const PMULTISAMPLEEDGES = &g_pConfigManager->getConfigValuePtr("decoration:multisample_edges")->intValue;
 
-    // Rounded corners
-    glUniform2f(shader->topLeft, TOPLEFT.x, TOPLEFT.y);
-    glUniform2f(shader->fullSize, FULLSIZE.x ,FULLSIZE.y);
-    glUniform1f(shader->radius, round);
-    glUniform1i(shader->primitiveMultisample, (int)(*PMULTISAMPLEEDGES == 1 && round != 0 && !noAA));
+    if (!usingFinalShader) {
+        // Rounded corners
+        glUniform2f(shader->topLeft, TOPLEFT.x, TOPLEFT.y);
+        glUniform2f(shader->fullSize, FULLSIZE.x, FULLSIZE.y);
+        glUniform1f(shader->radius, round);
+        glUniform1i(shader->primitiveMultisample, (int)(*PMULTISAMPLEEDGES == 1 && round != 0 && !noAA));
 
-    if (allowDim && m_pCurrentWindow && *PDIMINACTIVE && m_pCurrentWindow != g_pCompositor->m_pLastWindow) {
-        glUniform1i(shader->applyTint, 1);
-        const auto DIM = m_pCurrentWindow->m_fDimPercent.fl();
-        glUniform3f(shader->tint, 1.f - DIM, 1.f - DIM, 1.f - DIM);
-    } else {
-        glUniform1i(shader->applyTint, 0);
+        if (allowDim && m_pCurrentWindow && *PDIMINACTIVE && m_pCurrentWindow != g_pCompositor->m_pLastWindow) {
+            glUniform1i(shader->applyTint, 1);
+            const auto DIM = m_pCurrentWindow->m_fDimPercent.fl();
+            glUniform3f(shader->tint, 1.f - DIM, 1.f - DIM, 1.f - DIM);
+        } else {
+            glUniform1i(shader->applyTint, 0);
+        }
     }
 
     const float verts[] = {
@@ -502,13 +571,13 @@ void CHyprOpenGLImpl::renderTextureInternalWithDamage(const CTexture& tex, wlr_b
             }
         }
 
-	pixman_region32_fini(&damageClip);
+	    pixman_region32_fini(&damageClip);
     } else {
-	PIXMAN_DAMAGE_FOREACH(damage) {
-	    const auto RECT = RECTSARR[i];
-	    scissor(&RECT);
-	    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-	}
+	    PIXMAN_DAMAGE_FOREACH(damage) {
+	        const auto RECT = RECTSARR[i];
+	        scissor(&RECT);
+	        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+	    }
     }
 
     glDisableVertexAttribArray(shader->posAttrib);
@@ -534,8 +603,6 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, wlr_box* p
 
     float glMatrix[9];
     wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
-    wlr_matrix_multiply(glMatrix, matrixFlip180, glMatrix);
-    wlr_matrix_transpose(glMatrix, glMatrix);
 
     // get the config settings
     static auto *const PBLURSIZE = &g_pConfigManager->getConfigValuePtr("decoration:blur_size")->intValue;
@@ -570,7 +637,12 @@ CFramebuffer* CHyprOpenGLImpl::blurMainFramebufferWithDamage(float a, wlr_box* p
         glUseProgram(pShader->program);
 
         // prep two shaders
+#ifndef GLES2
+        glUniformMatrix3fv(pShader->proj, 1, GL_TRUE, glMatrix);
+#else
+        wlr_matrix_transpose(glMatrix, glMatrix);
         glUniformMatrix3fv(pShader->proj, 1, GL_FALSE, glMatrix);
+#endif
         glUniform1f(pShader->radius, *PBLURSIZE * (a / 255.f));  // this makes the blursize change with a
         if (pShader == &m_RenderData.pCurrentMonData->m_shBLUR1)
             glUniform2f(m_RenderData.pCurrentMonData->m_shBLUR1.halfpixel, 0.5f / (m_RenderData.pMonitor->vecPixelSize.x / 2.f), 0.5f / (m_RenderData.pMonitor->vecPixelSize.y / 2.f));
@@ -643,14 +715,16 @@ void CHyprOpenGLImpl::markBlurDirtyForMonitor(CMonitor* pMonitor) {
 
 void CHyprOpenGLImpl::preRender(CMonitor* pMonitor) {
     static auto *const PBLURNEWOPTIMIZE = &g_pConfigManager->getConfigValuePtr("decoration:blur_new_optimizations")->intValue;
+    static auto *const PBLURXRAY = &g_pConfigManager->getConfigValuePtr("decoration:blur_xray")->intValue;
+    static auto *const PBLUR = &g_pConfigManager->getConfigValuePtr("decoration:blur")->intValue;
 
-    if (!*PBLURNEWOPTIMIZE || !m_mMonitorRenderResources[pMonitor].blurFBDirty)
+    if (!*PBLURNEWOPTIMIZE || !m_mMonitorRenderResources[pMonitor].blurFBDirty || !*PBLUR)
         return;
 
     bool has = false;
 
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_iWorkspaceID == pMonitor->activeWorkspace && w->m_bIsMapped && !w->m_bHidden && !w->m_bIsFloating) {
+        if (w->m_iWorkspaceID == pMonitor->activeWorkspace && w->m_bIsMapped && !w->isHidden() && (!w->m_bIsFloating || *PBLURXRAY)) {
             has = true;
             break;
         }
@@ -687,13 +761,54 @@ void CHyprOpenGLImpl::preBlurForCurrentMonitor() {
 
 void CHyprOpenGLImpl::preWindowPass() {
     static auto *const PBLURNEWOPTIMIZE = &g_pConfigManager->getConfigValuePtr("decoration:blur_new_optimizations")->intValue;
+    static auto *const PBLURXRAY = &g_pConfigManager->getConfigValuePtr("decoration:blur_xray")->intValue;
+    static auto *const PBLUR = &g_pConfigManager->getConfigValuePtr("decoration:blur")->intValue;
 
-    if (!m_RenderData.pCurrentMonData->blurFBDirty || !*PBLURNEWOPTIMIZE)
+    if (!m_RenderData.pCurrentMonData->blurFBDirty || !*PBLURNEWOPTIMIZE || !*PBLUR)
         return;
 
+    auto windowShouldBeBlurred = [&] (CWindow* pWindow) -> bool {
+        if (!pWindow)
+            return false;
+
+        if (pWindow->m_sAdditionalConfigData.forceNoBlur)
+            return false;
+
+        const auto PSURFACE = g_pXWaylandManager->getWindowSurface(pWindow);
+
+        if (PSURFACE->opaque)
+            return false;
+
+        pixman_region32_t inverseOpaque;
+        pixman_region32_init(&inverseOpaque);
+        const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
+        const float A = pWindow->m_fAlpha.fl() * pWindow->m_fActiveInactiveAlpha.fl() * PWORKSPACE->m_fAlpha.fl() / 255.f;
+
+        if (A >= 255.f) {
+            pixman_box32_t surfbox = {0, 0, PSURFACE->current.width, PSURFACE->current.height};
+            pixman_region32_copy(&inverseOpaque, &PSURFACE->current.opaque);
+            pixman_region32_inverse(&inverseOpaque, &inverseOpaque, &surfbox);
+            pixman_region32_intersect_rect(&inverseOpaque, &inverseOpaque, 0, 0, PSURFACE->current.width, PSURFACE->current.height);
+
+            if (!pixman_region32_not_empty(&inverseOpaque)) {
+                pixman_region32_fini(&inverseOpaque);
+                return false;
+            }
+        }
+
+        pixman_region32_fini(&inverseOpaque);
+
+        return true;
+    };
+
     bool hasWindows = false;
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_iWorkspaceID == m_RenderData.pMonitor->activeWorkspace && !w->m_bHidden && w->m_bIsMapped && !w->m_bIsFloating) {
+        if (w->m_iWorkspaceID == m_RenderData.pMonitor->activeWorkspace && !w->isHidden() && w->m_bIsMapped && (!w->m_bIsFloating || *PBLURXRAY)) {
+
+            // check if window is valid
+            if (!windowShouldBeBlurred(w.get()))
+                continue;
+            
             hasWindows = true;
             break;
         }
@@ -706,12 +821,13 @@ void CHyprOpenGLImpl::preWindowPass() {
     preBlurForCurrentMonitor();
 }
 
-void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox, float a, wlr_surface* pSurface, int round) {
+void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox, float a, wlr_surface* pSurface, int round, bool blockBlurOptimization) {
     RASSERT(m_RenderData.pMonitor, "Tried to render texture with blur without begin()!");
 
     static auto *const PBLURENABLED = &g_pConfigManager->getConfigValuePtr("decoration:blur")->intValue;
     static auto *const PNOBLUROVERSIZED = &g_pConfigManager->getConfigValuePtr("decoration:no_blur_on_oversized")->intValue;
     static auto *const PBLURNEWOPTIMIZE = &g_pConfigManager->getConfigValuePtr("decoration:blur_new_optimizations")->intValue;
+    static auto *const PBLURXRAY = &g_pConfigManager->getConfigValuePtr("decoration:blur_xray")->intValue;
 
     // make a damage region for this window
     pixman_region32_t damage;
@@ -719,7 +835,7 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
     pixman_region32_intersect_rect(&damage, m_RenderData.pDamage, pBox->x, pBox->y, pBox->width, pBox->height);  // clip it to the box
 
     if(!pixman_region32_not_empty(&damage))
-	return;
+	    return;
 
     if (*PBLURENABLED == 0 || (*PNOBLUROVERSIZED && m_RenderData.primarySurfaceUVTopLeft != Vector2D(-1, -1)) || (m_pCurrentWindow && m_pCurrentWindow->m_sAdditionalConfigData.forceNoBlur)) {
         renderTexture(tex, pBox, a, round, false, true);
@@ -729,26 +845,33 @@ void CHyprOpenGLImpl::renderTextureWithBlur(const CTexture& tex, wlr_box* pBox,
     // amazing hack: the surface has an opaque region!
     pixman_region32_t inverseOpaque;
     pixman_region32_init(&inverseOpaque);
-    if (a == 255.f) {
-        pixman_box32_t monbox = {0, 0, m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y};
+    if (a >= 255.f) {
+        pixman_box32_t surfbox = {0, 0, pSurface->current.width, pSurface->current.height};
         pixman_region32_copy(&inverseOpaque, &pSurface->current.opaque);
-        pixman_region32_translate(&inverseOpaque, pBox->x, pBox->y);
-        pixman_region32_inverse(&inverseOpaque, &inverseOpaque, &monbox);
-        pixman_region32_intersect(&inverseOpaque, &damage, &inverseOpaque);
+        pixman_region32_inverse(&inverseOpaque, &inverseOpaque, &surfbox);
+        pixman_region32_intersect_rect(&inverseOpaque, &inverseOpaque, 0, 0, pSurface->current.width, pSurface->current.height);
+
+        if (!pixman_region32_not_empty(&inverseOpaque)) {
+            pixman_region32_fini(&inverseOpaque);
+            renderTexture(tex, pBox, a, round, false, true);
+            return;
+        }
     } else {
-        pixman_region32_copy(&inverseOpaque, &damage);
+        pixman_region32_init_rect(&inverseOpaque, 0, 0, pBox->width, pBox->height);
     }
 
-    if (!pixman_region32_not_empty(&inverseOpaque)) {
-        renderTexture(tex, pBox, a, round, false, true); // reject blurring a fully opaque window
-        return;
+    //                                                                        vvv TODO: layered blur fbs?
+    const bool USENEWOPTIMIZE = (*PBLURNEWOPTIMIZE && !blockBlurOptimization && ((m_pCurrentWindow && !m_pCurrentWindow->m_bIsFloating) || *PBLURXRAY) && m_RenderData.pCurrentMonData->blurFB.m_cTex.m_iTexID && (!m_pCurrentWindow || !g_pCompositor->isWorkspaceSpecial(m_pCurrentWindow->m_iWorkspaceID) ));
+
+    CFramebuffer* POUTFB = nullptr;
+    if (!USENEWOPTIMIZE) {
+        pixman_region32_translate(&inverseOpaque, pBox->x, pBox->y);
+
+        POUTFB = blurMainFramebufferWithDamage(a, pBox, &inverseOpaque);
+    } else {
+        POUTFB = &m_RenderData.pCurrentMonData->blurFB;
     }
 
-        //                                                                        vvv TODO: layered blur fbs?
-    const bool USENEWOPTIMIZE = (*PBLURNEWOPTIMIZE && m_pCurrentWindow && !m_pCurrentWindow->m_bIsFloating && m_RenderData.pCurrentMonData->blurFB.m_cTex.m_iTexID && m_pCurrentWindow->m_iWorkspaceID != SPECIAL_WORKSPACE_ID);
-
-    const auto POUTFB = USENEWOPTIMIZE ? &m_RenderData.pCurrentMonData->blurFB : blurMainFramebufferWithDamage(a, pBox, &inverseOpaque);
-
     pixman_region32_fini(&inverseOpaque);
 
     // bind primary
@@ -803,12 +926,12 @@ void pushVert2D(float x, float y, float* arr, int& counter, wlr_box* box) {
     counter++;
 }
 
-void CHyprOpenGLImpl::renderBorder(wlr_box* box, const CColor& col, int round) {
+void CHyprOpenGLImpl::renderBorder(wlr_box* box, const CGradientValueData& grad, int round, float a) {
     RASSERT((box->width > 0 && box->height > 0), "Tried to render rect with width/height < 0!");
     RASSERT(m_RenderData.pMonitor, "Tried to render rect without begin()!");
 
-    if (!pixman_region32_not_empty(m_RenderData.pDamage))
-	return;
+    if (!pixman_region32_not_empty(m_RenderData.pDamage) || (m_pCurrentWindow && m_pCurrentWindow->m_sAdditionalConfigData.forceNoBorder))
+	    return;
 
     static auto *const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
     static auto *const PMULTISAMPLE = &g_pConfigManager->getConfigValuePtr("decoration:multisample_edges")->intValue;
@@ -818,52 +941,49 @@ void CHyprOpenGLImpl::renderBorder(wlr_box* box, const CColor& col, int round) {
 
     int scaledBorderSize = *PBORDERSIZE * m_RenderData.pMonitor->scale;
 
-    if (round < 1) {
-        // zero rounding, just lines
-        wlr_box borderbox = {box->x - scaledBorderSize, box->y - scaledBorderSize, scaledBorderSize, box->height + 2 * scaledBorderSize};
-        renderRect(&borderbox, col, 0); // left
-        borderbox = {box->x, box->y - (int)scaledBorderSize, box->width + (int)scaledBorderSize, (int)scaledBorderSize};
-        renderRect(&borderbox, col, 0);  // top
-        borderbox = {box->x + box->width, box->y, (int)scaledBorderSize, box->height + (int)scaledBorderSize};
-        renderRect(&borderbox, col, 0);  // right
-        borderbox = {box->x, box->y + box->height, box->width, (int)scaledBorderSize};
-        renderRect(&borderbox, col, 0);  // bottom
-
-        return;
-    }
-
     // adjust box
     box->x -= scaledBorderSize;
     box->y -= scaledBorderSize;
     box->width += 2 * scaledBorderSize;
     box->height += 2 * scaledBorderSize;
 
-    round += scaledBorderSize;
+    round += round == 0 ? 0 : scaledBorderSize;
 
     float matrix[9];
     wlr_matrix_project_box(matrix, box, wlr_output_transform_invert(!m_bEndFrame ? WL_OUTPUT_TRANSFORM_NORMAL : m_RenderData.pMonitor->transform), 0, m_RenderData.pMonitor->output->transform_matrix);  // TODO: write own, don't use WLR here
 
     float glMatrix[9];
     wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
-    wlr_matrix_multiply(glMatrix, matrixFlip180, glMatrix);
-
-    wlr_matrix_transpose(glMatrix, glMatrix);
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     glUseProgram(m_RenderData.pCurrentMonData->m_shBORDER1.program);
 
+#ifndef GLES2
+    glUniformMatrix3fv(m_RenderData.pCurrentMonData->m_shBORDER1.proj, 1, GL_TRUE, glMatrix);
+#else
+    wlr_matrix_transpose(glMatrix, glMatrix);
     glUniformMatrix3fv(m_RenderData.pCurrentMonData->m_shBORDER1.proj, 1, GL_FALSE, glMatrix);
-    glUniform4f(m_RenderData.pCurrentMonData->m_shBORDER1.color, col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f);
+#endif
 
-    const auto TOPLEFT = Vector2D(round, round);
-    const auto BOTTOMRIGHT = Vector2D(box->width - round, box->height - round);
-    const auto FULLSIZE = Vector2D(box->width, box->height);
+    static_assert(sizeof(CColor) == 4 * sizeof(float)); // otherwise the line below this will fail
+
+    glUniform4fv(m_RenderData.pCurrentMonData->m_shBORDER1.gradient, grad.m_vColors.size(), (float*)grad.m_vColors.data());
+    glUniform1i(m_RenderData.pCurrentMonData->m_shBORDER1.gradientLength, grad.m_vColors.size());
+    glUniform1f(m_RenderData.pCurrentMonData->m_shBORDER1.angle, (int)(grad.m_fAngle / (PI / 180.0)) % 360 * (PI / 180.0));
+    glUniform1f(m_RenderData.pCurrentMonData->m_shBORDER1.alpha, a);
+
+    wlr_box transformedBox;
+    wlr_box_transform(&transformedBox, box, wlr_output_transform_invert(m_RenderData.pMonitor->transform),
+                      m_RenderData.pMonitor->vecTransformedSize.x, m_RenderData.pMonitor->vecTransformedSize.y);
+
+    const auto TOPLEFT = Vector2D(transformedBox.x, transformedBox.y);
+    const auto FULLSIZE = Vector2D(transformedBox.width, transformedBox.height);
 
     glUniform2f(m_RenderData.pCurrentMonData->m_shBORDER1.topLeft, (float)TOPLEFT.x, (float)TOPLEFT.y);
-    glUniform2f(m_RenderData.pCurrentMonData->m_shBORDER1.bottomRight, (float)BOTTOMRIGHT.x, (float)BOTTOMRIGHT.y);
     glUniform2f(m_RenderData.pCurrentMonData->m_shBORDER1.fullSize, (float)FULLSIZE.x, (float)FULLSIZE.y);
+    glUniform2f(m_RenderData.pCurrentMonData->m_shBORDER1.fullSizeUntransformed, (float)box->width, (float)box->height);
     glUniform1f(m_RenderData.pCurrentMonData->m_shBORDER1.radius, round);
     glUniform1f(m_RenderData.pCurrentMonData->m_shBORDER1.thick, scaledBorderSize);
     glUniform1i(m_RenderData.pCurrentMonData->m_shBORDER1.primitiveMultisample, *PMULTISAMPLE);
@@ -887,19 +1007,80 @@ void CHyprOpenGLImpl::renderBorder(wlr_box* box, const CColor& col, int round) {
             }
         }
 
-	pixman_region32_fini(&damageClip);
+	    pixman_region32_fini(&damageClip);
     } else {
-	PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
-	    const auto RECT = RECTSARR[i];
-	    scissor(&RECT);
-	    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-	}
+	    PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
+	        const auto RECT = RECTSARR[i];
+	        scissor(&RECT);
+	        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+	    }
     }
 
     glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shBORDER1.posAttrib);
     glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shBORDER1.texAttrib);
 
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+
+    // fix back box
+    box->x += scaledBorderSize;
+    box->y += scaledBorderSize;
+    box->width -= 2 * scaledBorderSize;
+    box->height -= 2 * scaledBorderSize;
+}
+
+void CHyprOpenGLImpl::makeRawWindowSnapshot(CWindow* pWindow, CFramebuffer* pFramebuffer) {
+    // we trust the window is valid.
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    wlr_output_attach_render(PMONITOR->output, nullptr);
+
+    // we need to "damage" the entire monitor
+    // so that we render the entire window
+    // this is temporary, doesnt mess with the actual wlr damage
+    pixman_region32_t fakeDamage;
+    pixman_region32_init(&fakeDamage);
+    pixman_region32_union_rect(&fakeDamage, &fakeDamage, 0, 0, (int)PMONITOR->vecTransformedSize.x, (int)PMONITOR->vecTransformedSize.y);
+
+    begin(PMONITOR, &fakeDamage, true);
+
+    clear(CColor(0, 0, 0, 0));  // JIC
+
+    timespec now;
+    clock_gettime(CLOCK_MONOTONIC, &now);
+
+    // this is a hack but it works :P
+    // we need to disable blur or else we will get a black background, as the shader
+    // will try to copy the bg to apply blur.
+    // this isn't entirely correct, but like, oh well.
+    // small todo: maybe make this correct? :P
+    const auto BLURVAL = g_pConfigManager->getInt("decoration:blur");
+    g_pConfigManager->setInt("decoration:blur", 0);
+
+    // TODO: how can we make this the size of the window? setting it to window's size makes the entire screen render with the wrong res forever more. odd.
+    glViewport(0, 0, PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
+
+    pFramebuffer->m_pStencilTex = &m_RenderData.pCurrentMonData->stencilTex;
+
+    pFramebuffer->alloc(PMONITOR->vecPixelSize.x, PMONITOR->vecPixelSize.y);
+
+    pFramebuffer->bind();
+
+    clear(CColor(0, 0, 0, 0));  // JIC
+
+    g_pHyprRenderer->renderWindow(pWindow, PMONITOR, &now, false, RENDER_PASS_ALL, true);
+
+    g_pConfigManager->setInt("decoration:blur", BLURVAL);
+
+// restore original fb
+#ifndef GLES2
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_iCurrentOutputFb);
+#else
+    glBindFramebuffer(GL_FRAMEBUFFER, m_iCurrentOutputFb);
+#endif
+    end();
+
+    pixman_region32_fini(&fakeDamage);
+
+    wlr_output_rollback(PMONITOR->output);
 }
 
 void CHyprOpenGLImpl::makeWindowSnapshot(CWindow* pWindow) {
@@ -916,7 +1097,7 @@ void CHyprOpenGLImpl::makeWindowSnapshot(CWindow* pWindow) {
 
     begin(PMONITOR, &fakeDamage, true);
 
-    clear(CColor(0,0,0,0)); // JIC
+    clear(CColor(0, 0, 0, 0));  // JIC
 
     timespec now;
     clock_gettime(CLOCK_MONOTONIC, &now);
@@ -929,10 +1110,9 @@ void CHyprOpenGLImpl::makeWindowSnapshot(CWindow* pWindow) {
     const auto BLURVAL = g_pConfigManager->getInt("decoration:blur");
     g_pConfigManager->setInt("decoration:blur", 0);
 
-    // render onto the window fb
-    const auto PFRAMEBUFFER = &m_mWindowFramebuffers[pWindow];
+    glViewport(0, 0, m_RenderData.pMonitor->vecPixelSize.x, m_RenderData.pMonitor->vecPixelSize.y);
 
-    glViewport(0, 0, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.x, g_pHyprOpenGL->m_RenderData.pMonitor->vecPixelSize.y);
+    const auto PFRAMEBUFFER = &m_mWindowFramebuffers[pWindow];
 
     PFRAMEBUFFER->m_pStencilTex = &m_RenderData.pCurrentMonData->stencilTex;
 
@@ -946,12 +1126,12 @@ void CHyprOpenGLImpl::makeWindowSnapshot(CWindow* pWindow) {
 
     g_pConfigManager->setInt("decoration:blur", BLURVAL);
 
-    // restore original fb
-    #ifndef GLES2
+// restore original fb
+#ifndef GLES2
     glBindFramebuffer(GL_DRAW_FRAMEBUFFER, m_iCurrentOutputFb);
-    #else
+#else
     glBindFramebuffer(GL_FRAMEBUFFER, m_iCurrentOutputFb);
-    #endif
+#endif
     end();
 
     pixman_region32_fini(&fakeDamage);
@@ -986,9 +1166,14 @@ void CHyprOpenGLImpl::makeLayerSnapshot(SLayerSurface* pLayer) {
     timespec now;
     clock_gettime(CLOCK_MONOTONIC, &now);
 
+    const auto BLURLSSTATUS = pLayer->forceBlur;
+    pLayer->forceBlur = false;
+
     // draw the layer
     g_pHyprRenderer->renderLayer(pLayer, PMONITOR, &now);
 
+    pLayer->forceBlur = BLURLSSTATUS;
+
     // TODO: WARN:
     // revise if any stencil-requiring rendering is done to the layers.
 
@@ -1006,6 +1191,14 @@ void CHyprOpenGLImpl::makeLayerSnapshot(SLayerSurface* pLayer) {
     wlr_output_rollback(PMONITOR->output);
 }
 
+void CHyprOpenGLImpl::onWindowResizeStart(CWindow* pWindow) {
+
+}
+
+void CHyprOpenGLImpl::onWindowResizeEnd(CWindow* pWindow) {
+
+}
+
 void CHyprOpenGLImpl::renderSnapshot(CWindow** pWindow) {
     RASSERT(m_RenderData.pMonitor, "Tried to render snapshot rect without begin()!");
     const auto PWINDOW = *pWindow;
@@ -1103,16 +1296,18 @@ void CHyprOpenGLImpl::renderRoundedShadow(wlr_box* box, int round, int range, fl
 
     float glMatrix[9];
     wlr_matrix_multiply(glMatrix, m_RenderData.projection, matrix);
-    wlr_matrix_multiply(glMatrix, matrixFlip180, glMatrix);
-
-    wlr_matrix_transpose(glMatrix, glMatrix);
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     glUseProgram(m_RenderData.pCurrentMonData->m_shSHADOW.program);
 
+#ifndef GLES2
+    glUniformMatrix3fv(m_RenderData.pCurrentMonData->m_shSHADOW.proj, 1, GL_TRUE, glMatrix);
+#else
+    wlr_matrix_transpose(glMatrix, glMatrix);
     glUniformMatrix3fv(m_RenderData.pCurrentMonData->m_shSHADOW.proj, 1, GL_FALSE, glMatrix);
+#endif
     glUniform4f(m_RenderData.pCurrentMonData->m_shSHADOW.color, col.r / 255.f, col.g / 255.f, col.b / 255.f, col.a / 255.f * a);
 
     const auto TOPLEFT = Vector2D(range + round, range + round);
@@ -1146,13 +1341,13 @@ void CHyprOpenGLImpl::renderRoundedShadow(wlr_box* box, int round, int range, fl
             }
         }
 
-	pixman_region32_fini(&damageClip);
+	    pixman_region32_fini(&damageClip);
     } else {
-	PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
-	    const auto RECT = RECTSARR[i];
-	    scissor(&RECT);
-	    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
-	}
+	    PIXMAN_DAMAGE_FOREACH(m_RenderData.pDamage) {
+	        const auto RECT = RECTSARR[i];
+	        scissor(&RECT);
+	        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+	    }
     }
 
     glDisableVertexAttribArray(m_RenderData.pCurrentMonData->m_shSHADOW.posAttrib);

src/render/OpenGL.hpp

@@ -12,11 +12,8 @@
 #include "Texture.hpp"
 #include "Framebuffer.hpp"
 
-inline const float matrixFlip180[] = {
-	1.0f, 0.0f, 0.0f,
-	0.0f, -1.0f, 0.0f,
-	0.0f, 0.0f, 1.0f,
-};
+class CHyprRenderer;
+
 inline const float fullVerts[] = {
     1, 0,  // top right
     0, 0,  // top left
@@ -71,6 +68,8 @@ struct SCurrentRenderData {
     wlr_box     clipBox = {};
 };
 
+class CGradientValueData;
+
 class CHyprOpenGLImpl {
 public:
 
@@ -83,11 +82,12 @@ public:
     void    renderRectWithDamage(wlr_box*, const CColor&, pixman_region32_t* damage, int round = 0);
     void    renderTexture(wlr_texture*, wlr_box*, float a, int round = 0, bool allowCustomUV = false);
     void    renderTexture(const CTexture&, wlr_box*, float a, int round = 0, bool discardOpaque = false, bool allowCustomUV = false);
-    void    renderTextureWithBlur(const CTexture&, wlr_box*, float a, wlr_surface* pSurface, int round = 0);
+    void    renderTextureWithBlur(const CTexture&, wlr_box*, float a, wlr_surface* pSurface, int round = 0, bool blockBlurOptimization = false);
     void    renderRoundedShadow(wlr_box*, int round, int range, float a = 1.0);
-    void    renderBorder(wlr_box*, const CColor&, int round);
+    void    renderBorder(wlr_box*, const CGradientValueData&, int round, float a = 1.0);
 
     void    makeWindowSnapshot(CWindow*);
+    void    makeRawWindowSnapshot(CWindow*, CFramebuffer*);
     void    makeLayerSnapshot(SLayerSurface*);
     void    renderSnapshot(CWindow**);
     void    renderSnapshot(SLayerSurface**);
@@ -108,11 +108,18 @@ public:
     void    saveBufferForMirror();
     void    renderMirrored();
 
+    void    onWindowResizeStart(CWindow*);
+    void    onWindowResizeEnd(CWindow*);
+
+    void    applyScreenShader(const std::string& path);
+
     SCurrentRenderData m_RenderData;
 
     GLint  m_iCurrentOutputFb = 0;
     GLint  m_iWLROutputFb = 0;
 
+    bool   m_bReloadScreenShader = true; // at launch it can be set
+
     CWindow* m_pCurrentWindow = nullptr; // hack to get the current rendered window
 
     pixman_region32_t m_rOriginalDamageRegion; // used for storing the pre-expanded region
@@ -131,9 +138,12 @@ private:
 
     bool                    m_bFakeFrame = false;
     bool                    m_bEndFrame = false;
+    bool                    m_bApplyFinalShader = false;
 
-    GLuint                  createProgram(const std::string&, const std::string&);
-    GLuint                  compileShader(const GLuint&, std::string);
+    CShader                 m_sFinalScreenShader;
+
+    GLuint                  createProgram(const std::string&, const std::string&, bool dynamic = false);
+    GLuint                  compileShader(const GLuint&, std::string, bool dynamic = false);
     void                    createBGTextureForMonitor(CMonitor*);
     void                    initShaders();
 
@@ -144,6 +154,8 @@ private:
     void                    renderSplash(cairo_t *const, cairo_surface_t *const, double);
 
     void                    preBlurForCurrentMonitor();
+
+    friend class CHyprRenderer;
 };
 
 inline std::unique_ptr<CHyprOpenGLImpl> g_pHyprOpenGL;

src/render/Renderer.cpp

@@ -1,5 +1,6 @@
 #include "Renderer.hpp"
 #include "../Compositor.hpp"
+#include "linux-dmabuf-unstable-v1-protocol.h"
 
 void renderSurface(struct wlr_surface* surface, int x, int y, void* data) {
     const auto TEXTURE = wlr_surface_get_texture(surface);
@@ -41,7 +42,7 @@ void renderSurface(struct wlr_surface* surface, int x, int y, void* data) {
             g_pHyprOpenGL->renderTexture(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, rounding, true);
         } else {
             if (RDATA->blur)
-                g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, surface, rounding);
+                g_pHyprOpenGL->renderTextureWithBlur(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, surface, rounding, RDATA->blockBlurOptimization);
             else
                 g_pHyprOpenGL->renderTexture(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, rounding, true);
         }
@@ -50,9 +51,10 @@ void renderSurface(struct wlr_surface* surface, int x, int y, void* data) {
         g_pHyprOpenGL->renderTexture(TEXTURE, &windowBox, RDATA->fadeAlpha * RDATA->alpha, rounding, true);
     }
 
-    wlr_surface_send_frame_done(surface, RDATA->when);
-
-    wlr_presentation_surface_sampled_on_output(g_pCompositor->m_sWLRPresentation, surface, RDATA->output);
+    if (!g_pHyprRenderer->m_bBlockSurfaceFeedback) {
+        wlr_surface_send_frame_done(surface, RDATA->when);
+        wlr_presentation_surface_sampled_on_output(g_pCompositor->m_sWLRPresentation, surface, RDATA->output);
+    }
 
     // reset the UV, we might've set it above
     g_pHyprOpenGL->m_RenderData.primarySurfaceUVTopLeft = Vector2D(-1, -1);
@@ -84,12 +86,10 @@ bool CHyprRenderer::shouldRenderWindow(CWindow* pWindow, CMonitor* pMonitor) {
         return true;
 
     // if not, check if it maybe is active on a different monitor.
-    if (g_pCompositor->isWorkspaceVisible(pWindow->m_iWorkspaceID) ||
-        (PWORKSPACE && PWORKSPACE->m_iMonitorID == pMonitor->ID && PWORKSPACE->m_bForceRendering) || // vvvv might be in animation progress vvvvv
-        (PWORKSPACE && PWORKSPACE->m_iMonitorID == pMonitor->ID && (PWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWORKSPACE->m_fAlpha.isBeingAnimated())))
+    if (g_pCompositor->isWorkspaceVisible(pWindow->m_iWorkspaceID) && pWindow->m_bIsFloating /* tiled windows can't be multi-ws */)
         return !pWindow->m_bIsFullscreen; // Do not draw fullscreen windows on other monitors
 
-    if (pMonitor->specialWorkspaceOpen && pWindow->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+    if (pMonitor->specialWorkspaceID && g_pCompositor->isWorkspaceSpecial(pWindow->m_iWorkspaceID))
         return true;
 
     return false;
@@ -112,7 +112,7 @@ bool CHyprRenderer::shouldRenderWindow(CWindow* pWindow) {
         if (PWORKSPACE && PWORKSPACE->m_iMonitorID == m->ID && (PWORKSPACE->m_vRenderOffset.isBeingAnimated() || PWORKSPACE->m_fAlpha.isBeingAnimated()))
             return true;
 
-        if (m->specialWorkspaceOpen && pWindow->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+        if (m->specialWorkspaceID && g_pCompositor->isWorkspaceSpecial(pWindow->m_iWorkspaceID))
             return true;
     }
 
@@ -169,6 +169,12 @@ void CHyprRenderer::renderWorkspaceWithFullscreenWindow(CMonitor* pMonitor, CWor
         pWorkspaceWindow = w.get();
     }
 
+    if (!pWorkspaceWindow) {
+        // ?? happens sometimes...
+        pWorkspace->m_bHasFullscreenWindow = false;
+        return; // this will produce one blank frame. Oh well.
+    }
+
     // then render windows over fullscreen.
     for (auto& w : g_pCompositor->m_vWindows) {
         if (w->m_iWorkspaceID != pWorkspaceWindow->m_iWorkspaceID || (!w->m_bCreatedOverFullscreen && !w->m_bPinned) || !w->m_bIsMapped)
@@ -178,11 +184,11 @@ void CHyprRenderer::renderWorkspaceWithFullscreenWindow(CMonitor* pMonitor, CWor
     }
 
     // and then special windows
-    for (auto& w : g_pCompositor->m_vWindows) {
+    if (pMonitor->specialWorkspaceID) for (auto& w : g_pCompositor->m_vWindows) {
         if (!g_pCompositor->windowValidMapped(w.get()) && !w->m_bFadingOut)
             continue;
 
-        if (w->m_iWorkspaceID != SPECIAL_WORKSPACE_ID)
+        if (w->m_iWorkspaceID != pMonitor->specialWorkspaceID)
             continue;
 
         if (!shouldRenderWindow(w.get(), pMonitor))
@@ -210,8 +216,8 @@ void CHyprRenderer::renderWorkspaceWithFullscreenWindow(CMonitor* pMonitor, CWor
         g_pHyprError->draw();
 }
 
-void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec* time, bool decorate, eRenderPassMode mode) {
-    if (pWindow->m_bHidden)
+void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec* time, bool decorate, eRenderPassMode mode, bool ignorePosition, bool ignoreAllGeometry) {
+    if (pWindow->isHidden())
         return;
 
     if (pWindow->m_bFadingOut) {
@@ -222,9 +228,17 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec*
 
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
     const auto REALPOS = pWindow->m_vRealPosition.vec() + (pWindow->m_bPinned ? Vector2D{} : PWORKSPACE->m_vRenderOffset.vec());
-    static const auto PNOFLOATINGBORDERS = &g_pConfigManager->getConfigValuePtr("general:no_border_on_floating")->intValue;
+    static auto *const PNOFLOATINGBORDERS = &g_pConfigManager->getConfigValuePtr("general:no_border_on_floating")->intValue;
 
     SRenderData renderdata = {pMonitor->output, time, REALPOS.x, REALPOS.y};
+    if (ignorePosition) {
+        renderdata.x = pMonitor->vecPosition.x;
+        renderdata.y = pMonitor->vecPosition.y;
+    }
+
+    if (ignoreAllGeometry)
+        decorate = false;
+
     renderdata.surface = g_pXWaylandManager->getWindowSurface(pWindow);
     renderdata.w = std::max(pWindow->m_vRealSize.vec().x, 5.0); // clamp the size to min 5,
     renderdata.h = std::max(pWindow->m_vRealSize.vec().y, 5.0); // otherwise we'll have issues later with invalid boxes
@@ -232,10 +246,15 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec*
     renderdata.fadeAlpha = pWindow->m_fAlpha.fl() * (pWindow->m_bPinned ? 1.f : (PWORKSPACE->m_fAlpha.fl() / 255.f));
     renderdata.alpha = pWindow->m_fActiveInactiveAlpha.fl();
     renderdata.decorate = decorate && !pWindow->m_bX11DoesntWantBorders && (pWindow->m_bIsFloating ? *PNOFLOATINGBORDERS == 0 : true) && (!pWindow->m_bIsFullscreen || PWORKSPACE->m_efFullscreenMode != FULLSCREEN_FULL);
-    renderdata.rounding = pWindow->m_sAdditionalConfigData.rounding;
-    renderdata.blur = true; // if it shouldn't, it will be ignored later
+    renderdata.rounding = ignoreAllGeometry ? 0 : pWindow->m_sAdditionalConfigData.rounding;
+    renderdata.blur = !ignoreAllGeometry; // if it shouldn't, it will be ignored later
     renderdata.pWindow = pWindow;
 
+    if (ignoreAllGeometry) {
+        renderdata.alpha = 1.f;
+        renderdata.fadeAlpha = 255.f;
+    }
+
     // apply window special data
     if (pWindow->m_sSpecialRenderData.alphaInactive == -1)
         renderdata.alpha *= pWindow->m_sSpecialRenderData.alpha;
@@ -250,33 +269,34 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec*
 
     // clip box for animated offsets
     Vector2D offset;
-    if (PWORKSPACE->m_vRenderOffset.vec().x != 0) {
-        const auto PWSMON = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
-        const auto PROGRESS = PWORKSPACE->m_vRenderOffset.vec().x / PWSMON->vecSize.x;
-        const auto WINBB = pWindow->getFullWindowBoundingBox();
+    if (!ignorePosition && pWindow->m_bIsFloating) {
+        if (PWORKSPACE->m_vRenderOffset.vec().x != 0) {
+            const auto PWSMON = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
+            const auto PROGRESS = PWORKSPACE->m_vRenderOffset.vec().x / PWSMON->vecSize.x;
+            const auto WINBB = pWindow->getFullWindowBoundingBox();
 
-        if (WINBB.x < PWSMON->vecPosition.x) {
-            offset.x = (PWSMON->vecPosition.x - WINBB.x) * PROGRESS;
-        } else if (WINBB.x > PWSMON->vecPosition.x + PWSMON->vecSize.x) {
-            offset.x = (WINBB.x - PWSMON->vecPosition.x + PWSMON->vecSize.x) * PROGRESS;
-        }
-    } else if (PWORKSPACE->m_vRenderOffset.vec().y) {
-        const auto PWSMON = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
-        const auto PROGRESS = PWORKSPACE->m_vRenderOffset.vec().y / PWSMON->vecSize.y;
-        const auto WINBB = pWindow->getFullWindowBoundingBox();
+            if (WINBB.x < PWSMON->vecPosition.x) {
+                offset.x = (PWSMON->vecPosition.x - WINBB.x) * PROGRESS;
+            } else 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.vec().y) {
+            const auto PWSMON = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
+            const auto PROGRESS = PWORKSPACE->m_vRenderOffset.vec().y / PWSMON->vecSize.y;
+            const auto WINBB = pWindow->getFullWindowBoundingBox();
 
-        if (WINBB.y < PWSMON->vecPosition.y) {
-            offset.y = (PWSMON->vecPosition.y - WINBB.y) * PROGRESS;
-        } else if (WINBB.y > PWSMON->vecPosition.y + PWSMON->vecSize.y) {
-            offset.y = (WINBB.y - PWSMON->vecPosition.y + PWSMON->vecSize.y) * PROGRESS;
+            if (WINBB.y < PWSMON->vecPosition.y) {
+                offset.y = (PWSMON->vecPosition.y - WINBB.y) * PROGRESS;
+            } else if (WINBB.y + WINBB.height > PWSMON->vecPosition.y + PWSMON->vecSize.y) {
+                offset.y = (WINBB.y + WINBB.width - PWSMON->vecPosition.y - PWSMON->vecSize.y) * PROGRESS;
+            }
         }
+
+        renderdata.x += offset.x;
+        renderdata.y += offset.y;
     }
-
-    renderdata.x += offset.x;
-    renderdata.y += offset.y;
-
+    
     // render window decorations first, if not fullscreen full
-
     if (mode == RENDER_PASS_ALL || mode == RENDER_PASS_MAIN) {
         if (!pWindow->m_bIsFullscreen || PWORKSPACE->m_efFullscreenMode != FULLSCREEN_FULL) for (auto& wd : pWindow->m_dWindowDecorations)
                 wd->draw(pMonitor, renderdata.alpha * renderdata.fadeAlpha / 255.f, offset);
@@ -289,14 +309,20 @@ void CHyprRenderer::renderWindow(CWindow* pWindow, CMonitor* pMonitor, timespec*
             float rounding = renderdata.dontRound ? 0 : renderdata.rounding == -1 ? *PROUNDING : renderdata.rounding;
             rounding *= pMonitor->scale;
 
-            auto col = g_pHyprOpenGL->m_pCurrentWindow->m_cRealBorderColor.col();
-            col.a *= renderdata.fadeAlpha * renderdata.alpha / 255.f;
+            auto grad = g_pHyprOpenGL->m_pCurrentWindow->m_cRealBorderColor;
+            const bool ANIMATED = g_pHyprOpenGL->m_pCurrentWindow->m_fBorderAnimationProgress.isBeingAnimated();
+            float a1 = renderdata.fadeAlpha * renderdata.alpha / 255.f * (ANIMATED ? g_pHyprOpenGL->m_pCurrentWindow->m_fBorderAnimationProgress.fl() : 1.f);
 
             wlr_box windowBox = {renderdata.x - pMonitor->vecPosition.x, renderdata.y - pMonitor->vecPosition.y, renderdata.w, renderdata.h};
 
             scaleBox(&windowBox, pMonitor->scale);
 
-            g_pHyprOpenGL->renderBorder(&windowBox, col, rounding);
+            g_pHyprOpenGL->renderBorder(&windowBox, grad, rounding, a1);
+
+            if (ANIMATED) {
+                float a2 = renderdata.fadeAlpha * renderdata.alpha / 255.f * (1.f - g_pHyprOpenGL->m_pCurrentWindow->m_fBorderAnimationProgress.fl());
+                g_pHyprOpenGL->renderBorder(&windowBox, g_pHyprOpenGL->m_pCurrentWindow->m_cRealBorderColorPrevious, rounding, a2);
+            }
         }
     }
 
@@ -332,6 +358,7 @@ void CHyprRenderer::renderLayer(SLayerSurface* pLayer, CMonitor* pMonitor, times
     renderdata.decorate = false;
     renderdata.w = pLayer->layerSurface->surface->current.width;
     renderdata.h = pLayer->layerSurface->surface->current.height;
+    renderdata.blockBlurOptimization = pLayer->layer == ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM || pLayer->layer == ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND;
     wlr_surface_for_each_surface(pLayer->layerSurface->surface, renderSurface, &renderdata);
 
     renderdata.squishOversized = false;  // don't squish popups
@@ -377,33 +404,44 @@ void CHyprRenderer::renderAllClientsForMonitor(const int& ID, timespec* time) {
         return;
     }
 
+    CWindow* lastWindow = nullptr;
+
     // Non-floating main
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_bHidden && !w->m_bIsMapped && !w->m_bFadingOut)
+        if (w->isHidden() && !w->m_bIsMapped && !w->m_bFadingOut)
             continue;
 
         if (w->m_bIsFloating)
             continue;  // floating are in the second pass
 
-        if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+        if (g_pCompositor->isWorkspaceSpecial(w->m_iWorkspaceID))
             continue;  // special are in the third pass
 
         if (!shouldRenderWindow(w.get(), PMONITOR))
             continue;
+        
+        // render active window after all others of this pass
+        if (w.get() == g_pCompositor->m_pLastWindow) {
+            lastWindow = w.get();
+            continue;
+        }
 
         // render the bad boy
         renderWindow(w.get(), PMONITOR, time, true, RENDER_PASS_MAIN);
     }
 
+    if (lastWindow)
+        renderWindow(lastWindow, PMONITOR, time, true, RENDER_PASS_MAIN);
+
     // Non-floating popup
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_bHidden && !w->m_bIsMapped && !w->m_bFadingOut)
+        if (w->isHidden() && !w->m_bIsMapped && !w->m_bFadingOut)
             continue;
 
         if (w->m_bIsFloating)
             continue;  // floating are in the second pass
 
-        if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+        if (g_pCompositor->isWorkspaceSpecial(w->m_iWorkspaceID))
             continue; // special are in the third pass
 
         if (!shouldRenderWindow(w.get(), PMONITOR))
@@ -415,13 +453,13 @@ void CHyprRenderer::renderAllClientsForMonitor(const int& ID, timespec* time) {
 
     // floating on top
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_bHidden && !w->m_bIsMapped && !w->m_bFadingOut)
+        if (w->isHidden() && !w->m_bIsMapped && !w->m_bFadingOut)
             continue;
 
         if (!w->m_bIsFloating)
             continue;
 
-        if (w->m_iWorkspaceID == SPECIAL_WORKSPACE_ID)
+        if (g_pCompositor->isWorkspaceSpecial(w->m_iWorkspaceID))
             continue;
 
         if (!shouldRenderWindow(w.get(), PMONITOR))
@@ -433,10 +471,10 @@ void CHyprRenderer::renderAllClientsForMonitor(const int& ID, timespec* time) {
 
     // and then special
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (w->m_bHidden && !w->m_bIsMapped && !w->m_bFadingOut)
+        if (w->isHidden() && !w->m_bIsMapped && !w->m_bFadingOut)
             continue;
 
-        if (w->m_iWorkspaceID != SPECIAL_WORKSPACE_ID)
+        if (!g_pCompositor->isWorkspaceSpecial(w->m_iWorkspaceID))
             continue;
 
         if (!shouldRenderWindow(w.get(), PMONITOR))
@@ -529,6 +567,154 @@ void CHyprRenderer::calculateUVForWindowSurface(CWindow* pWindow, wlr_surface* p
     }
 }
 
+void countSubsurfacesIter(wlr_surface* pSurface, int x, int y, void* data) {
+    *(int*)data += 1;
+}
+
+bool CHyprRenderer::attemptDirectScanout(CMonitor* pMonitor) {
+    if (!pMonitor->mirrors.empty())
+        return false; // do not DS if this monitor is being mirrored. Will break the functionality.
+
+    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pMonitor->activeWorkspace);
+
+    if (!PWORKSPACE || !PWORKSPACE->m_bHasFullscreenWindow || g_pInputManager->m_sDrag.drag || g_pCompositor->m_sSeat.exclusiveClient || pMonitor->specialWorkspaceID)
+        return false;
+
+    const auto PCANDIDATE = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
+
+    if (!PCANDIDATE)
+        return false; // ????
+
+    if (PCANDIDATE->m_fAlpha.fl() != 255.f || PCANDIDATE->m_fActiveInactiveAlpha.fl() != 1.f || PWORKSPACE->m_fAlpha.fl() != 255.f)
+        return false;
+
+    if (PCANDIDATE->m_vRealSize.vec() != pMonitor->vecSize || PCANDIDATE->m_vRealPosition.vec() != pMonitor->vecPosition || PCANDIDATE->m_vRealPosition.isBeingAnimated() || PCANDIDATE->m_vRealSize.isBeingAnimated())
+        return false;
+
+    if (!pMonitor->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY].empty())
+        return false;
+
+    for (auto& topls : pMonitor->m_aLayerSurfaceLists[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
+        if (topls->alpha.fl() != 0.f)
+            return false;
+    }
+
+    // check if it did not open any subsurfaces or shit
+    int surfaceCount = 0;
+    if (PCANDIDATE->m_bIsX11) {
+        surfaceCount = 1;
+
+        // check opaque
+        if (PCANDIDATE->m_uSurface.xwayland->has_alpha)
+            return false;
+    } else {
+        wlr_xdg_surface_for_each_surface(PCANDIDATE->m_uSurface.xdg, countSubsurfacesIter, &surfaceCount);
+        wlr_xdg_surface_for_each_popup_surface(PCANDIDATE->m_uSurface.xdg, countSubsurfacesIter, &surfaceCount);
+
+        if (!PCANDIDATE->m_uSurface.xdg->surface->opaque)
+            return false;
+    }
+
+    if (surfaceCount != 1)
+        return false;
+
+    const auto PSURFACE = g_pXWaylandManager->getWindowSurface(PCANDIDATE);
+
+    if (!PSURFACE || PSURFACE->current.scale != pMonitor->output->scale || PSURFACE->current.transform != pMonitor->output->transform)
+        return false;
+
+    // finally, we should be GTG.
+    wlr_output_attach_buffer(pMonitor->output, &PSURFACE->buffer->base);
+
+    if (!wlr_output_test(pMonitor->output)) {
+        return false;
+    }
+
+    timespec now;
+    clock_gettime(CLOCK_MONOTONIC, &now);
+    wlr_surface_send_frame_done(PSURFACE, &now);
+    wlr_presentation_surface_sampled_on_output(g_pCompositor->m_sWLRPresentation, PSURFACE, pMonitor->output);
+
+    if (wlr_output_commit(pMonitor->output)) {
+        if (!m_pLastScanout) {
+            m_pLastScanout = PCANDIDATE;
+            Debug::log(LOG, "Entered a direct scanout to %x: \"%s\"", PCANDIDATE, PCANDIDATE->m_szTitle.c_str());
+        }
+    } else {
+        m_pLastScanout = nullptr;
+        return false;
+    }
+
+    return true;
+}
+
+void CHyprRenderer::setWindowScanoutMode(CWindow* pWindow) {
+    if (!g_pCompositor->m_sWLRLinuxDMABuf)
+        return;
+
+    if (!pWindow->m_bIsFullscreen) {
+        wlr_linux_dmabuf_v1_set_surface_feedback(g_pCompositor->m_sWLRLinuxDMABuf, g_pXWaylandManager->getWindowSurface(pWindow), nullptr);
+        Debug::log(LOG, "Scanout mode OFF set for %x", pWindow);
+        return;
+    }
+
+    const auto RENDERERDRMFD = wlr_renderer_get_drm_fd(g_pCompositor->m_sWLRRenderer);
+    const auto BACKENDDRMFD = wlr_backend_get_drm_fd(g_pCompositor->m_sWLRBackend);
+
+    if (RENDERERDRMFD < 0 || BACKENDDRMFD < 0)
+        return;
+
+    auto deviceIDFromFD = [](int fd, unsigned long* deviceID) -> bool {
+        struct stat stat;
+        if (fstat(fd, &stat) != 0) {
+            return false;
+        }
+        *deviceID = stat.st_rdev;
+        return true;
+    };
+
+    unsigned long rendererDevice, scanoutDevice;
+    if (!deviceIDFromFD(RENDERERDRMFD, &rendererDevice) || !deviceIDFromFD(BACKENDDRMFD, &scanoutDevice))
+        return;
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+
+    const auto POUTPUTFORMATS = wlr_output_get_primary_formats(PMONITOR->output, WLR_BUFFER_CAP_DMABUF);
+    if (!POUTPUTFORMATS)
+        return;
+
+    const auto PRENDERERFORMATS = wlr_renderer_get_dmabuf_texture_formats(g_pCompositor->m_sWLRRenderer);
+    wlr_drm_format_set scanoutFormats = { 0 };
+
+    if (!wlr_drm_format_set_intersect(&scanoutFormats, POUTPUTFORMATS, PRENDERERFORMATS))
+        return;
+
+    const wlr_linux_dmabuf_feedback_v1_tranche TRANCHES[] = {
+        {
+            .target_device = scanoutDevice,
+            .flags = ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT,
+            .formats = &scanoutFormats
+        }, {
+            .target_device = rendererDevice,
+            .formats = PRENDERERFORMATS
+        }
+    };
+
+    const wlr_linux_dmabuf_feedback_v1 FEEDBACK = {
+        .main_device = rendererDevice,
+        .tranches_len = sizeof(TRANCHES) / sizeof(TRANCHES[0]),
+        .tranches = TRANCHES
+    };
+
+    if (!wlr_linux_dmabuf_v1_set_surface_feedback(g_pCompositor->m_sWLRLinuxDMABuf, g_pXWaylandManager->getWindowSurface(pWindow), &FEEDBACK)) {
+        Debug::log(ERR, "Error in scanout mode setting: wlr_linux_dmabuf_v1_set_surface_feedback returned false.");
+    }
+
+    wlr_drm_format_set_finish(&scanoutFormats);
+
+    Debug::log(LOG, "Scanout mode ON set for %x", pWindow);
+}
+
 void CHyprRenderer::outputMgrApplyTest(wlr_output_configuration_v1* config, bool test) {
     wlr_output_configuration_head_v1* head;
     bool noError = true;
@@ -556,9 +742,17 @@ void CHyprRenderer::outputMgrApplyTest(wlr_output_configuration_v1* config, bool
 
         commandForCfg += std::to_string(head->state.x) + "x" + std::to_string(head->state.y) + "," + std::to_string(head->state.scale);
 
-        if (!test)
+        if (!test) {
             g_pConfigManager->parseKeyword("monitor", commandForCfg, true);
 
+            std::string transformStr = std::string(OUTPUT->name) + ",transform," + std::to_string((int)OUTPUT->transform);
+
+            const auto PMONITOR = g_pCompositor->getMonitorFromName(OUTPUT->name);
+
+            if (!PMONITOR || OUTPUT->transform != PMONITOR->transform)
+                g_pConfigManager->parseKeyword("monitor", transformStr);
+        }
+
         noError = wlr_output_test(OUTPUT);
 
         if (!noError)
@@ -756,9 +950,15 @@ void CHyprRenderer::arrangeLayersForMonitor(const int& monitor) {
     PMONITOR->vecReservedTopLeft = Vector2D(usableArea.x, usableArea.y) - PMONITOR->vecPosition;
     PMONITOR->vecReservedBottomRight = PMONITOR->vecSize - Vector2D(usableArea.width, usableArea.height) - PMONITOR->vecReservedTopLeft;
 
-    const auto ENTRY = g_pConfigManager->m_mAdditionalReservedAreas[PMONITOR->szName];
-    PMONITOR->vecReservedTopLeft = PMONITOR->vecReservedTopLeft + Vector2D(ENTRY.left, ENTRY.top);
-    PMONITOR->vecReservedBottomRight = PMONITOR->vecReservedBottomRight + Vector2D(ENTRY.right, ENTRY.bottom);
+    auto ADDITIONALRESERVED = g_pConfigManager->m_mAdditionalReservedAreas.find(PMONITOR->szName);
+    if (ADDITIONALRESERVED == g_pConfigManager->m_mAdditionalReservedAreas.end()) {
+        ADDITIONALRESERVED = g_pConfigManager->m_mAdditionalReservedAreas.find("");  // glob wildcard
+    }
+
+    if (ADDITIONALRESERVED != g_pConfigManager->m_mAdditionalReservedAreas.end()) {
+        PMONITOR->vecReservedTopLeft = PMONITOR->vecReservedTopLeft + Vector2D(ADDITIONALRESERVED->second.left, ADDITIONALRESERVED->second.top);
+        PMONITOR->vecReservedBottomRight = PMONITOR->vecReservedBottomRight + Vector2D(ADDITIONALRESERVED->second.right, ADDITIONALRESERVED->second.bottom);
+    }
 
     // damage the monitor if can
     if (PMONITOR->damage)
@@ -836,7 +1036,7 @@ void CHyprRenderer::damageMonitor(CMonitor* pMonitor) {
     if (g_pCompositor->m_bUnsafeState || pMonitor->isMirror())
         return;
 
-    wlr_box damageBox = {0, 0, pMonitor->vecPixelSize.x, pMonitor->vecPixelSize.y};
+    wlr_box damageBox = { 0, 0, INT16_MAX, INT16_MAX };
     pMonitor->addDamage(&damageBox);
 
     static auto *const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
@@ -940,7 +1140,8 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
             && DELTALESSTHAN(pMonitor->refreshRate, pMonitorRule->refreshRate, 1)
             && pMonitor->scale == pMonitorRule->scale
             && ((DELTALESSTHAN(pMonitor->vecPosition.x, pMonitorRule->offset.x, 1) && DELTALESSTHAN(pMonitor->vecPosition.y, pMonitorRule->offset.y, 1)) || pMonitorRule->offset == Vector2D(-1, -1))
-            && pMonitor->transform == pMonitorRule->transform) {
+            && pMonitor->transform == pMonitorRule->transform
+            && pMonitorRule->enable10bit == pMonitor->enabled10bit) {
 
         Debug::log(LOG, "Not applying a new rule to %s because it's already applied!", pMonitor->szName.c_str());
         return true;
@@ -949,7 +1150,8 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
     wlr_output_set_scale(pMonitor->output, pMonitorRule->scale);
     pMonitor->scale = pMonitorRule->scale;
 
-    pMonitor->vecPosition = pMonitorRule->offset;
+    wlr_output_set_transform(pMonitor->output, pMonitorRule->transform);
+    pMonitor->transform = pMonitorRule->transform;
 
     // loop over modes and choose an appropriate one.
     if (pMonitorRule->resolution != Vector2D() && pMonitorRule->resolution != Vector2D(-1,-1) && pMonitorRule->resolution != Vector2D(-1,-2)) {
@@ -1145,23 +1347,37 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
         }
     }
 
-
-    wlr_output_set_transform(pMonitor->output, pMonitorRule->transform);
-    pMonitor->transform = pMonitorRule->transform;
+    pMonitor->vrrActive = pMonitor->output->pending.adaptive_sync_enabled;  // disabled here, will be tested in CConfigManager::ensureVRR()
 
     pMonitor->vecPixelSize = pMonitor->vecSize;
 
-    // Adaptive sync (VRR)
-    wlr_output_enable_adaptive_sync(pMonitor->output, 1);
+    if (pMonitorRule->enable10bit) {
+        // try 10b RGB
+        wlr_output_set_render_format(pMonitor->output, DRM_FORMAT_XRGB2101010);
+        pMonitor->enabled10bit = true;
 
-    if (!wlr_output_test(pMonitor->output)) {
-        Debug::log(LOG, "Pending output %s does not accept VRR.", pMonitor->output->name);
-        wlr_output_enable_adaptive_sync(pMonitor->output, 0);
+        if (!wlr_output_test(pMonitor->output)) {
+            Debug::log(ERR, "Output %s -> 10 bit enabled, but failed format DRM_FORMAT_XRGB2101010. Trying BGR.", pMonitor->output->name);
+
+            wlr_output_set_render_format(pMonitor->output, DRM_FORMAT_XBGR2101010);
+
+            if (!wlr_output_test(pMonitor->output)) {
+                Debug::log(ERR, "Output %s -> 10 bit enabled, but failed format DRM_FORMAT_XBGR2101010. Falling back to 8 bit.", pMonitor->output->name);
+
+                wlr_output_set_render_format(pMonitor->output, DRM_FORMAT_XRGB8888);
+            } else {
+                Debug::log(LOG, "10bit format DRM_FORMAT_XBGR2101010 succeeded for output %s", pMonitor->output->name);
+            }
+        } else {
+            Debug::log(LOG, "10bit format DRM_FORMAT_XRGB2101010 succeeded for output %s", pMonitor->output->name);
+        }
+    } else {
+        wlr_output_set_render_format(pMonitor->output, DRM_FORMAT_XRGB8888);
+        pMonitor->enabled10bit = false;
     }
 
     if (!wlr_output_commit(pMonitor->output)) {
         Debug::log(ERR, "Couldn't commit output named %s", pMonitor->output->name);
-        return true;
     }
 
     int x, y;
@@ -1169,7 +1385,14 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
     pMonitor->vecSize = (Vector2D(x, y) / pMonitor->scale).floor();
     pMonitor->vecTransformedSize = Vector2D(x,y);
 
-    if (pMonitorRule->offset == Vector2D(-1, -1)) {
+    if (pMonitor->createdByUser) {
+        wlr_box transformedBox = { 0, 0, (int)pMonitor->vecTransformedSize.x, (int)pMonitor->vecTransformedSize.y };
+        wlr_box_transform(&transformedBox, &transformedBox, wlr_output_transform_invert(pMonitor->output->transform), (int)pMonitor->vecTransformedSize.x, (int)pMonitor->vecTransformedSize.y);
+
+        pMonitor->vecPixelSize = Vector2D(transformedBox.width, transformedBox.height);
+    }
+
+    if (pMonitorRule->offset == Vector2D(-1, -1) && pMonitor->vecPosition == Vector2D(-1, -1)) {
         // let's find manually a sensible position for it, to the right.
         Vector2D finalPos;
 
@@ -1183,18 +1406,15 @@ bool CHyprRenderer::applyMonitorRule(CMonitor* pMonitor, SMonitorRule* pMonitorR
         }
 
         pMonitor->vecPosition = finalPos;
+    } else if (pMonitorRule->offset != Vector2D(-1, -1)) {
+        pMonitor->vecPosition = pMonitorRule->offset;
     }
 
-    if (!pMonitor->isMirror())
-        wlr_output_layout_add(g_pCompositor->m_sWLROutputLayout, pMonitor->output, (int)pMonitor->vecPosition.x, (int)pMonitor->vecPosition.y);
-
-    wlr_output_enable(pMonitor->output, true);
-
     // update renderer (here because it will call rollback, so we cannot do this before committing)
     g_pHyprOpenGL->destroyMonitorResources(pMonitor);
 
     // updato wlroots
-    Events::listener_change(nullptr, nullptr);
+    wlr_output_layout_add(g_pCompositor->m_sWLROutputLayout, pMonitor->output, (int)pMonitor->vecPosition.x, (int)pMonitor->vecPosition.y);
 
     // updato us
     arrangeLayersForMonitor(pMonitor->ID);

src/render/Renderer.hpp

@@ -23,6 +23,8 @@ enum eRenderPassMode {
     RENDER_PASS_POPUP
 };
 
+class CToplevelExportProtocolManager;
+
 class CHyprRenderer {
 public:
 
@@ -44,13 +46,18 @@ public:
     void                calculateUVForWindowSurface(CWindow*, wlr_surface*, bool main = false);
 
     bool                m_bWindowRequestedCursorHide = false;
+    bool                m_bBlockSurfaceFeedback = false;
+    CWindow*            m_pLastScanout = nullptr;
 
     DAMAGETRACKINGMODES damageTrackingModeFromStr(const std::string&);
 
+    bool                attemptDirectScanout(CMonitor*);
+    void                setWindowScanoutMode(CWindow*);
+
 private:
     void                arrangeLayerArray(CMonitor*, const std::vector<std::unique_ptr<SLayerSurface>>&, bool, wlr_box*);
     void                renderWorkspaceWithFullscreenWindow(CMonitor*, CWorkspace*, timespec*);
-    void                renderWindow(CWindow*, CMonitor*, timespec*, bool, eRenderPassMode);
+    void                renderWindow(CWindow*, CMonitor*, timespec*, bool, eRenderPassMode, bool ignorePosition = false, bool ignoreAllGeometry = false);
     void                renderLayer(SLayerSurface*, CMonitor*, timespec*);
     void                renderDragIcon(CMonitor*, timespec*);
     void                renderIMEPopup(SIMEPopup*, CMonitor*, timespec*);
@@ -59,6 +66,7 @@ private:
 
 
     friend class CHyprOpenGLImpl;
+    friend class CToplevelExportProtocolManager;
 };
 
 inline std::unique_ptr<CHyprRenderer> g_pHyprRenderer;

src/render/Shader.cpp

@@ -14,7 +14,11 @@ GLint CShader::getUniformLocation(const std::string& unif) {
 
 CShader::~CShader() {
     // destroy shader
-    if (program) {
-        glDeleteProgram(program);
-    }
+    destroy();
+}
+
+void CShader::destroy() {
+    glDeleteProgram(program);
+
+    program = 0;
 }

src/render/Shader.hpp

@@ -19,6 +19,7 @@ public:
     GLint topLeft;
     GLint bottomRight;
     GLint fullSize;
+    GLint fullSizeUntransformed;
     GLint radius;
     GLint primitiveMultisample;
 
@@ -32,8 +33,14 @@ public:
     GLint applyTint;
     GLint tint;
 
+    GLint gradient;
+    GLint gradientLength;
+    GLint angle;
+
     GLint getUniformLocation(const std::string&);
 
+    void destroy();
+
 private:
     std::unordered_map<std::string, GLint> m_muUniforms;
 };

src/render/decorations/CHyprDropShadowDecoration.cpp

@@ -59,10 +59,14 @@ void CHyprDropShadowDecoration::draw(CMonitor* pMonitor, float a, const Vector2D
     if (!m_pWindow->m_sSpecialRenderData.decorate)
         return;
 
+    if (m_pWindow->m_sAdditionalConfigData.forceNoShadow)
+        return;
+
     static auto *const PSHADOWS = &g_pConfigManager->getConfigValuePtr("decoration:drop_shadow")->intValue;
     static auto *const PSHADOWSIZE = &g_pConfigManager->getConfigValuePtr("decoration:shadow_range")->intValue;
     static auto *const PROUNDING = &g_pConfigManager->getConfigValuePtr("decoration:rounding")->intValue;
     static auto *const PSHADOWIGNOREWINDOW = &g_pConfigManager->getConfigValuePtr("decoration:shadow_ignore_window")->intValue;
+    static auto *const PSHADOWSCALE = &g_pConfigManager->getConfigValuePtr("decoration:shadow_scale")->floatValue;
     static auto *const PSHADOWOFFSET = &g_pConfigManager->getConfigValuePtr("decoration:shadow_offset")->vecValue;
 
     if (*PSHADOWS != 1)
@@ -70,22 +74,48 @@ void CHyprDropShadowDecoration::draw(CMonitor* pMonitor, float a, const Vector2D
 
     const auto ROUNDING = !m_pWindow->m_sSpecialRenderData.rounding ? 0 : (m_pWindow->m_sAdditionalConfigData.rounding == -1 ? *PROUNDING : m_pWindow->m_sAdditionalConfigData.rounding);
 
-    // update the extents
-    m_seExtents = {{*PSHADOWSIZE + 2 - PSHADOWOFFSET->x, *PSHADOWSIZE + 2 - PSHADOWOFFSET->y}, {*PSHADOWSIZE + 2 + PSHADOWOFFSET->x, *PSHADOWSIZE + 2 + PSHADOWOFFSET->y}};
-
     // draw the shadow
-    wlr_box fullBox = {m_vLastWindowPos.x - m_seExtents.topLeft.x + 2, m_vLastWindowPos.y - m_seExtents.topLeft.y + 2, m_vLastWindowSize.x + m_seExtents.topLeft.x + m_seExtents.bottomRight.x - 4, m_vLastWindowSize.y + m_seExtents.topLeft.y + m_seExtents.bottomRight.y - 4};
+    wlr_box fullBox = { m_vLastWindowPos.x - *PSHADOWSIZE, m_vLastWindowPos.y - *PSHADOWSIZE,
+                        m_vLastWindowSize.x + 2.0 * *PSHADOWSIZE, m_vLastWindowSize.y + 2.0 * *PSHADOWSIZE };
 
     fullBox.x -= pMonitor->vecPosition.x;
     fullBox.y -= pMonitor->vecPosition.y;
 
+    const float SHADOWSCALE = std::clamp(*PSHADOWSCALE, 0.f, 1.f);
+
+    // scale the box in relation to the center of the box
+    const Vector2D NEWSIZE = Vector2D { fullBox.width, fullBox.height } * SHADOWSCALE;
+    fullBox.width = NEWSIZE.x;
+    fullBox.height = NEWSIZE.y;
+
+    if (PSHADOWOFFSET->x < 0) {
+        fullBox.x += PSHADOWOFFSET->x;
+    } else if (PSHADOWOFFSET->x > 0) {
+        fullBox.x = m_vLastWindowPos.x + m_vLastWindowSize.x - fullBox.width + (SHADOWSCALE * *PSHADOWSIZE) + PSHADOWOFFSET->x - pMonitor->vecPosition.x;
+    } else {
+        fullBox.x += ((m_vLastWindowSize.x + 2.0 * *PSHADOWSIZE) - NEWSIZE.x) / 2.0;
+    }
+
+    if (PSHADOWOFFSET->y < 0) {
+        fullBox.y += PSHADOWOFFSET->y;
+    } else if (PSHADOWOFFSET->y > 0) {
+        fullBox.y = m_vLastWindowPos.y + m_vLastWindowSize.y - fullBox.height + (SHADOWSCALE * *PSHADOWSIZE) + PSHADOWOFFSET->y - pMonitor->vecPosition.y;
+    } else {
+        fullBox.y += ((m_vLastWindowSize.y + 2.0 * *PSHADOWSIZE) - NEWSIZE.y) / 2.0;
+    }
+
+    m_seExtents = { { m_vLastWindowPos.x - fullBox.x - pMonitor->vecPosition.x + 2,
+                    m_vLastWindowPos.y - fullBox.y - pMonitor->vecPosition.y + 2},
+                    { fullBox.x + fullBox.width + pMonitor->vecPosition.x - m_vLastWindowPos.x - m_vLastWindowSize.x + 2,
+                    fullBox.y + fullBox.height + pMonitor->vecPosition.y - m_vLastWindowPos.y - m_vLastWindowSize.y + 2} };
+
     fullBox.x += offset.x;
     fullBox.y += offset.y;
 
     if (fullBox.width < 1 || fullBox.height < 1)
-        return; // don't draw invisible shadows
+        return;  // don't draw invisible shadows
 
-    g_pHyprOpenGL->scissor((wlr_box *)nullptr);
+    g_pHyprOpenGL->scissor((wlr_box*)nullptr);
 
     if (*PSHADOWIGNOREWINDOW) {
         glEnable(GL_STENCIL_TEST);

src/render/decorations/CHyprGroupBarDecoration.cpp

@@ -67,7 +67,7 @@ void CHyprGroupBarDecoration::draw(CMonitor* pMonitor, float a, const Vector2D&
     // get how many bars we will draw
     int barsToDraw = m_dwGroupMembers.size();
 
-    if (barsToDraw < 1 || m_pWindow->m_bHidden || !g_pCompositor->windowValidMapped(m_pWindow))
+    if (barsToDraw < 1 || m_pWindow->isHidden() || !g_pCompositor->windowValidMapped(m_pWindow))
         return;
 
     if (!m_pWindow->m_sSpecialRenderData.decorate)

src/render/shaders/Border.hpp

@@ -9,82 +9,111 @@ varying vec4 v_color;
 varying vec2 v_texcoord;
 
 uniform vec2 topLeft;
-uniform vec2 bottomRight;
 uniform vec2 fullSize;
+uniform vec2 fullSizeUntransformed;
 uniform float radius;
 uniform float thick;
 uniform int primitiveMultisample;
 
-float getOpacityForPixAndCorner(vec2 pix, vec2 corner) {
+uniform vec4 gradient[10];
+uniform int gradientLength;
+uniform float angle;
+uniform float alpha;
 
-    if (primitiveMultisample == 0) {
-        float dis = distance(pix + vec2(0.5, 0.5), corner);
-        return dis < radius && dis > radius - thick ? 1.0 : 0.0;
+vec4 getColorForCoord(vec2 normalizedCoord) {
+    if (gradientLength < 2)
+        return gradient[0];
+
+    float finalAng = 0.0;
+
+    if (angle > 4.71 /* 270 deg */) {
+        normalizedCoord[1] = 1.0 - normalizedCoord[1];
+        finalAng = 6.28 - angle;
+    } else if (angle > 3.14 /* 180 deg */) {
+        normalizedCoord[0] = 1.0 - normalizedCoord[0];
+        normalizedCoord[1] = 1.0 - normalizedCoord[1];
+        finalAng = angle - 3.14;
+    } else if (angle > 1.57 /* 90 deg */) {
+        normalizedCoord[0] = 1.0 - normalizedCoord[0];
+        finalAng = 3.14 - angle;
+    } else {
+        finalAng = angle;
     }
 
-    float distance1 = distance(pix + vec2(0.25, 0.25), corner);
-    float distance2 = distance(pix + vec2(0.75, 0.25), corner);
-    float distance3 = distance(pix + vec2(0.25, 0.75), corner);
-    float distance4 = distance(pix + vec2(0.75, 0.75), corner);
+    float sine = sin(finalAng);
 
-    float v1 = distance1 < radius && distance1 > radius - thick ? 1.0 : 0.0;
-    float v2 = distance2 < radius && distance2 > radius - thick ? 1.0 : 0.0;
-    float v3 = distance3 < radius && distance3 > radius - thick ? 1.0 : 0.0;
-    float v4 = distance4 < radius && distance4 > radius - thick ? 1.0 : 0.0;
+    float progress = (normalizedCoord[1] * sine + normalizedCoord[0] * (1.0 - sine)) * float(gradientLength - 1);
+    int bottom = int(floor(progress));
+    int top = bottom + 1;
 
-    return (v1 + v2 + v3 + v4) / 4.0;
+    return gradient[top] * (progress - float(bottom)) + gradient[bottom] * (float(top) - progress);
 }
 
 void main() {
 
-    vec2 pixCoord = fullSize * v_texcoord;
+    highp vec2 pixCoord = vec2(gl_FragCoord);
+    highp vec2 originalPixCoord = v_texcoord;
+    originalPixCoord *= fullSizeUntransformed;
 
-    vec4 pixColor = v_color;
+    vec4 pixColor = vec4(1.0, 1.0, 1.0, 1.0);
 
     bool done = false;
 
-    // check for edges
-    if (pixCoord[0] < topLeft[0]) {
-        if (pixCoord[1] < topLeft[1]) {
-            // top left
-            pixColor[3] = pixColor[3] * getOpacityForPixAndCorner(pixCoord, topLeft + vec2(1,1));
-            done = true;
-        } else if (pixCoord[1] > bottomRight[1]) {
-            // bottom left
-            pixColor[3] = pixColor[3] * getOpacityForPixAndCorner(pixCoord, vec2(topLeft[0] + 1.0, bottomRight[1]));
-            done = true;
-        }
-    } else if (pixCoord[0] > bottomRight[0]) {
-        if (pixCoord[1] < topLeft[1]) {
-            // top right
-            pixColor[3] = pixColor[3] * getOpacityForPixAndCorner(pixCoord, vec2(bottomRight[0], topLeft[1] + 1.0));
-            done = true;
-        } else if (pixCoord[1] > bottomRight[1]) {
-            // bottom right
-            pixColor[3] = pixColor[3] * getOpacityForPixAndCorner(pixCoord, bottomRight);
-            done = true;
-        }
+    pixCoord -= topLeft + fullSize * 0.5;
+    pixCoord *= vec2(lessThan(pixCoord, vec2(0.0))) * -2.0 + 1.0;
+    pixCoord -= fullSize * 0.5 - radius;
+
+    if (min(pixCoord.x, pixCoord.y) > 0.0 && radius > 0.0) {
+
+	    float dist = length(pixCoord);
+
+	    if (dist > radius + 1.0 || dist < radius - thick - 1.0)
+	        discard;
+
+	    if (primitiveMultisample == 1 && (dist > radius - 1.0 || dist < radius - thick + 1.0)) {
+	        float distances = 0.0;
+            float len = length(pixCoord + vec2(0.25, 0.25));
+	        distances += float(len < radius && len > radius - thick);
+            len = length(pixCoord + vec2(0.75, 0.25));
+            distances += float(len < radius && len > radius - thick);
+            len = length(pixCoord + vec2(0.25, 0.75));
+            distances += float(len < radius && len > radius - thick);
+            len = length(pixCoord + vec2(0.75, 0.75));
+            distances += float(len < radius && len > radius - thick);
+
+	        if (distances == 0.0)
+		        discard;
+
+	        distances /= 4.0;
+
+	        pixColor[3] *= distances;
+        } else if (dist > radius || dist < radius - thick)
+            discard;
+
+        done = true;
     }
 
     // now check for other shit
     if (!done) {
         // distance to all straight bb borders
-        float distanceT = pixCoord[1];
-        float distanceB = fullSize[1] - pixCoord[1];
-        float distanceL = pixCoord[0];
-        float distanceR = fullSize[0] - pixCoord[0];
+        float distanceT = originalPixCoord[1];
+        float distanceB = fullSizeUntransformed[1] - originalPixCoord[1];
+        float distanceL = originalPixCoord[0];
+        float distanceR = fullSizeUntransformed[0] - originalPixCoord[0];
 
         // get the smallest
         float smallest = min(min(distanceT, distanceB), min(distanceL, distanceR));
 
-        if (smallest > thick) {
-            discard; return;
-        }
+        if (smallest > thick)
+            discard;
     }
 
-    if (pixColor[3] == 0.0) {
-        discard; return;
-    }
+    if (pixColor[3] == 0.0)
+        discard;
+
+    float pixColor3 = pixColor[3];
+    pixColor = getColorForCoord(v_texcoord);
+    pixColor[3] *= alpha * pixColor3;
 
     gl_FragColor = pixColor;
 }

src/render/shaders/Textures.hpp

@@ -13,24 +13,24 @@ inline static constexpr auto ROUNDED_SHADER_FUNC = [](const std::string colorVar
 
     if (pixCoord.x + pixCoord.y > radius) {
 
-	float dist = length(pixCoord);
+	    float dist = length(pixCoord);
 
-	if (dist > radius)
-	    discard;
+	    if (dist > radius)
+	        discard;
 
-	if (primitiveMultisample == 1 && dist > radius - 1.0) {
-	    float distances = 0.0;
-	    distances += float(length(pixCoord + vec2(0.25, 0.25)) < radius);
-	    distances += float(length(pixCoord + vec2(0.75, 0.25)) < radius);
-	    distances += float(length(pixCoord + vec2(0.25, 0.75)) < radius);
-	    distances += float(length(pixCoord + vec2(0.75, 0.75)) < radius);
+	    if (primitiveMultisample == 1 && dist > radius - 1.0) {
+	        float distances = 0.0;
+	        distances += float(length(pixCoord + vec2(0.25, 0.25)) < radius);
+	        distances += float(length(pixCoord + vec2(0.75, 0.25)) < radius);
+	        distances += float(length(pixCoord + vec2(0.25, 0.75)) < radius);
+	        distances += float(length(pixCoord + vec2(0.75, 0.75)) < radius);
 
-	    if (distances == 0.0)
-		discard;
+	        if (distances == 0.0)
+		        discard;
 
-	    distances /= 4.0;
+	        distances /= 4.0;
 
-	    )#" + colorVarName + R"#( = )#" + colorVarName + R"#( * distances;
+	        )#" + colorVarName + R"#( = )#" + colorVarName + R"#( * distances;
         }
 
     }