props: bump ver to v0.31.0

* Replace find() with C++20 starts_with() and ends_with()

* Replace find() with C++20 contains()

.github/workflows/ci.yaml

@@ -39,7 +39,7 @@ jobs:
           mkdir hyprland/assets
           cp ./LICENSE hyprland/
           cp build/Hyprland hyprland/
-          cp hyprctl/hyprctl hyprland/
+          cp build/hyprctl/hyprctl hyprland/
           cp subprojects/wlroots/build/libwlroots.so.12032 hyprland/
           cp build/Hyprland hyprland/
           cp -r example/ hyprland/
@@ -105,4 +105,4 @@ jobs:
       - 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
+        run: make release

.github/workflows/man-update.yaml

@@ -15,13 +15,15 @@ jobs:
     steps:
     - name: Install deps
       run: sudo apt install pandoc
+
     - name: Clone repository
       uses: actions/checkout@v3
-      # Not needed
-      # with:
-      #   submodules: recursive
+      with:
+        token: ${{ secrets.PAT }}
+
     - name: Build man pages
       run: make man
+
     - uses: stefanzweifel/git-auto-commit-action@v4
       name: Commit
       with:

.github/workflows/nix-build.yaml

@@ -1,26 +0,0 @@
-name: Build Hyprland (Nix)
-
-on: [push, pull_request, workflow_dispatch]
-jobs:
-  nix:
-    name: "Build Hyprland (Nix)"
-    runs-on: ubuntu-latest
-    steps:
-    - name: Clone repository
-      uses: actions/checkout@v3
-      with:
-        submodules: recursive
-    - name: Install nix
-      uses: cachix/install-nix-action@v20
-      with:
-        install_url: https://nixos.org/nix/install
-        extra_nix_config: |
-          auto-optimise-store = true
-          access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
-          experimental-features = nix-command flakes
-    - uses: cachix/cachix-action@v12
-      with:
-        name: hyprland
-        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
-    - name: Build packages
-      run: nix flake check --print-build-logs --accept-flake-config

.github/workflows/nix-build.yml

@@ -0,0 +1,30 @@
+on:
+  workflow_call:
+    secrets:
+      CACHIX_AUTH_TOKEN:
+        required: false
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        package:
+          - hyprland
+          - hyprland-nvidia
+          - xdg-desktop-portal-hyprland
+
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clone repository
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.ref }}
+
+      - uses: DeterminateSystems/nix-installer-action@main
+      - uses: DeterminateSystems/magic-nix-cache-action@main
+      - uses: cachix/cachix-action@v12
+        with:
+          name: hyprland
+          authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
+
+      - run: nix build -L ${{ matrix.command }}

.github/workflows/nix-ci.yml

@@ -0,0 +1,15 @@
+name: Nix
+
+on: [push, pull_request, workflow_dispatch]
+
+jobs:
+  wlroots:
+    if: github.event_name != 'pull_request'
+    uses: ./.github/workflows/nix-update-wlroots.yml
+    secrets: inherit
+
+  build:
+    if: always() && !cancelled() && !contains(needs.*.result, 'failure')
+    needs: wlroots
+    uses: ./.github/workflows/nix-build.yml
+    secrets: inherit

.github/workflows/nix-update-inputs.yaml

@@ -1,40 +0,0 @@
-name: "Nix update"
-
-on:
-  schedule:
-    - cron: '0 0 * * *'
-
-jobs:
-  update:
-    name: "inputs"
-    runs-on: ubuntu-latest
-    steps:
-    - name: Clone repository
-      uses: actions/checkout@v3
-
-    - name: Install nix
-      uses: cachix/install-nix-action@v20
-      with:
-        install_url: https://nixos.org/nix/install
-        extra_nix_config: |
-          auto-optimise-store = true
-          access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
-          experimental-features = nix-command flakes
-
-    - name: Update lockfile
-      run: nix/update-inputs.sh
-
-    - uses: cachix/cachix-action@v12
-      with:
-        name: hyprland
-        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
-
-    - name: Build packages
-      run: nix flake check --print-build-logs --accept-flake-config
-
-    - name: Build Waybar-Hyprland
-      run: nix build .#waybar-hyprland --print-build-logs
-
-    - uses: stefanzweifel/git-auto-commit-action@v4
-      with:
-        commit_message: "Nix: bump inputs"

.github/workflows/nix-update-inputs.yml

@@ -0,0 +1,29 @@
+name: Nix
+
+on:
+  schedule:
+    - cron: '0 0 * * *' # check daily
+
+jobs:
+  update:
+    name: inputs
+    runs-on: ubuntu-latest
+    steps:
+      - name: Clone repository
+        uses: actions/checkout@v3
+        with:
+          token: ${{ secrets.PAT }}
+
+      - uses: DeterminateSystems/nix-installer-action@main
+      - name: Update inputs
+        run: nix/update-inputs.sh
+
+      - name: Commit
+        uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_message: "[gha] Nix: update inputs"
+
+  update-build:
+    needs: update
+    uses: ./.github/workflows/nix-build.yml
+    secrets: inherit

.github/workflows/nix-update-wlroots.yaml

@@ -1,35 +0,0 @@
-name: "Nix update"
-
-on: [push, workflow_dispatch]
-
-jobs:
-  update:
-    name: "wlroots"
-    runs-on: ubuntu-latest
-    steps:
-    - name: Clone repository
-      uses: actions/checkout@v3
-
-    - name: Install nix
-      uses: cachix/install-nix-action@v20
-      with:
-        install_url: https://nixos.org/nix/install
-        extra_nix_config: |
-          auto-optimise-store = true
-          access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
-          experimental-features = nix-command flakes
-
-    - name: Update lockfile
-      run: nix/update-wlroots.sh
-
-    - uses: cachix/cachix-action@v12
-      with:
-        name: hyprland
-        authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}'
-
-    - name: Build packages
-      run: nix flake check --print-build-logs --accept-flake-config
-
-    - uses: stefanzweifel/git-auto-commit-action@v4
-      with:
-        commit_message: "Nix: bump wlroots"

.github/workflows/nix-update-wlroots.yml

@@ -0,0 +1,26 @@
+name: Nix
+
+on:
+  workflow_call:
+    secrets:
+      PAT:
+        required: true
+
+jobs:
+  update:
+    name: wlroots
+    runs-on: ubuntu-latest
+    steps:
+    - name: Clone repository
+      uses: actions/checkout@v3
+      with:
+        token: ${{ secrets.PAT }}
+
+    - uses: DeterminateSystems/nix-installer-action@main
+    - name: Update lockfile
+      run: nix/update-wlroots.sh
+
+    - name: Commit
+      uses: stefanzweifel/git-auto-commit-action@v4
+      with:
+        commit_message: "[gha] Nix: update wlroots"

.github/workflows/release.yaml

@@ -15,10 +15,15 @@ jobs:
         with:
           submodules: recursive
 
+      - name: Generate version
+        id: genversion
+        run: |
+          bash -c scripts/generateVersion.sh
+          mv scripts/generateVersion.sh scripts/generateVersion.sh.bak
+
       - name: Create tarball with submodules
         id: tar
         run: |
-          sed -i "1s/^/#define GIT_COMMIT_HASH \"$(git rev-parse HEAD)\"\n#define GIT_TAG \"$(git describe --tags)\"\n/" ./src/defines.hpp
           mkdir hyprland-source; mv ./* ./hyprland-source || tar -czv --owner=0 --group=0 --no-same-owner --no-same-permissions -f source.tar.gz *
 
       - id: whatrelease

.gitignore

@@ -29,3 +29,5 @@ gmon.out
 *.tar.gz
 
 PKGBUILD
+
+src/version.h

CMakeLists.txt

@@ -21,37 +21,32 @@ message(STATUS "Gathering git info")
 # Get git info
 # hash and branch
 execute_process(
-    COMMAND git rev-parse --abbrev-ref HEAD
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-    OUTPUT_VARIABLE GIT_BRANCH
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-execute_process(
-    COMMAND git rev-parse HEAD
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-    OUTPUT_VARIABLE GIT_COMMIT_HASH
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-execute_process(
-    COMMAND sh -c "git show ${GIT_COMMIT_HASH} | head -n 5 | tail -n 1 | sed -e 's/#//g' -e 's/\"//g'"
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-    OUTPUT_VARIABLE GIT_COMMIT_MESSAGE
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-execute_process(
-    COMMAND sh -c "git diff-index --quiet HEAD -- || echo \"dirty\""
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-    OUTPUT_VARIABLE GIT_DIRTY
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
-
-execute_process(
-    COMMAND sh -c "git describe --tags"
-    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-    OUTPUT_VARIABLE GIT_TAG
-    OUTPUT_STRIP_TRAILING_WHITESPACE)
+    COMMAND ./scripts/generateVersion.sh
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
 #
 #
 
+# udis
+add_subdirectory("subprojects/udis86")
+
+# wlroots
+message(STATUS "Setting up wlroots")
+
+include(ExternalProject)
+string(TOLOWER ${CMAKE_BUILD_TYPE} BUILDTYPE_LOWER)
+ExternalProject_Add(
+    wlroots
+    PREFIX ${CMAKE_SOURCE_DIR}/subprojects/wlroots
+    SOURCE_DIR ${CMAKE_SOURCE_DIR}/subprojects/wlroots
+    PATCH_COMMAND sed -E -i -e "s/(soversion = 12)([^032]|$$)/soversion = 12032/g" meson.build
+    CONFIGURE_COMMAND meson setup build --buildtype=${BUILDTYPE_LOWER} -Dwerror=false -Dexamples=false -Drenderers=gles2 $<IF:$<BOOL:${WITH_ASAN}>,-Db_sanitize=address,-Db_sanitize=none> && meson setup build --buildtype=${BUILDTYPE_LOWER} -Dwerror=false -Dexamples=false -Drenderers=gles2 $<IF:$<BOOL:${WITH_ASAN}>,-Db_sanitize=address,-Db_sanitize=none> --reconfigure
+    BUILD_COMMAND ninja -C build
+    BUILD_ALWAYS true
+    BUILD_IN_SOURCE true
+    BUILD_BYPRODUCTS ${CMAKE_SOURCE_DIR}/subprojects/wlroots/build/libwlroots.so.12032
+    INSTALL_COMMAND echo "wlroots: install not needed"
+)
+
 find_program(WaylandScanner NAMES wayland-scanner)
 message(STATUS "Found WaylandScanner at ${WaylandScanner}")
 execute_process(
@@ -71,6 +66,7 @@ endif()
 
 include_directories(
   .
+  "src/"
   "subprojects/wlroots/include/"
   "subprojects/wlroots/build/include/"
   "subprojects/udis86/"
@@ -92,6 +88,7 @@ pkg_check_modules(deps REQUIRED IMPORTED_TARGET wayland-server wayland-client wa
 file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
 
 add_executable(Hyprland ${SRCFILES})
+add_dependencies(Hyprland wlroots)
 
 if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
     message(STATUS "Setting debug flags")
@@ -122,6 +119,12 @@ if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
     add_link_options(-pg -no-pie -fno-builtin)
 endif()
 
+check_include_file("execinfo.h" EXECINFOH)
+if(EXECINFOH)
+    message(STATUS "Configuration supports execinfo")
+    add_compile_definitions(HAS_EXECINFO)
+endif()
+
 include(CheckLibraryExists)
 check_library_exists(execinfo backtrace "" HAVE_LIBEXECINFO)
 if(HAVE_LIBEXECINFO)
@@ -146,13 +149,18 @@ if(NO_SYSTEMD)
     message(STATUS "SYSTEMD support is disabled...")
 else()
     message(STATUS "SYSTEMD support is requested (NO_SYSTEMD not defined) checking deps...")
-    pkg_check_modules(LIBSYSTEMD libsystemd)
     check_include_file("systemd/sd-daemon.h" SYSTEMDH)
-    if(LIBSYSTEMD_FOUND AND SYSTEMDH)
-        add_compile_definitions(USES_SYSTEMD)
-        target_link_libraries(Hyprland "${LIBSYSTEMD_LIBRARIES}")
+    if(SYSTEMDH)
+        pkg_check_modules(LIBSYSTEMD libsystemd)
+        if (LIBSYSTEMD_FOUND)
+            add_compile_definitions(USES_SYSTEMD)
+            target_link_libraries(Hyprland "${LIBSYSTEMD_LIBRARIES}")
+            message(STATUS "Systemd found")
+        else()
+            message(WARNING "Systemd support requested but systemd libraries were not found")
+        endif()
     else()
-        message(WARNING "Systemd support requested but libsystemd or systemd headers were not found")
+        message(WARNING "Systemd support requested but systemd headers were not found")
     endif()
 endif()
 
@@ -168,6 +176,10 @@ set(CPACK_PROJECT_NAME ${PROJECT_NAME})
 set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
 include(CPack)
 
+message(STATUS "Setting precompiled headers")
+
+target_precompile_headers(Hyprland PRIVATE $<$<COMPILE_LANGUAGE:CXX>:src/pch/pch.hpp>)
+
 message(STATUS "Setting link libraries")
 
 target_link_libraries(Hyprland rt PkgConfig::deps)
@@ -197,10 +209,9 @@ target_link_libraries(Hyprland
         OpenGL::EGL
         OpenGL::GL
         Threads::Threads
-        ${CMAKE_SOURCE_DIR}/subprojects/udis86/build/libudis86/liblibudis86.a
+        libudis86
 )
 
-protocol("protocols/ext-workspace-unstable-v1.xml" "ext-workspace-unstable-v1" true)
 protocol("protocols/idle.xml" "idle" true)
 protocol("protocols/pointer-constraints-unstable-v1.xml" "pointer-constraints-unstable-v1" true)
 protocol("protocols/tablet-unstable-v2.xml" "tablet-unstable-v2" true)
@@ -214,5 +225,9 @@ protocol("stable/xdg-shell/xdg-shell.xml" "xdg-shell" false)
 protocol("unstable/linux-dmabuf/linux-dmabuf-unstable-v1.xml" "linux-dmabuf-unstable-v1" false)
 protocol("unstable/xdg-output/xdg-output-unstable-v1.xml" "xdg-output-unstable-v1" false)
 protocol("staging/fractional-scale/fractional-scale-v1.xml" "fractional-scale-v1" false)
+protocol("staging/tearing-control/tearing-control-v1.xml" "tearing-control-v1" false)
 protocol("unstable/text-input/text-input-unstable-v1.xml" "text-input-unstable-v1" false)
 protocol("staging/cursor-shape/cursor-shape-v1.xml" "cursor-shape-v1" false)
+
+# hyprctl
+add_subdirectory(hyprctl)

CODE_OF_CONDUCT.md

@@ -0,0 +1,96 @@
+## Goal
+
+Our goal is to provide a space where it is safe for everyone to contribute to,
+and get support for, open-source software in a respectful and cooperative
+manner.
+
+We value all contributions and want to make this organization and its
+surrounding community a place for everyone.
+
+As members, contributors, and everyone else who may participate in the
+development, we strive to keep the entire experience civil.
+
+## Standards
+
+Our community standards exist in order to make sure everyone feels comfortable
+contributing to the project(s) together.
+
+Our standards are:
+ - Do not harass, attack, or in any other way discriminate against anyone, including
+for their protected traits, including, but not limited to, sex, religion, race,
+appearance, gender, identity, nationality, sexuality, etc.
+ - Do not go off-topic, do not post spam.
+ - Treat everyone with respect.
+
+Examples of breaking each rule respectively include:
+ - Harassment, bullying or inappropriate jokes about another person.
+ - Posting distasteful imagery, trolling, or posting things unrelated to the topic at hand.
+ - Treating someone as worse because of their lack of understanding of an issue.
+
+## Enforcement
+
+Enforcement of this CoC is done by the members of the hyprwm organization.
+
+We, as the organization, will strive our best to keep this community civil and
+following the standards outlined above.
+
+### Reporting incidents
+
+If you believe an incident of breaking our standards has occurred, but nobody has
+taken appropriate action, you can privately contact the people responsible for dealing
+with such incidents in multiple ways:
+
+***E-Mail***
+ - `vaxry[at]vaxry.net`
+ - `mihai[at]fufexan.net`
+
+***Discord***
+ - `@vaxry`
+ - `@fufexan`
+
+***Matrix***
+ - `@vaxry:matrix.vaxry.net`
+ - `@fufexan:matrix.org`
+ 
+We, as members, guarantee your privacy and will not share those reports with anyone.
+
+## Enforcement Strategy
+
+Depending on the severity of the infraction, any action from the list below may be applied.
+Please keep in mind cases are reviewed on a per-case basis and members are the ultimate
+deciding factor in the type of punishment.
+
+If the matter would benefit from an outside opinion, a member might reach for more opinions
+from people unrelated to the organization, however, the final decision regarding the action
+to be taken is still up to the member.
+
+For example, if the matter at hand regards a representative of a marginalized group or minority,
+the member might ask for a first-hand opinion from another representative of such group.
+
+### Correction/Edit
+
+If your message is found to be misleading or poorly worded, a member might
+edit your message.
+
+### Warning/Deletion
+
+If your message is found inappropriate, a member might give you a public or private warning,
+and/or delete your message.
+
+### Mute
+
+If your message is disruptive, or you have been repeatedly violating the standards,
+a member might mute (or temporarily ban) you.
+
+### Ban
+
+If your message is hateful, very disruptive, or other, less serious infractions are repeated
+ignoring previous punishments, a member might ban you permanently.
+
+## Scope
+
+This CoC shall apply to all projects ran under the `hyprwm` organization and all _official_ communities
+outside of GitHub.
+
+However, it is worth noting that official communities outside of GitHub might have their own,
+additional sets of rules.

Makefile

@@ -3,67 +3,56 @@ PREFIX = /usr/local
 legacyrenderer:
 	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DLEGACY_RENDERER:BOOL=true -S . -B ./build -G Ninja
 	cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
+	chmod -R 777 ./build
 
 legacyrendererdebug:
 	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -DLEGACY_RENDERER:BOOL=true -S . -B ./build -G Ninja
 	cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
+	chmod -R 777 ./build
 
 release:
 	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -S . -B ./build -G Ninja
 	cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
+	chmod -R 777 ./build
 
 debug:
 	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -S . -B ./build -G Ninja
 	cmake --build ./build --config Debug --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
+	chmod -R 777 ./build
 
 clear:
 	rm -rf build
 	rm -f ./protocols/*-protocol.h ./protocols/*-protocol.c
-	rm -f ./hyprctl/hyprctl
 	rm -rf ./subprojects/wlroots/build
 
 all:
+	@if [[ "$EUID" = 0 ]]; then echo -en "Avoid running $(MAKE) all as sudo.\n"; fi
 	$(MAKE) clear
-	$(MAKE) fixwlr
-	cd ./subprojects/wlroots && meson setup build/ --buildtype=release && ninja -C build/ && mkdir -p ${PREFIX}/lib/ && cp ./build/libwlroots.so.12032 ${PREFIX}/lib/ || echo "Could not install libwlroots to ${PREFIX}/lib/libwlroots.so.12032"
-	cd subprojects/udis86 && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -S . -B./build -G Ninja && cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
 	$(MAKE) release
-	$(MAKE) -C hyprctl all
 
 install:
-	$(MAKE) clear
-	$(MAKE) fixwlr
-	cd ./subprojects/wlroots && meson setup build/ --buildtype=release && ninja -C build/ && mkdir -p ${PREFIX}/lib/ && cp ./build/libwlroots.so.12032 ${PREFIX}/lib/ || echo "Could not install libwlroots to ${PREFIX}/lib/libwlroots.so.12032"
-	cd subprojects/udis86 && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -S . -B./build -G Ninja && cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF` && cd ../..
-	$(MAKE) release
-	$(MAKE) -C hyprctl all
+	@if [ ! -f ./build/Hyprland ]; then echo -en "You need to run $(MAKE) all first.\n" && exit 1; fi
+	@echo -en "!NOTE: Please note make install does not compile Hyprland and only installs the already built files."
 
 	mkdir -p ${PREFIX}/share/wayland-sessions
 	mkdir -p ${PREFIX}/bin
 	cp -f ./build/Hyprland ${PREFIX}/bin
-	cp -f ./hyprctl/hyprctl ${PREFIX}/bin
+	cp -f ./build/hyprctl/hyprctl ${PREFIX}/bin
+	chmod 755 ${PREFIX}/bin/Hyprland
+	chmod 755 ${PREFIX}/bin/hyprctl
 	if [ ! -f ${PREFIX}/share/wayland-sessions/hyprland.desktop ]; then cp ./example/hyprland.desktop ${PREFIX}/share/wayland-sessions; fi
 	mkdir -p ${PREFIX}/share/hyprland
 	cp ./assets/wall_* ${PREFIX}/share/hyprland
+	mkdir -p ${PREFIX}/share/xdg-desktop-portal
+	cp ./assets/hyprland-portals.conf ${PREFIX}/share/xdg-desktop-portal
 
 	mkdir -p ${PREFIX}/share/man/man1
 	install -m644 ./docs/*.1 ${PREFIX}/share/man/man1
 
-	mkdir -p ${PREFIX}/include/hyprland
-	mkdir -p ${PREFIX}/include/hyprland/protocols
-	mkdir -p ${PREFIX}/include/hyprland/wlroots
-	mkdir -p ${PREFIX}/share/pkgconfig
-	
-	find src -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland
-	cd subprojects/wlroots/include && find . -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland/wlroots && cd ../../..
-	cd subprojects/wlroots/build/include && find . -name '*.h*' -print0 | cpio --quiet -0dump ${PREFIX}/include/hyprland/wlroots && cd ../../../..
-	cp ./protocols/*-protocol.h ${PREFIX}/include/hyprland/protocols
-	cp ./build/hyprland.pc ${PREFIX}/share/pkgconfig
-	if [ -d /usr/share/pkgconfig ]; then cp ./build/hyprland.pc /usr/share/pkgconfig 2>/dev/null || true; fi
+	mkdir -p ${PREFIX}/lib/
+	cp ./subprojects/wlroots/build/libwlroots.so.12032 ${PREFIX}/lib/
 
-cleaninstall:
-	echo -en "$(MAKE) cleaninstall has been DEPRECATED, you should avoid using it in the future.\nRunning $(MAKE) install instead...\n"
-	$(MAKE) install
+	$(MAKE) installheaders
 
 uninstall:
 	rm -f ${PREFIX}/share/wayland-sessions/hyprland.desktop
@@ -74,30 +63,12 @@ uninstall:
 	rm -f ${PREFIX}/share/man/man1/Hyprland.1
 	rm -f ${PREFIX}/share/man/man1/hyprctl.1
 
-fixwlr:
-	sed -E -i -e 's/(soversion = 12)([^032]|$$)/soversion = 12032/g' subprojects/wlroots/meson.build
-
-	rm -rf ./subprojects/wlroots/build
-
-config:
-	$(MAKE) fixwlr
-
-	meson setup subprojects/wlroots/build subprojects/wlroots --prefix=${PREFIX} --buildtype=release -Dwerror=false -Dexamples=false
-	ninja -C subprojects/wlroots/build/
-
-	ninja -C subprojects/wlroots/build/ install
-
-	cd subprojects/udis86 && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -S . -B ./build -G Ninja && cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
-
 pluginenv:
-	cd subprojects/udis86 && cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -S . -B ./build -G Ninja && cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
-
-	$(MAKE) fixwlr
-
-	meson setup subprojects/wlroots/build subprojects/wlroots --prefix=${PREFIX} --buildtype=release -Dwerror=false -Dexamples=false
-	ninja -C subprojects/wlroots/build/
-
-	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -S . -B ./build -G Ninja
+	@echo -en "$(MAKE) pluginenv has been deprecated.\nPlease run $(MAKE) all && sudo $(MAKE) installheaders\n"
+	@exit 1
+	
+installheaders:
+	@if [ ! -f ./build/Hyprland ]; then echo -en "You need to run $(MAKE) all first.\n" && exit 1; fi
 
 	mkdir -p ${PREFIX}/include/hyprland
 	mkdir -p ${PREFIX}/include/hyprland/protocols
@@ -111,13 +82,8 @@ pluginenv:
 	cp ./build/hyprland.pc ${PREFIX}/share/pkgconfig
 	if [ -d /usr/share/pkgconfig ]; then cp ./build/hyprland.pc /usr/share/pkgconfig 2>/dev/null || true; fi
 
-configdebug:
-	$(MAKE) fixwlr
-
-	meson setup subprojects/wlroots/build subprojects/wlroots --prefix=${PREFIX} --buildtype=debug -Dwerror=false -Dexamples=false -Db_sanitize=address
-	ninja -C subprojects/wlroots/build/
-
-	ninja -C subprojects/wlroots/build/ install
+	chmod -R 755 ${PREFIX}/include/hyprland
+	chmod 755 ${PREFIX}/share/pkgconfig
 
 man:
 	pandoc ./docs/Hyprland.1.rst \

README.md

@@ -16,7 +16,8 @@
 
 Hyprland is a dynamic tiling Wayland compositor based on wlroots that doesn't sacrifice on its looks.
 
-It supports multiple layouts, fancy effects, has a very flexible IPC model allowing for a lot of customization, a powerful plugin system and more.
+It provides the latest Wayland features, is highly customizable, has all the eyecandy, the most powerful plugins,
+easy IPC, much more QoL stuff than other wlr-based compositors and more...
 <br>
 <br>
 
@@ -32,40 +33,29 @@ It supports multiple layouts, fancy effects, has a very flexible IPC model allow
 <br>
 
 </div>
- 
-# Notice
-
-Hyprland is still in pretty early development compared to some other Wayland compositors.
-
-Although Hyprland is pretty stable, it may have some bugs.
 
 # Features
 
+- All of the eyecandy: gradient borders, blur, animations, shadows and much more
+- A lot of customization
+- Much more QoL stuff than other wlr-based compositors
+- Custom bezier curves for the best animations
+- Powerful plugin support
+- Tearing support for better gaming performance
 - Easily expandable and readable codebase
-- Plugin support
+- Fast and active development
+- Not scared to provide bleeding-edge features
 - Config reloaded instantly upon saving
-- Custom bezier curve based animations
-- Dual Kawase blur
-- Drop shadows
-- Rounded corners
-- Gradient borders
 - Fully dynamic workspaces
+- Two built-in layouts and more available as plugins
 - 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 workspaces (scratchpads)
-- Window/monitor rules
+- Window groups (tabbed mode)
+- Powerful window/monitor/layer rules
 - Socket-based IPC
-- `wlr_ext` workspaces protocol support
-- Event system for bash scripts
-- Full damage tracking
-- Docks support
-- Drawing tablet support
-- Native IME + Input panels support
+- Native IME and Input Panels Support
 - and much more...
 
 <br>
@@ -90,15 +80,6 @@ Although Hyprland is pretty stable, it may have some bugs.
 <br>
 <br>
 
-# Stars Over Time
-
-<br>
-
-[![Stars Preview]][Stars]
-
-<br>
-<br>
-
 </div>
 
 # Special Thanks

assets/hyprland-portals.conf

@@ -0,0 +1,2 @@
+[preferred]
+default=hyprland;gtk

assets/meson.build

@@ -5,3 +5,5 @@ foreach type : wallpaper_types
     install_data(f'wall_@type@@size@K.png', install_dir: join_paths(get_option('datadir'), 'hyprland'), install_tag: 'runtime')
   endforeach
 endforeach
+
+install_data('hyprland-portals.conf', install_dir: join_paths(get_option('datadir'), 'xdg-desktop-portal'), install_tag: 'runtime')

example/hyprland.conf

@@ -49,6 +49,9 @@ general {
     col.inactive_border = rgba(595959aa)
 
     layout = dwindle
+
+    # Please see https://wiki.hyprland.org/Configuring/Tearing/ before you turn this on
+    allow_tearing = false
 }
 
 decoration {
@@ -99,6 +102,11 @@ gestures {
     workspace_swipe = false
 }
 
+misc {
+    # See https://wiki.hyprland.org/Configuring/Variables/ for more
+    force_default_wallpaper = -1 # Set to 0 to disable the anime mascot wallpapers
+}
+
 # Example per-device config
 # See https://wiki.hyprland.org/Configuring/Keywords/#per-device-input-configs for more
 device:epic-mouse-v1 {

flake.lock

@@ -4,14 +4,17 @@
       "inputs": {
         "nixpkgs": [
           "nixpkgs"
+        ],
+        "systems": [
+          "systems"
         ]
       },
       "locked": {
-        "lastModified": 1684265364,
-        "narHash": "sha256-AxNnWbthsuNx73HDQr0eBxrcE3+yfl/WsaXZqUFmkpQ=",
+        "lastModified": 1691753796,
+        "narHash": "sha256-zOEwiWoXk3j3+EoF3ySUJmberFewWlagvewDRuWYAso=",
         "owner": "hyprwm",
         "repo": "hyprland-protocols",
-        "rev": "8c279b9fb0f2b031427dc5ef4eab53f2ed835530",
+        "rev": "0c2ce70625cb30aef199cb388f99e19a61a6ce03",
         "type": "github"
       },
       "original": {
@@ -22,11 +25,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1690179384,
-        "narHash": "sha256-+arbgqFTAtoeKtepW9wCnA0njCOyoiDFyl0Q0SBSOtE=",
+        "lastModified": 1694767346,
+        "narHash": "sha256-5uH27SiVFUwsTsqC5rs3kS7pBoNhtoy9QfTP9BmknGk=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "b12803b6d90e2e583429bb79b859ca53c348b39a",
+        "rev": "ace5093e36ab1e95cb9463863491bee90d5a4183",
         "type": "github"
       },
       "original": {
@@ -40,26 +43,42 @@
       "inputs": {
         "hyprland-protocols": "hyprland-protocols",
         "nixpkgs": "nixpkgs",
+        "systems": "systems",
         "wlroots": "wlroots",
         "xdph": "xdph"
       }
     },
+    "systems": {
+      "locked": {
+        "lastModified": 1689347949,
+        "narHash": "sha256-12tWmuL2zgBgZkdoB6qXZsgJEH9LR3oUgpaQq2RbI80=",
+        "owner": "nix-systems",
+        "repo": "default-linux",
+        "rev": "31732fcf5e8fea42e59c2488ad31a0e651500f68",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default-linux",
+        "type": "github"
+      }
+    },
     "wlroots": {
       "flake": false,
       "locked": {
         "host": "gitlab.freedesktop.org",
-        "lastModified": 1690165843,
-        "narHash": "sha256-gv5kjss6REeQG0BmvK2gTx7jHLRdCnP25po6It6I6N8=",
+        "lastModified": 1696410538,
+        "narHash": "sha256-ecDhdYLXWHsxMv+EWG36mCNDvzRbu9qfjH7dLxL7aGM=",
         "owner": "wlroots",
         "repo": "wlroots",
-        "rev": "e8d545a9770a2473db32e0a0bfa757b05d2af4f3",
+        "rev": "3406c1b17a4a7e6d4e2a7d9c1176affa72bce1bc",
         "type": "gitlab"
       },
       "original": {
         "host": "gitlab.freedesktop.org",
         "owner": "wlroots",
         "repo": "wlroots",
-        "rev": "e8d545a9770a2473db32e0a0bfa757b05d2af4f3",
+        "rev": "3406c1b17a4a7e6d4e2a7d9c1176affa72bce1bc",
         "type": "gitlab"
       }
     },
@@ -70,14 +89,17 @@
         ],
         "nixpkgs": [
           "nixpkgs"
+        ],
+        "systems": [
+          "systems"
         ]
       },
       "locked": {
-        "lastModified": 1685385764,
-        "narHash": "sha256-r+XMyOoRXq+hlfjayb+fyi9kq2JK48TrwuNIAXqlj7U=",
+        "lastModified": 1694628480,
+        "narHash": "sha256-Qg9hstRw0pvjGu5hStkr2UX1D73RYcQ9Ns/KnZMIm9w=",
         "owner": "hyprwm",
         "repo": "xdg-desktop-portal-hyprland",
-        "rev": "4d9ff0c17716936e0b5ca577a39e263633901ed1",
+        "rev": "8f45a6435069b9e24ebd3160eda736d7a391cbf2",
         "type": "github"
       },
       "original": {

flake.nix

@@ -4,23 +4,28 @@
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
 
+    # <https://github.com/nix-systems/nix-systems>
+    systems.url = "github:nix-systems/default-linux";
+
     wlroots = {
       type = "gitlab";
       host = "gitlab.freedesktop.org";
       owner = "wlroots";
       repo = "wlroots";
-      rev = "e8d545a9770a2473db32e0a0bfa757b05d2af4f3";
+      rev = "3406c1b17a4a7e6d4e2a7d9c1176affa72bce1bc";
       flake = false;
     };
 
     hyprland-protocols = {
       url = "github:hyprwm/hyprland-protocols";
       inputs.nixpkgs.follows = "nixpkgs";
+      inputs.systems.follows = "systems";
     };
 
     xdph = {
       url = "github:hyprwm/xdg-desktop-portal-hyprland";
       inputs.nixpkgs.follows = "nixpkgs";
+      inputs.systems.follows = "systems";
       inputs.hyprland-protocols.follows = "hyprland-protocols";
     };
   };
@@ -28,39 +33,23 @@
   outputs = inputs @ {
     self,
     nixpkgs,
+    systems,
     ...
   }: let
-    lib = nixpkgs.lib.extend (import ./nix/lib.nix);
-    genSystems = lib.genAttrs [
-      # Add more systems if they are supported
-      "aarch64-linux"
-      "x86_64-linux"
-    ];
-
-    pkgsFor = genSystems (system:
+    inherit (nixpkgs) lib;
+    eachSystem = lib.genAttrs (import systems);
+    pkgsFor = eachSystem (system:
       import nixpkgs {
-        inherit system;
-        overlays = [
-          self.overlays.hyprland-packages
-          self.overlays.wlroots-hyprland
-          inputs.hyprland-protocols.overlays.default
+        localSystem = system;
+        overlays = with self.overlays; [
+          hyprland-packages
+          hyprland-extras
         ];
       });
   in {
-    overlays =
-      (import ./nix/overlays.nix {inherit self lib inputs;})
-      // {
-        default =
-          lib.mkJoinedOverlays
-          (with self.overlays; [
-            hyprland-packages
-            hyprland-extras
-            wlroots-hyprland
-            inputs.hyprland-protocols.overlays.default
-          ]);
-      };
+    overlays = import ./nix/overlays.nix {inherit self lib inputs;};
 
-    checks = genSystems (system:
+    checks = eachSystem (system:
       (lib.filterAttrs
         (n: _: (lib.hasPrefix "hyprland" n) && !(lib.hasSuffix "debug" n))
         self.packages.${system})
@@ -68,16 +57,30 @@
         inherit (self.packages.${system}) xdg-desktop-portal-hyprland;
       });
 
-    packages = genSystems (system:
-      (self.overlays.default pkgsFor.${system} pkgsFor.${system})
-      // {
-        default = self.packages.${system}.hyprland;
-      });
+    packages = eachSystem (system: {
+      default = self.packages.${system}.hyprland;
+      inherit
+        (pkgsFor.${system})
+        # hyprland-packages
+        hyprland
+        hyprland-unwrapped
+        hyprland-debug
+        hyprland-nvidia
+        # hyprland-extras
+        xdg-desktop-portal-hyprland
+        # dependencies
+        hyprland-protocols
+        wlroots-hyprland
+        udis86
+        ;
+    });
 
-    devShells = genSystems (system: {
-      default = pkgsFor.${system}.mkShell {
+    devShells = eachSystem (system: {
+      default = pkgsFor.${system}.mkShell.override {
+        stdenv = pkgsFor.${system}.gcc13Stdenv;
+      } {
         name = "hyprland-shell";
-        nativeBuildInputs = with pkgsFor.${system}; [ cmake python3 ];
+        nativeBuildInputs = with pkgsFor.${system}; [cmake python3];
         buildInputs = [self.packages.${system}.wlroots-hyprland];
         inputsFrom = [
           self.packages.${system}.wlroots-hyprland
@@ -86,7 +89,7 @@
       };
     });
 
-    formatter = genSystems (system: pkgsFor.${system}.alejandra);
+    formatter = eachSystem (system: nixpkgs.legacyPackages.${system}.alejandra);
 
     nixosModules.default = import ./nix/module.nix inputs;
     homeManagerModules.default = import ./nix/hm-module.nix self;

hyprctl/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.19)
+
+project(
+    hyprctl
+    DESCRIPTION "Control utility for Hyprland"
+)
+
+add_executable(hyprctl "main.cpp")

hyprctl/main.cpp

@@ -11,12 +11,17 @@
 #include <unistd.h>
 #include <ranges>
 #include <algorithm>
+#include <signal.h>
+#include <format>
 
 #include <iostream>
 #include <string>
 #include <fstream>
 #include <string>
+#include <vector>
 #include <deque>
+#include <filesystem>
+#include <stdarg.h>
 
 const std::string USAGE = R"#(usage: hyprctl [(opt)flags] [command] [(opt)args]
 
@@ -45,14 +50,63 @@ commands:
     plugin
     notify
     globalshortcuts
+    instances
 
 flags:
     -j -> output in JSON
     --batch -> execute a batch of commands, separated by ';'
+    --instance (-i) -> use a specific instance. Can be either signature or index in hyprctl instances (0, 1, etc)
 )#";
 
 #define PAD
 
+std::string instanceSignature;
+
+struct SInstanceData {
+    std::string id;
+    uint64_t    time;
+    uint64_t    pid;
+    std::string wlSocket;
+    bool        valid = true;
+};
+
+std::vector<SInstanceData> instances() {
+    std::vector<SInstanceData> result;
+
+    for (const auto& el : std::filesystem::directory_iterator("/tmp/hypr")) {
+        if (el.is_directory())
+            continue;
+
+        // read lock
+        SInstanceData* data = &result.emplace_back();
+        data->id            = el.path().string();
+        data->id            = data->id.substr(data->id.find_last_of('/') + 1, data->id.find(".lock") - data->id.find_last_of('/') - 1);
+
+        data->time = std::stoull(data->id.substr(data->id.find_first_of('_') + 1));
+
+        // read file
+        std::ifstream ifs(el.path().string());
+
+        int           i = 0;
+        for (std::string line; std::getline(ifs, line); ++i) {
+            if (i == 0) {
+                data->pid = std::stoull(line);
+            } else if (i == 1) {
+                data->wlSocket = line;
+            } else
+                break;
+        }
+
+        ifs.close();
+    }
+
+    std::erase_if(result, [&](const auto& el) { return kill(el.pid, 0) != 0 && errno == ESRCH; });
+
+    std::sort(result.begin(), result.end(), [&](const auto& a, const auto& b) { return a.time < b.time; });
+
+    return result;
+}
+
 void request(std::string arg, int minArgs = 0) {
     const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
 
@@ -68,20 +122,15 @@ void request(std::string arg, int minArgs = 0) {
         return;
     }
 
-    // get the instance signature
-    auto instanceSig = getenv("HYPRLAND_INSTANCE_SIGNATURE");
-
-    if (!instanceSig) {
+    if (instanceSignature.empty()) {
         std::cout << "HYPRLAND_INSTANCE_SIGNATURE was not set! (Is Hyprland running?)";
         return;
     }
 
-    std::string instanceSigStr = std::string(instanceSig);
-
     sockaddr_un serverAddress = {0};
     serverAddress.sun_family  = AF_UNIX;
 
-    std::string socketPath = "/tmp/hypr/" + instanceSigStr + "/.socket.sock";
+    std::string socketPath = "/tmp/hypr/" + instanceSignature + "/.socket.sock";
 
     strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
 
@@ -131,20 +180,15 @@ void requestHyprpaper(std::string arg) {
         return;
     }
 
-    // get the instance signature
-    auto instanceSig = getenv("HYPRLAND_INSTANCE_SIGNATURE");
-
-    if (!instanceSig) {
+    if (instanceSignature.empty()) {
         std::cout << "HYPRLAND_INSTANCE_SIGNATURE was not set! (Is Hyprland running?)";
         return;
     }
 
-    std::string instanceSigStr = std::string(instanceSig);
-
     sockaddr_un serverAddress = {0};
     serverAddress.sun_family  = AF_UNIX;
 
-    std::string socketPath = "/tmp/hypr/" + instanceSigStr + "/.hyprpaper.sock";
+    std::string socketPath = "/tmp/hypr/" + instanceSignature + "/.hyprpaper.sock";
 
     strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
 
@@ -153,6 +197,9 @@ void requestHyprpaper(std::string arg) {
         return;
     }
 
+    arg = arg.substr(arg.find_first_of('/') + 1); // strip flags
+    arg = arg.substr(arg.find_first_of(' ') + 1); // strip "hyprpaper"
+
     auto sizeWritten = write(SERVERSOCKET, arg.c_str(), arg.length());
 
     if (sizeWritten < 0) {
@@ -174,92 +221,42 @@ void requestHyprpaper(std::string arg) {
     std::cout << std::string(buffer);
 }
 
-int dispatchRequest(int argc, char** argv) {
-
-    if (argc < 3) {
-        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++) {
-        if (!strcmp(argv[i], "--"))
-            continue;
-        rq += " " + std::string(argv[i]);
-    }
-
-    request(rq);
-    return 0;
-}
-
-int keywordRequest(int argc, char** argv) {
-    if (argc < 4) {
-        std::cout << "Usage: hyprctl keyword <keyword> <arg>\n\
-            Execute a hyprland keyword with the given argument";
-        return 1;
-    }
-
-    std::string rq = "/keyword";
-
-    for (int i = 2; i < argc; i++)
-        rq += " " + std::string(argv[i]);
-
-    request(rq);
-    return 0;
-}
-
-int hyprpaperRequest(int argc, char** argv) {
-    if (argc < 4) {
-        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;
-}
-
-int setcursorRequest(int argc, char** argv) {
-    if (argc < 4) {
-        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 ";
-    for (size_t i = 2; i < argc; ++i)
-        rq += std::string(argv[i]) + " ";
-    rq.pop_back();
-
-    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) {
     std::string rq = "[[BATCH]]" + arg.substr(arg.find_first_of(" ") + 1);
 
     request(rq);
 }
 
+void instancesRequest(bool json) {
+    std::string result = "";
+
+    // gather instance data
+    std::vector<SInstanceData> inst = instances();
+
+    if (!json) {
+        for (auto& el : inst) {
+            result += std::format("instance {}:\n\ttime: {}\n\tpid: {}\n\twl socket: {}\n\n", el.id, el.time, el.pid, el.wlSocket);
+        }
+    } else {
+        result += '[';
+        for (auto& el : inst) {
+            result += std::format(R"#(
+{{
+    "instance": "{}",
+    "time": {},
+    "pid": {},
+    "wl_socket": "{}"
+}},)#",
+                                  el.id, el.time, el.pid, el.wlSocket);
+        }
+
+        result.pop_back();
+        result += "\n]";
+    }
+
+    std::cout << result << "\n";
+}
+
 std::deque<std::string> splitArgs(int argc, char** argv) {
     std::deque<std::string> result;
 
@@ -284,9 +281,11 @@ int main(int argc, char** argv) {
         return 1;
     }
 
-    std::string fullRequest = "";
-    std::string fullArgs    = "";
-    const auto  ARGS        = splitArgs(argc, argv);
+    std::string fullRequest      = "";
+    std::string fullArgs         = "";
+    const auto  ARGS             = splitArgs(argc, argv);
+    bool        json             = false;
+    std::string overrideInstance = "";
 
     for (auto i = 0; i < ARGS.size(); ++i) {
         if (ARGS[i] == "--") {
@@ -298,8 +297,18 @@ int main(int argc, char** argv) {
             // parse
             if (ARGS[i] == "-j" && !fullArgs.contains("j")) {
                 fullArgs += "j";
+                json = true;
             } else if (ARGS[i] == "--batch") {
                 fullRequest = "--batch ";
+            } else if (ARGS[i] == "--instance" || ARGS[i] == "-i") {
+                ++i;
+
+                if (i >= ARGS.size()) {
+                    printf("%s\n", USAGE.c_str());
+                    return 1;
+                }
+
+                overrideInstance = ARGS[i];
             } else {
                 printf("%s\n", USAGE.c_str());
                 return 1;
@@ -320,6 +329,35 @@ int main(int argc, char** argv) {
 
     fullRequest = fullArgs + "/" + fullRequest;
 
+    if (overrideInstance.contains("_"))
+        instanceSignature = overrideInstance;
+    else if (!overrideInstance.empty()) {
+        if (!isNumber(overrideInstance, false)) {
+            std::cout << "instance invalid\n";
+            return 1;
+        }
+
+        const auto INSTANCENO = std::stoi(overrideInstance);
+
+        const auto INSTANCES = instances();
+
+        if (INSTANCENO < 0 || INSTANCENO >= INSTANCES.size()) {
+            std::cout << "no such instance\n";
+            return 1;
+        }
+
+        instanceSignature = INSTANCES[INSTANCENO].id;
+    } else {
+        const auto ISIG = getenv("HYPRLAND_INSTANCE_SIGNATURE");
+
+        if (!ISIG) {
+            std::cout << "HYPRLAND_INSTANCE_SIGNATURE not set! (is hyprland running?)";
+            return 1;
+        }
+
+        instanceSignature = ISIG;
+    }
+
     int exitStatus = 0;
 
     if (fullRequest.contains("/--batch"))
@@ -356,6 +394,8 @@ int main(int argc, char** argv) {
         request(fullRequest);
     else if (fullRequest.contains("/globalshortcuts"))
         request(fullRequest);
+    else if (fullRequest.contains("/instances"))
+        instancesRequest(json);
     else if (fullRequest.contains("/switchxkblayout"))
         request(fullRequest, 2);
     else if (fullRequest.contains("/seterror"))
@@ -367,15 +407,15 @@ int main(int argc, char** argv) {
     else if (fullRequest.contains("/notify"))
         request(fullRequest, 2);
     else if (fullRequest.contains("/output"))
-        exitStatus = outputRequest(argc, argv);
+        request(fullRequest, 2);
     else if (fullRequest.contains("/setcursor"))
-        exitStatus = setcursorRequest(argc, argv);
+        request(fullRequest, 1);
     else if (fullRequest.contains("/dispatch"))
-        exitStatus = dispatchRequest(argc, argv);
+        request(fullRequest, 1);
     else if (fullRequest.contains("/keyword"))
-        exitStatus = keywordRequest(argc, argv);
+        request(fullRequest, 2);
     else if (fullRequest.contains("/hyprpaper"))
-        exitStatus = hyprpaperRequest(argc, argv);
+        requestHyprpaper(fullRequest);
     else if (fullRequest.contains("/--help"))
         printf("%s", USAGE.c_str());
     else {

meson.build

@@ -20,26 +20,20 @@ else
   error('Could not configure current C++ compiler (' + cpp_compiler.get_id() + ' ' + cpp_compiler.version() + ') with required C++ standard (C++23)')
 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('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(
   [
     '-Wno-unused-parameter',
     '-Wno-unused-value',
     '-Wno-missing-field-initializers',
     '-Wno-narrowing',
-
-    f'-DGIT_BRANCH="@GIT_BRANCH@"',
-    f'-DGIT_COMMIT_HASH="@GIT_COMMIT_HASH@"',
-    f'-DGIT_COMMIT_MESSAGE="@GIT_COMMIT_MESSAGE@"',
-    f'-DGIT_DIRTY="@GIT_DIRTY@"',
   ],
   language: 'cpp')
 
-wlroots = subproject('wlroots', default_options: ['examples=false'])
+if cpp_compiler.check_header('execinfo.h')
+  add_project_arguments('-DHAS_EXECINFO', language: 'cpp')
+endif
+
+wlroots = subproject('wlroots', default_options: ['examples=false', 'renderers=gles2'])
 have_xwlr = wlroots.get_variable('features').get('xwayland')
 xcb_dep = dependency('xcb', required: get_option('xwayland'))
 
@@ -81,6 +75,8 @@ foreach file : headers
   install_headers(file, subdir: 'hyprland', preserve_path: true)
 endforeach
 
+version_h = run_command('sh', '-c', 'scripts/generateVersion.sh')
+
 subdir('protocols')
 subdir('src')
 subdir('hyprctl')

nix/default.nix

@@ -26,114 +26,115 @@
   xcbutilwm,
   xwayland,
   debug ? false,
+  enableNvidiaPatches ? false,
   enableXWayland ? true,
-  hidpiXWayland ? false,
   legacyRenderer ? false,
-  nvidiaPatches ? false,
-  withSystemd ? true,
+  withSystemd ? lib.meta.availableOn stdenv.hostPlatform systemd,
   wrapRuntimeDeps ? true,
   version ? "git",
   commit,
-}: let
-  assertXWayland = lib.assertMsg (hidpiXWayland -> enableXWayland) ''
-    Hyprland: cannot have hidpiXWayland when enableXWayland is false.
-  '';
-in
-  assert assertXWayland;
-    stdenv.mkDerivation {
-      pname = "hyprland" + lib.optionalString debug "-debug";
-      inherit version;
+  # deprecated flags
+  nvidiaPatches ? false,
+  hidpiXWayland ? false,
+}:
+assert lib.assertMsg (!nvidiaPatches) "The option `nvidiaPatches` has been renamed `enableNvidiaPatches`";
+assert lib.assertMsg (!hidpiXWayland) "The option `hidpiXWayland` has been removed. Please refer https://wiki.hyprland.org/Configuring/XWayland";
+  stdenv.mkDerivation {
+    pname = "hyprland${lib.optionalString enableNvidiaPatches "-nvidia"}${lib.optionalString debug "-debug"}";
+    inherit version;
 
-      src = lib.cleanSourceWith {
-        filter = name: type: let
-          baseName = baseNameOf (toString name);
-        in
-          ! (
-            lib.hasSuffix ".nix" baseName
-          );
-        src = lib.cleanSource ../.;
-      };
+    src = lib.cleanSourceWith {
+      filter = name: type: let
+        baseName = baseNameOf (toString name);
+      in
+        ! (lib.hasSuffix ".nix" baseName);
+      src = lib.cleanSource ../.;
+    };
 
-      nativeBuildInputs = [
-        jq
-        meson
-        ninja
-        pkg-config
-        makeWrapper
-        wayland-scanner
-      ];
+    nativeBuildInputs = [
+      jq
+      meson
+      ninja
+      pkg-config
+      makeWrapper
+      wayland-scanner
+    ];
 
-      outputs = [
-        "out"
-        "man"
-        "dev"
-      ];
+    outputs = [
+      "out"
+      "man"
+      "dev"
+    ];
 
-      buildInputs =
-        [
-          git
-          cairo
-          hyprland-protocols
-          libdrm
-          libinput
-          libxkbcommon
-          mesa
-          pango
-          udis86
-          wayland
-          wayland-protocols
-          pciutils
-          (wlroots.override {inherit enableXWayland hidpiXWayland nvidiaPatches;})
-        ]
-        ++ lib.optionals enableXWayland [libxcb xcbutilwm xwayland]
-        ++ lib.optionals withSystemd [systemd];
+    buildInputs =
+      [
+        git
+        cairo
+        hyprland-protocols
+        libdrm
+        libinput
+        libxkbcommon
+        mesa
+        pango
+        udis86
+        wayland
+        wayland-protocols
+        pciutils
+        (wlroots.override {inherit enableNvidiaPatches;})
+      ]
+      ++ lib.optionals enableXWayland [libxcb xcbutilwm xwayland]
+      ++ lib.optionals withSystemd [systemd];
 
-      mesonBuildType =
-        if debug
-        then "debug"
-        else "release";
+    mesonBuildType =
+      if debug
+      then "debug"
+      else "release";
 
-      mesonFlags = builtins.concatLists [
-        ["-Dauto_features=disabled"]
-        (lib.optional enableXWayland "-Dxwayland=enabled")
-        (lib.optional legacyRenderer "-Dlegacy_renderer=enabled")
-        (lib.optional withSystemd "-Dsystemd=enabled")
-      ];
+    mesonFlags = builtins.concatLists [
+      ["-Dauto_features=disabled"]
+      (lib.optional enableXWayland "-Dxwayland=enabled")
+      (lib.optional legacyRenderer "-Dlegacy_renderer=enabled")
+      (lib.optional withSystemd "-Dsystemd=enabled")
+    ];
 
-      patches = [
-        # make meson use the provided wlroots instead of the git submodule
-        ./patches/meson-build.patch
-        # fixes portals search path to be picked up from $XDG_DESKTOP_PORTAL_DIR
-        ./patches/portals.patch
-      ];
+    patches = [
+      # make meson use the provided wlroots instead of the git submodule
+      ./patches/meson-build.patch
+    ];
 
-      postPatch = ''
-        # Fix hardcoded paths to /usr installation
-        sed -i "s#/usr#$out#" src/render/OpenGL.cpp
-        substituteInPlace meson.build \
-          --replace "@GIT_COMMIT_HASH@" '${commit}' \
-          --replace "@GIT_DIRTY@" '${
-          if commit == ""
-          then "dirty"
-          else ""
-        }'
-      '';
+    postPatch = ''
+      # Fix hardcoded paths to /usr installation
+      sed -i "s#/usr#$out#" src/render/OpenGL.cpp
 
-      postInstall = ''
-        ln -s ${wlroots}/include/wlr $dev/include/hyprland/wlroots
-        ${lib.optionalString wrapRuntimeDeps ''
-          wrapProgram $out/bin/Hyprland \
-            --suffix PATH : ${lib.makeBinPath [ binutils pciutils ]}
-        ''}
-      '';
+      # Generate version.h
+      cp src/version.h.in src/version.h
+      substituteInPlace src/version.h \
+        --replace "@HASH@" '${commit}' \
+        --replace "@BRANCH@" "" \
+        --replace "@MESSAGE@" "" \
+        --replace "@TAG@" "" \
+        --replace "@DIRTY@" '${
+        if commit == ""
+        then "dirty"
+        else ""
+      }'
+    '';
 
-      passthru.providedSessions = ["hyprland"];
+    postInstall = ''
+      ln -s ${wlroots}/include/wlr $dev/include/hyprland/wlroots
+      ${lib.optionalString wrapRuntimeDeps ''
+        wrapProgram $out/bin/Hyprland \
+          --suffix PATH : ${lib.makeBinPath [binutils pciutils]}
+      ''}
+    '';
 
-      meta = with lib; {
-        homepage = "https://github.com/vaxerski/Hyprland";
-        description = "A dynamic tiling Wayland compositor that doesn't sacrifice on its looks";
-        license = licenses.bsd3;
-        platforms = platforms.linux;
-        mainProgram = "Hyprland";
-      };
-    }
+    passthru.providedSessions = ["hyprland"];
+
+    meta = with lib; {
+      homepage = "https://github.com/vaxerski/Hyprland";
+      description = "A dynamic tiling Wayland compositor that doesn't sacrifice on its looks";
+      license = licenses.bsd3;
+      platforms = platforms.linux;
+      mainProgram = "Hyprland";
+    };
+  }

nix/hm-module.nix

@@ -7,8 +7,7 @@ self: {
   cfg = config.wayland.windowManager.hyprland;
   defaultHyprlandPackage = self.packages.${pkgs.stdenv.hostPlatform.system}.default.override {
     enableXWayland = cfg.xwayland.enable;
-    hidpiXWayland = cfg.xwayland.hidpi;
-    inherit (cfg) nvidiaPatches;
+    inherit (cfg) enableNvidiaPatches;
   };
 in {
   disabledModules = ["services/window-managers/hyprland.nix"];
@@ -36,13 +35,12 @@ in {
       defaultText = lib.literalExpression ''
         hyprland.packages.''${pkgs.stdenv.hostPlatform.system}.default.override {
           enableXWayland = config.wayland.windowManager.hyprland.xwayland.enable;
-          hidpiXWayland = config.wayland.windowManager.hyprland.xwayland.hidpi;
-          inherit (config.wayland.windowManager.hyprland) nvidiaPatches;
+          inherit (config.wayland.windowManager.hyprland) enableNvidiaPatches;
         }
       '';
       description = lib.mdDoc ''
         Hyprland package to use. Will override the 'xwayland' and
-        'nvidiaPatches' options.
+        'enableNvidiaPatches' options.
 
         Defaults to the one provided by the flake. Set it to
         {package}`pkgs.hyprland` to use the one provided by nixpkgs or
@@ -86,19 +84,9 @@ in {
         '';
       };
 
-    xwayland = {
-      enable = lib.mkEnableOption (lib.mdDoc "XWayland") // {default = true;};
-      hidpi =
-        lib.mkEnableOption null
-        // {
-          description = lib.mdDoc ''
-            Enable HiDPI XWayland, based on [XWayland MR 733](https://gitlab.freedesktop.org/xorg/xserver/-/merge_requests/733).
-            See <https://wiki.hyprland.org/Nix/Options-Overrides/#xwayland-hidpi> for more info.
-          '';
-        };
-    };
+    xwayland.enable = lib.mkEnableOption (lib.mdDoc "XWayland") // {default = true;};
 
-    nvidiaPatches = lib.mkEnableOption (lib.mdDoc "patching wlroots for better Nvidia support.");
+    enableNvidiaPatches = lib.mkEnableOption (lib.mdDoc "patching wlroots for better Nvidia support.");
 
     extraConfig = lib.mkOption {
       type = lib.types.nullOr lib.types.lines;
@@ -119,10 +107,14 @@ in {
 
   config = lib.mkIf cfg.enable {
     warnings =
-      if (cfg.systemdIntegration || cfg.plugins != []) && cfg.extraConfig == null then
-        [ ''You have enabled hyprland.systemdIntegration or listed plugins in hyprland.plugins.
-            Your Hyprland config will be linked by home manager.
-            Set hyprland.extraConfig or unset hyprland.systemdIntegration and hyprland.plugins to remove this warning.'' ]
+      if (cfg.systemdIntegration || cfg.plugins != []) && cfg.extraConfig == null
+      then [
+        ''
+          You have enabled hyprland.systemdIntegration or listed plugins in hyprland.plugins.
+          Your Hyprland config will be linked by home manager.
+          Set hyprland.extraConfig or unset hyprland.systemdIntegration and hyprland.plugins to remove this warning.
+        ''
+      ]
       else [];
 
     home.packages =
@@ -138,9 +130,17 @@ in {
           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
         '')
         + lib.concatStrings (builtins.map (entry: let
-            plugin = if lib.types.package.check entry then "${entry}/lib/lib${entry.pname}.so" else entry;
-          in "plugin = ${plugin}\n") cfg.plugins)
-        + (if cfg.extraConfig != null then cfg.extraConfig else "");
+          plugin =
+            if lib.types.package.check entry
+            then "${entry}/lib/lib${entry.pname}.so"
+            else entry;
+        in "plugin = ${plugin}\n")
+        cfg.plugins)
+        + (
+          if cfg.extraConfig != null
+          then cfg.extraConfig
+          else ""
+        );
 
       onChange = let
         hyprlandPackage =
@@ -169,4 +169,9 @@ in {
       };
     };
   };
+
+  imports = [
+    (lib.mkRemovedOptionModule ["wayland" "windowManager" "hyprland" "xwayland" "hidpi"]
+      "Support for this option has been removed. Refer to https://wiki.hyprland.org/Configuring/XWayland for more info")
+  ];
 }

nix/lib.nix

@@ -1,8 +0,0 @@
-final: prev: let
-  lib = final;
-
-  mkJoinedOverlays = overlays: final: prev:
-    lib.foldl' (attrs: overlay: attrs // (overlay final prev)) {} overlays;
-in prev // {
-  inherit mkJoinedOverlays;
-}

nix/module.nix

@@ -2,15 +2,15 @@ inputs: {
   config,
   lib,
   pkgs,
+  options,
   ...
 }:
 with lib; let
   cfg = config.programs.hyprland;
+  inherit (pkgs.stdenv.hostPlatform) system;
 
-  defaultHyprlandPackage = inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.default.override {
-    enableXWayland = cfg.xwayland.enable;
-    hidpiXWayland = cfg.xwayland.hidpi;
-    inherit (cfg) nvidiaPatches;
+  finalPortalPackage = cfg.portalPackage.override {
+    hyprland = cfg.finalPackage;
   };
 in {
   # disables Nixpkgs Hyprland module to avoid conflicts
@@ -30,73 +30,70 @@ in {
         '';
       };
 
-    package = mkOption {
-      type = types.path;
-      default = defaultHyprlandPackage;
-      defaultText = literalExpression ''
-        hyprland.packages.''${pkgs.stdenv.hostPlatform.system}.default.override {
-          enableXWayland = config.programs.hyprland.xwayland.enable;
-          hidpiXWayland = config.programs.hyprland.xwayland.hidpi;
-          inherit (config.programs.hyprland) nvidiaPatches;
-        }
-      '';
-      example = literalExpression "pkgs.hyprland";
+    package = mkPackageOptionMD inputs.self.packages.${system} "hyprland" { };
+
+    finalPackage = mkOption {
+      type = types.package;
+      readOnly = true;
+      default = cfg.package.override {
+        enableXWayland = cfg.xwayland.enable;
+        enableNvidiaPatches = cfg.enableNvidiaPatches;
+      };
+      defaultText =
+        literalExpression
+        "`programs.hyprland.package` with applied configuration";
       description = mdDoc ''
-        The Hyprland package to use.
-        Setting this option will make {option}`programs.hyprland.xwayland` and
-        {option}`programs.hyprland.nvidiaPatches` not work.
+        The Hyprland package after applying configuration.
       '';
     };
 
-    xwayland = {
-      enable = mkEnableOption (mdDoc "XWayland") // {default = true;};
-      hidpi =
-        mkEnableOption null
-        // {
-          description = mdDoc ''
-            Enable HiDPI XWayland, based on [XWayland MR 733](https://gitlab.freedesktop.org/xorg/xserver/-/merge_requests/733).
-            See <https://wiki.hyprland.org/Nix/Options-Overrides/#xwayland-hidpi> for more info.
-          '';
-        };
-    };
+    portalPackage = mkPackageOptionMD inputs.xdph.packages.${system} "xdg-desktop-portal-hyprland" {};
 
-    nvidiaPatches = mkEnableOption (mdDoc "patching wlroots for better Nvidia support");
+    xwayland.enable = mkEnableOption (mdDoc "support for XWayland") // {default = true;};
+
+    enableNvidiaPatches =
+      mkEnableOption null
+      // {
+        description = mdDoc "Whether to apply patches to wlroots for better Nvidia support.";
+      };
   };
 
   config = mkIf cfg.enable {
-    environment = {
-      systemPackages = [cfg.package];
+    environment.systemPackages = [cfg.finalPackage];
 
-      sessionVariables = {
-        NIXOS_OZONE_WL = mkDefault "1";
-      };
-    };
-
-    fonts =
-      if versionOlder config.system.stateVersion "23.11"
-      then {enableDefaultFonts = mkDefault true;}
-      else {enableDefaultPackages = mkDefault true;};
+    # NixOS changed the name of this attribute between NixOS 23.05 and
+    # 23.11
+    fonts = if builtins.hasAttr "enableDefaultPackages" options.fonts
+      then {enableDefaultPackages = mkDefault true;}
+      else {enableDefaultFonts = mkDefault true;};
 
     hardware.opengl.enable = mkDefault true;
 
     programs = {
       dconf.enable = mkDefault true;
-      xwayland.enable = mkDefault true;
+      xwayland.enable = mkDefault cfg.xwayland.enable;
     };
 
     security.polkit.enable = true;
 
-    services.xserver.displayManager.sessionPackages = [cfg.package];
+    services.xserver.displayManager.sessionPackages = [cfg.finalPackage];
 
     xdg.portal = {
       enable = mkDefault true;
-      extraPortals = lib.mkIf (cfg.package != null) [
-        (inputs.xdph.packages.${pkgs.stdenv.hostPlatform.system}.xdg-desktop-portal-hyprland.override {
-          hyprland-share-picker = inputs.xdph.packages.${pkgs.stdenv.hostPlatform.system}.hyprland-share-picker.override {
-            hyprland = cfg.package;
-          };
-        })
-      ];
+      extraPortals = [finalPortalPackage];
     };
   };
+
+  imports = with lib; [
+    (
+      mkRemovedOptionModule
+      ["programs" "hyprland" "xwayland" "hidpi"]
+      "XWayland patches are deprecated. Refer to https://wiki.hyprland.org/Configuring/XWayland"
+    )
+    (
+      mkRenamedOptionModule
+      ["programs" "hyprland" "nvidiaPatches"]
+      ["programs" "hyprland" "enableNvidiaPatches"]
+    )
+  ];
 }

nix/overlays.nix

@@ -10,71 +10,62 @@
     (builtins.substring 4 2 longDate)
     (builtins.substring 6 2 longDate)
   ]);
+
+  mkJoinedOverlays = overlays: final: prev:
+    lib.foldl' (attrs: overlay: attrs // (overlay final prev)) {} overlays;
 in {
-  # Packages for variations of Hyprland, and its dependencies.
-  hyprland-packages = final: prev: {
-    hyprland = final.callPackage ./default.nix {
-      version =
-        props.version
-        + "+date="
-        + (mkDate (self.lastModifiedDate or "19700101"))
-        + "_"
-        + (self.shortRev or "dirty");
-      wlroots = final.wlroots-hyprland;
-      commit = self.rev or "";
-      inherit (final) udis86 hyprland-protocols;
-    };
+  # Contains what a user is most likely to care about:
+  # Hyprland itself, XDPH and the Share Picker.
+  default = mkJoinedOverlays (with self.overlays; [
+    hyprland-packages
+    hyprland-extras
+  ]);
 
-    hyprland-unwrapped = final.hyprland.override {wrapRuntimeDeps = false;};
-    hyprland-debug = final.hyprland.override {debug = true;};
-    hyprland-hidpi = final.hyprland.override {hidpiXWayland = true;};
-    hyprland-nvidia = final.hyprland.override {nvidiaPatches = true;};
-    hyprland-no-hidpi =
-      builtins.trace
-      "hyprland-no-hidpi was removed. Please use the default package."
-      final.hyprland;
-
-    udis86 = final.callPackage ./udis86.nix {};
-  };
+  # Packages for variations of Hyprland, dependencies included.
+  hyprland-packages = mkJoinedOverlays [
+    # Dependencies
+    inputs.hyprland-protocols.overlays.default
+    self.overlays.wlroots-hyprland
+    self.overlays.udis86
+    # Hyprland packages themselves
+    (final: prev: {
+      hyprland = final.callPackage ./default.nix {
+        stdenv = final.gcc13Stdenv;
+        version = "${props.version}+date=${mkDate (self.lastModifiedDate or "19700101")}_${self.shortRev or "dirty"}";
+        wlroots = final.wlroots-hyprland;
+        commit = self.rev or "";
+        inherit (final) udis86 hyprland-protocols;
+      };
+      hyprland-unwrapped = final.hyprland.override {wrapRuntimeDeps = false;};
+      hyprland-debug = final.hyprland.override {debug = true;};
+      hyprland-nvidia = final.hyprland.override {enableNvidiaPatches = true;};
+      hyprland-hidpi =
+        builtins.trace ''
+          hyprland-hidpi was removed. Please use the hyprland package.
+          For more information, refer to https://wiki.hyprland.org/Configuring/XWayland.
+        ''
+        final.hyprland;
+    })
+  ];
 
   # Packages for extra software recommended for usage with Hyprland,
   # including forked or patched packages for compatibility.
-  hyprland-extras = lib.mkJoinedOverlays [
-    # Include any inputs' specific overlays whose attributes should
-    # be re-exported by the Hyprland flake.
-    #
-    inputs.xdph.overlays.default
-    # Provides:
-    # - xdg-desktop-portal-hyprland
-    # - hyprland-share-picker
-    #
-    # Attributes for `hyprland-extras` defined by this flake can
-    # go in the oberlay below.
-    (final: prev: {
-      waybar-hyprland = prev.waybar.overrideAttrs (old: {
-        postPatch = ''
-          # use hyprctl to switch workspaces
-          sed -i 's/zext_workspace_handle_v1_activate(workspace_handle_);/const std::string command = "hyprctl dispatch workspace " + name_;\n\tsystem(command.c_str());/g' src/modules/wlr/workspace_manager.cpp
-        '';
-        postFixup = ''
-          wrapProgram $out/bin/waybar \
-            --suffix PATH : ${lib.makeBinPath [final.hyprland]}
-        '';
-        mesonFlags = old.mesonFlags ++ ["-Dexperimental=true"];
-      });
-    })
+  hyprland-extras = mkJoinedOverlays [
+    inputs.xdph.overlays.xdg-desktop-portal-hyprland
   ];
 
+  udis86 = final: prev: {
+    udis86 = final.callPackage ./udis86.nix {};
+  };
+
   # Patched version of wlroots for Hyprland.
   # It is under a new package name so as to not conflict with
   # the standard version in nixpkgs.
   wlroots-hyprland = final: prev: {
     wlroots-hyprland = final.callPackage ./wlroots.nix {
-      version =
-        mkDate (inputs.wlroots.lastModifiedDate or "19700101")
-        + "_"
-        + (inputs.wlroots.shortRev or "dirty");
+      version = "${mkDate (inputs.wlroots.lastModifiedDate or "19700101")}_${inputs.wlroots.shortRev or "dirty"}";
       src = inputs.wlroots;
+
       libdisplay-info = prev.libdisplay-info.overrideAttrs (old: {
         version = "0.1.1+date=2023-03-02";
         src = final.fetchFromGitLab {
@@ -85,6 +76,7 @@ in {
           sha256 = "sha256-/q79o13Zvu7x02SBGu0W5yQznQ+p7ltZ9L6cMW5t/o4=";
         };
       });
+
       libliftoff = prev.libliftoff.overrideAttrs (old: {
         version = "0.5.0-dev";
         src = final.fetchFromGitLab {

nix/patches/meson-build.patch

@@ -1,24 +1,12 @@
 diff --git a/meson.build b/meson.build
-index f3802553..6a924a79 100644
+index 726933bc..28b4d9ac 100644
 --- a/meson.build
 +++ b/meson.build
-@@ -21,9 +21,9 @@ else
- 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_HASH = '@GIT_COMMIT_HASH@'
- 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()
-+GIT_DIRTY = '@GIT_DIRTY@'
- 
- add_project_arguments(
-   [
-@@ -39,21 +39,8 @@ add_project_arguments(
+@@ -29,20 +29,7 @@ add_project_arguments(
    ],
    language: 'cpp')
  
--wlroots = subproject('wlroots', default_options: ['examples=false'])
+-wlroots = subproject('wlroots', default_options: ['examples=false', 'renderers=gles2'])
 -have_xwlr = wlroots.get_variable('features').get('xwayland')
 -xcb_dep = dependency('xcb', required: get_option('xwayland'))
 -
@@ -32,17 +20,24 @@ index f3802553..6a924a79 100644
 -have_xwayland = xcb_dep.found() and have_xwlr
 -
 -if not have_xwayland
--  add_project_arguments('-DNO_XWAYLAND', language: 'cpp')
 +if get_option('xwayland').disabled()
-+  add_project_arguments('-DNO_XWAYLAND', language: 'cpp')
+   add_project_arguments('-DNO_XWAYLAND', language: 'cpp')
  endif
  
- backtrace_dep = cpp_compiler.find_library('execinfo', required: false)
+@@ -71,8 +58,6 @@ foreach file : headers
+   install_headers(file, subdir: 'hyprland', preserve_path: true)
+ endforeach
+ 
+-version_h = run_command('sh', '-c', 'scripts/generateVersion.sh')
+-
+ subdir('protocols')
+ subdir('src')
+ subdir('hyprctl')
 diff --git a/src/meson.build b/src/meson.build
-index 7b658d31..60aa4057 100644
+index 2065c6f5..55530605 100644
 --- a/src/meson.build
 +++ b/src/meson.build
-@@ -7,16 +7,16 @@ executable('Hyprland', src,
+@@ -9,16 +9,16 @@ executable('Hyprland', src,
      server_protos,
      dependency('wayland-server'),
      dependency('wayland-client'),

nix/patches/portals.patch

@@ -1,26 +0,0 @@
-diff --git a/src/Compositor.cpp b/src/Compositor.cpp
-index a9d95f39..069a03ca 100644
---- a/src/Compositor.cpp
-+++ b/src/Compositor.cpp
-@@ -2340,14 +2340,18 @@ void CCompositor::performUserChecks() {
- 
-     static auto* const    PSUPPRESSPORTAL = &g_pConfigManager->getConfigValuePtr("misc:suppress_portal_warnings")->intValue;
- 
--    if (!*PSUPPRESSPORTAL) {
--        if (std::ranges::any_of(BAD_PORTALS, [&](const std::string& portal) { return std::filesystem::exists("/usr/share/xdg-desktop-portal/portals/" + portal + ".portal"); })) {
-+    static auto* const    PORTALDIRENV = getenv("XDG_DESKTOP_PORTAL_DIR");
-+
-+    static auto const     PORTALDIR = PORTALDIRENV != NULL ? std::string(PORTALDIRENV) : "";
-+
-+    if (!*PSUPPRESSPORTAL && PORTALDIR != "") {
-+        if (std::ranges::any_of(BAD_PORTALS, [&](const std::string& portal) { return std::filesystem::exists(PORTALDIR + "/" + portal + ".portal"); })) {
-             // bad portal detected
-             g_pHyprNotificationOverlay->addNotification("You have one or more incompatible xdg-desktop-portal impls installed. Please remove incompatible ones to avoid issues.",
-                                                         CColor(0), 15000, ICON_ERROR);
-         }
- 
--        if (std::filesystem::exists("/usr/share/xdg-desktop-portal/portals/hyprland.portal") && std::filesystem::exists("/usr/share/xdg-desktop-portal/portals/wlr.portal")) {
-+        if (std::filesystem::exists(PORTALDIR + "/hyprland.portal") && std::filesystem::exists(PORTALDIR + "/wlr.portal")) {
-             g_pHyprNotificationOverlay->addNotification("You have xdg-desktop-portal-hyprland and -wlr installed simultaneously. Please uninstall one to avoid issues.", CColor(0),
-                                                         15000, ICON_ERROR);
-         }

nix/patches/wlroots-hidpi.patch

@@ -1,164 +0,0 @@
-diff --git a/include/xwayland/xwm.h b/include/xwayland/xwm.h
-index 3d540522..1c5a2e37 100644
---- a/include/xwayland/xwm.h
-+++ b/include/xwayland/xwm.h
-@@ -88,6 +88,7 @@ enum atom_name {
- 	DND_ACTION_PRIVATE,
- 	NET_CLIENT_LIST,
- 	NET_CLIENT_LIST_STACKING,
-+	XWAYLAND_GLOBAL_OUTPUT_SCALE,
- 	ATOM_LAST // keep last
- };
- 
-@@ -96,6 +97,7 @@ struct wlr_xwm {
- 	struct wl_event_source *event_source;
- 	struct wlr_seat *seat;
- 	uint32_t ping_timeout;
-+	uint32_t scale;
- 
- 	xcb_atom_t atoms[ATOM_LAST];
- 	xcb_connection_t *xcb_conn;
-diff --git a/xwayland/xwm.c b/xwayland/xwm.c
-index 5f857f24..21584ebd 100644
---- a/xwayland/xwm.c
-+++ b/xwayland/xwm.c
-@@ -19,6 +19,14 @@
- #include <xcb/xfixes.h>
- #include "xwayland/xwm.h"
- 
-+static int32_t scale(struct wlr_xwm *xwm, uint32_t val) {
-+	return val * xwm->scale;
-+}
-+
-+static int32_t unscale(struct wlr_xwm *xwm, uint32_t val) {
-+	return (val + xwm->scale/2) / xwm->scale;
-+}
-+
- static const char *const atom_map[ATOM_LAST] = {
- 	[WL_SURFACE_ID] = "WL_SURFACE_ID",
- 	[WL_SURFACE_SERIAL] = "WL_SURFACE_SERIAL",
-@@ -90,6 +98,7 @@ static const char *const atom_map[ATOM_LAST] = {
- 	[DND_ACTION_PRIVATE] = "XdndActionPrivate",
- 	[NET_CLIENT_LIST] = "_NET_CLIENT_LIST",
- 	[NET_CLIENT_LIST_STACKING] = "_NET_CLIENT_LIST_STACKING",
-+	[XWAYLAND_GLOBAL_OUTPUT_SCALE] = "_XWAYLAND_GLOBAL_OUTPUT_SCALE",
- };
- 
- #define STARTUP_INFO_REMOVE_PREFIX "remove: ID="
-@@ -965,8 +974,8 @@ static void xwm_handle_create_notify(struct wlr_xwm *xwm,
- 		return;
- 	}
- 
--	xwayland_surface_create(xwm, ev->window, ev->x, ev->y,
--		ev->width, ev->height, ev->override_redirect);
-+	xwayland_surface_create(xwm, ev->window, unscale(xwm, ev->x), unscale(xwm, ev->y),
-+		unscale(xwm, ev->width), unscale(xwm, ev->height), ev->override_redirect);
- }
- 
- static void xwm_handle_destroy_notify(struct wlr_xwm *xwm,
-@@ -997,10 +1006,10 @@ static void xwm_handle_configure_request(struct wlr_xwm *xwm,
- 
- 	struct wlr_xwayland_surface_configure_event wlr_event = {
- 		.surface = surface,
--		.x = mask & XCB_CONFIG_WINDOW_X ? ev->x : surface->x,
--		.y = mask & XCB_CONFIG_WINDOW_Y ? ev->y : surface->y,
--		.width = mask & XCB_CONFIG_WINDOW_WIDTH ? ev->width : surface->width,
--		.height = mask & XCB_CONFIG_WINDOW_HEIGHT ? ev->height : surface->height,
-+		.x = mask & XCB_CONFIG_WINDOW_X ? unscale(xwm, ev->x) : surface->x,
-+		.y = mask & XCB_CONFIG_WINDOW_Y ? unscale(xwm, ev->y) : surface->y,
-+		.width = mask & XCB_CONFIG_WINDOW_WIDTH ? unscale(xwm, ev->width) : surface->width,
-+		.height = mask & XCB_CONFIG_WINDOW_HEIGHT ? unscale(xwm, ev->height) : surface->height,
- 		.mask = mask,
- 	};
- 
-@@ -1015,14 +1024,14 @@ static void xwm_handle_configure_notify(struct wlr_xwm *xwm,
- 	}
- 
- 	bool geometry_changed =
--		(xsurface->x != ev->x || xsurface->y != ev->y ||
--		 xsurface->width != ev->width || xsurface->height != ev->height);
-+		(xsurface->x != unscale(xwm, ev->x) || xsurface->y != unscale(xwm, ev->y) ||
-+		 xsurface->width != unscale(xwm, ev->width) || xsurface->height != unscale(xwm, ev->height));
- 
- 	if (geometry_changed) {
--		xsurface->x = ev->x;
--		xsurface->y = ev->y;
--		xsurface->width = ev->width;
--		xsurface->height = ev->height;
-+		xsurface->x = unscale(xwm, ev->x);
-+		xsurface->y = unscale(xwm, ev->y);
-+		xsurface->width = unscale(xwm, ev->width);
-+		xsurface->height = unscale(xwm, ev->height);
- 	}
- 
- 	if (xsurface->override_redirect != ev->override_redirect) {
-@@ -1133,6 +1142,20 @@ static void xwm_handle_property_notify(struct wlr_xwm *xwm,
- 		xcb_property_notify_event_t *ev) {
- 	struct wlr_xwayland_surface *xsurface = lookup_surface(xwm, ev->window);
- 	if (xsurface == NULL) {
-+		if (ev->atom == xwm->atoms[XWAYLAND_GLOBAL_OUTPUT_SCALE]) {
-+			xcb_get_property_cookie_t cookie = xcb_get_property(xwm->xcb_conn, 0,
-+					ev->window, ev->atom, XCB_ATOM_ANY, 0, 2048);
-+			xcb_get_property_reply_t *reply = xcb_get_property_reply(xwm->xcb_conn,
-+					cookie, NULL);
-+			if (reply == NULL) {
-+				return;
-+			}
-+			if (reply->type == XCB_ATOM_CARDINAL) {
-+				xwm->scale = *(uint32_t*)xcb_get_property_value(reply);
-+			}
-+			free(reply);
-+		}
-+
- 		return;
- 	}
- 
-@@ -1760,16 +1783,17 @@ void wlr_xwayland_surface_configure(struct wlr_xwayland_surface *xsurface,
- 	int old_w = xsurface->width;
- 	int old_h = xsurface->height;
- 
-+	struct wlr_xwm *xwm = xsurface->xwm;
-+
- 	xsurface->x = x;
- 	xsurface->y = y;
- 	xsurface->width = width;
- 	xsurface->height = height;
- 
--	struct wlr_xwm *xwm = xsurface->xwm;
- 	uint32_t mask = XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
- 		XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
- 		XCB_CONFIG_WINDOW_BORDER_WIDTH;
--	uint32_t values[] = {x, y, width, height, 0};
-+	uint32_t values[] = {scale(xwm, x), scale(xwm, y), scale(xwm, width), scale(xwm, height), 0};
- 	xcb_configure_window(xwm->xcb_conn, xsurface->window_id, mask, values);
- 
- 	// If the window size did not change, then we cannot rely on
-@@ -1777,15 +1801,15 @@ void wlr_xwayland_surface_configure(struct wlr_xwayland_surface *xsurface,
- 	// we are supposed to send a synthetic event. See ICCCM part
- 	// 4.1.5. But we ignore override-redirect windows as ICCCM does
- 	// not apply to them.
--	if (width == old_w && height == old_h && !xsurface->override_redirect) {
-+	if (scale(xwm, width) == scale(xwm, old_w) && scale(xwm, height) == scale(xwm, old_h) && !xsurface->override_redirect) {
- 		xcb_configure_notify_event_t configure_notify = {
- 			.response_type = XCB_CONFIGURE_NOTIFY,
- 			.event = xsurface->window_id,
- 			.window = xsurface->window_id,
--			.x = x,
--			.y = y,
--			.width = width,
--			.height = height,
-+			.x = scale(xwm, x),
-+			.y = scale(xwm, y),
-+			.width = scale(xwm, width),
-+			.height = scale(xwm, height),
- 		};
- 
- 		xcb_send_event(xwm->xcb_conn, 0, xsurface->window_id,
-@@ -2122,6 +2146,7 @@ struct wlr_xwm *xwm_create(struct wlr_xwayland *xwayland, int wm_fd) {
- 	wl_list_init(&xwm->pending_startup_ids);
- 	xwm->ping_timeout = 10000;
- 
-+	xwm->scale = 1;
- 	xwm->xcb_conn = xcb_connect_to_fd(wm_fd, NULL);
- 
- 	int rc = xcb_connection_has_error(xwm->xcb_conn);

nix/patches/wlroots-nvidia.patch

@@ -1,3 +1,16 @@
+diff --git a/render/gles2/renderer.c b/render/gles2/renderer.c
+index 9fe934f7..9662d4ee 100644
+--- a/render/gles2/renderer.c
++++ b/render/gles2/renderer.c
+@@ -176,7 +176,7 @@ static bool gles2_bind_buffer(struct wlr_renderer *wlr_renderer,
+ 		assert(wlr_egl_is_current(renderer->egl));
+ 
+ 		push_gles2_debug(renderer);
+-		glFlush();
++		glFinish();
+ 		glBindFramebuffer(GL_FRAMEBUFFER, 0);
+ 		pop_gles2_debug(renderer);
+ 
 diff --git a/types/output/render.c b/types/output/render.c
 index 2e38919a..97f78608 100644
 --- a/types/output/render.c

nix/patches/xwayland-hidpi.patch

@@ -1,493 +0,0 @@
-diff --git a/hw/xwayland/xwayland-cursor.c b/hw/xwayland/xwayland-cursor.c
-index e3c1aaa50..eba29b5ba 100644
---- a/hw/xwayland/xwayland-cursor.c
-+++ b/hw/xwayland/xwayland-cursor.c
-@@ -164,6 +164,8 @@ xwl_cursor_attach_pixmap(struct xwl_seat *xwl_seat,
-     }
- 
-     wl_surface_attach(xwl_cursor->surface, buffer, 0, 0);
-+    wl_surface_set_buffer_scale(xwl_cursor->surface,
-+                                xwl_seat->xwl_screen->global_output_scale);
-     xwl_surface_damage(xwl_seat->xwl_screen, xwl_cursor->surface, 0, 0,
-                        xwl_seat->x_cursor->bits->width,
-                        xwl_seat->x_cursor->bits->height);
-@@ -195,6 +197,7 @@ xwl_cursor_clear_frame_cb(struct xwl_cursor *xwl_cursor)
- void
- xwl_seat_set_cursor(struct xwl_seat *xwl_seat)
- {
-+    struct xwl_screen *xwl_screen = xwl_seat->xwl_screen;
-     struct xwl_cursor *xwl_cursor = &xwl_seat->cursor;
-     PixmapPtr pixmap;
-     CursorPtr cursor;
-@@ -225,8 +228,8 @@ xwl_seat_set_cursor(struct xwl_seat *xwl_seat)
-     wl_pointer_set_cursor(xwl_seat->wl_pointer,
-                           xwl_seat->pointer_enter_serial,
-                           xwl_cursor->surface,
--                          xwl_seat->x_cursor->bits->xhot,
--                          xwl_seat->x_cursor->bits->yhot);
-+                          xwl_scale_to(xwl_screen, xwl_seat->x_cursor->bits->xhot),
-+                          xwl_scale_to(xwl_screen, xwl_seat->x_cursor->bits->yhot));
- 
-     xwl_cursor_attach_pixmap(xwl_seat, xwl_cursor, pixmap);
- }
-@@ -235,6 +238,7 @@ void
- xwl_tablet_tool_set_cursor(struct xwl_tablet_tool *xwl_tablet_tool)
- {
-     struct xwl_seat *xwl_seat = xwl_tablet_tool->seat;
-+    struct xwl_screen *xwl_screen = xwl_seat->xwl_screen;
-     struct xwl_cursor *xwl_cursor = &xwl_tablet_tool->cursor;
-     PixmapPtr pixmap;
-     CursorPtr cursor;
-@@ -263,8 +267,9 @@ xwl_tablet_tool_set_cursor(struct xwl_tablet_tool *xwl_tablet_tool)
-     zwp_tablet_tool_v2_set_cursor(xwl_tablet_tool->tool,
-                                   xwl_tablet_tool->proximity_in_serial,
-                                   xwl_cursor->surface,
--                                  xwl_seat->x_cursor->bits->xhot,
--                                  xwl_seat->x_cursor->bits->yhot);
-+                                  xwl_scale_to(xwl_screen, xwl_seat->x_cursor->bits->xhot),
-+                                  xwl_scale_to(xwl_screen, xwl_seat->x_cursor->bits->yhot));
-+    wl_surface_set_buffer_scale(xwl_cursor->surface, xwl_screen->global_output_scale);
- 
-     xwl_cursor_attach_pixmap(xwl_seat, xwl_cursor, pixmap);
- }
-diff --git a/hw/xwayland/xwayland-input.c b/hw/xwayland/xwayland-input.c
-index 6e0600e4e..4a22ebff0 100644
---- a/hw/xwayland/xwayland-input.c
-+++ b/hw/xwayland/xwayland-input.c
-@@ -507,8 +507,8 @@ pointer_handle_enter(void *data, struct wl_pointer *pointer,
-     DeviceIntPtr dev = get_pointer_device(xwl_seat);
-     DeviceIntPtr master;
-     int i;
--    int sx = wl_fixed_to_int(sx_w);
--    int sy = wl_fixed_to_int(sy_w);
-+    int sx = wl_fixed_to_int(sx_w) * xwl_seat->xwl_screen->global_output_scale;
-+    int sy = wl_fixed_to_int(sy_w) * xwl_seat->xwl_screen->global_output_scale;
-     int dx, dy;
-     ScreenPtr pScreen = xwl_seat->xwl_screen->screen;
-     ValuatorMask mask;
-@@ -731,13 +731,14 @@ pointer_handle_motion(void *data, struct wl_pointer *pointer,
-                       uint32_t time, wl_fixed_t sx_w, wl_fixed_t sy_w)
- {
-     struct xwl_seat *xwl_seat = data;
-+    int32_t scale = xwl_seat->xwl_screen->global_output_scale;
- 
-     if (!xwl_seat->focus_window)
-         return;
- 
-     xwl_seat->pending_pointer_event.has_absolute = TRUE;
--    xwl_seat->pending_pointer_event.x = sx_w;
--    xwl_seat->pending_pointer_event.y = sy_w;
-+    xwl_seat->pending_pointer_event.x = sx_w * scale;
-+    xwl_seat->pending_pointer_event.y = sy_w * scale;
- 
-     if (wl_proxy_get_version((struct wl_proxy *) xwl_seat->wl_pointer) < 5)
-         dispatch_pointer_motion_event(xwl_seat);
-@@ -887,12 +888,13 @@ relative_pointer_handle_relative_motion(void *data,
-                                         wl_fixed_t dy_unaccelf)
- {
-     struct xwl_seat *xwl_seat = data;
-+    int32_t scale = xwl_seat->xwl_screen->global_output_scale;
- 
-     xwl_seat->pending_pointer_event.has_relative = TRUE;
--    xwl_seat->pending_pointer_event.dx = wl_fixed_to_double(dxf);
--    xwl_seat->pending_pointer_event.dy = wl_fixed_to_double(dyf);
--    xwl_seat->pending_pointer_event.dx_unaccel = wl_fixed_to_double(dx_unaccelf);
--    xwl_seat->pending_pointer_event.dy_unaccel = wl_fixed_to_double(dy_unaccelf);
-+    xwl_seat->pending_pointer_event.dx = wl_fixed_to_double(dxf) * scale;
-+    xwl_seat->pending_pointer_event.dy = wl_fixed_to_double(dyf) * scale;
-+    xwl_seat->pending_pointer_event.dx_unaccel = wl_fixed_to_double(dx_unaccelf) * scale;
-+    xwl_seat->pending_pointer_event.dy_unaccel = wl_fixed_to_double(dy_unaccelf) * scale;
- 
-     if (!xwl_seat->focus_window)
-         return;
-@@ -1382,8 +1384,8 @@ touch_handle_down(void *data, struct wl_touch *wl_touch,
- 
-     xwl_touch->window = wl_surface_get_user_data(surface);
-     xwl_touch->id = id;
--    xwl_touch->x = wl_fixed_to_int(sx_w);
--    xwl_touch->y = wl_fixed_to_int(sy_w);
-+    xwl_touch->x = wl_fixed_to_int(sx_w) * xwl_seat->xwl_screen->global_output_scale;
-+    xwl_touch->y = wl_fixed_to_int(sy_w) * xwl_seat->xwl_screen->global_output_scale;
-     xorg_list_add(&xwl_touch->link_touch, &xwl_seat->touches);
- 
-     xwl_touch_send_event(xwl_touch, xwl_seat, XI_TouchBegin);
-@@ -1419,8 +1421,8 @@ touch_handle_motion(void *data, struct wl_touch *wl_touch,
-     if (!xwl_touch)
-         return;
- 
--    xwl_touch->x = wl_fixed_to_int(sx_w);
--    xwl_touch->y = wl_fixed_to_int(sy_w);
-+    xwl_touch->x = wl_fixed_to_int(sx_w) * xwl_seat->xwl_screen->global_output_scale;
-+    xwl_touch->y = wl_fixed_to_int(sy_w) * xwl_seat->xwl_screen->global_output_scale;
-     xwl_touch_send_event(xwl_touch, xwl_seat, XI_TouchUpdate);
- }
- 
-@@ -2110,8 +2112,8 @@ tablet_tool_motion(void *data, struct zwp_tablet_tool_v2 *tool,
-     struct xwl_tablet_tool *xwl_tablet_tool = data;
-     struct xwl_seat *xwl_seat = xwl_tablet_tool->seat;
-     int32_t dx, dy;
--    double sx = wl_fixed_to_double(x);
--    double sy = wl_fixed_to_double(y);
-+    double sx = wl_fixed_to_double(x) * xwl_seat->xwl_screen->global_output_scale;
-+    double sy = wl_fixed_to_double(y) * xwl_seat->xwl_screen->global_output_scale;
- 
-     if (!xwl_seat->tablet_focus_window)
-         return;
-@@ -3152,6 +3154,7 @@ xwl_pointer_warp_emulator_set_fake_pos(struct xwl_pointer_warp_emulator *warp_em
-                                        int x,
-                                        int y)
- {
-+    struct xwl_screen *xwl_screen;
-     struct zwp_locked_pointer_v1 *locked_pointer =
-         warp_emulator->locked_pointer;
-     WindowPtr window;
-@@ -3163,6 +3166,7 @@ xwl_pointer_warp_emulator_set_fake_pos(struct xwl_pointer_warp_emulator *warp_em
-     if (!warp_emulator->xwl_seat->focus_window)
-         return;
- 
-+    xwl_screen = warp_emulator->xwl_seat->xwl_screen;
-     window = warp_emulator->xwl_seat->focus_window->window;
-     if (x >= window->drawable.x ||
-         y >= window->drawable.y ||
-@@ -3171,8 +3175,8 @@ xwl_pointer_warp_emulator_set_fake_pos(struct xwl_pointer_warp_emulator *warp_em
-         sx = x - window->drawable.x;
-         sy = y - window->drawable.y;
-         zwp_locked_pointer_v1_set_cursor_position_hint(locked_pointer,
--                                                       wl_fixed_from_int(sx),
--                                                       wl_fixed_from_int(sy));
-+                                                       wl_fixed_from_int(xwl_scale_to(xwl_screen, sx)),
-+                                                       wl_fixed_from_int(xwl_scale_to(xwl_screen, sy)));
-         wl_surface_commit(warp_emulator->xwl_seat->focus_window->surface);
-     }
- }
-diff --git a/hw/xwayland/xwayland-output.c b/hw/xwayland/xwayland-output.c
-index 661e1828d..6c60aba34 100644
---- a/hw/xwayland/xwayland-output.c
-+++ b/hw/xwayland/xwayland-output.c
-@@ -186,6 +186,9 @@ update_backing_pixmaps(struct xwl_screen *xwl_screen, int width, int height)
- static void
- update_screen_size(struct xwl_screen *xwl_screen, int width, int height)
- {
-+    width *= xwl_screen->global_output_scale;
-+    height *= xwl_screen->global_output_scale;
-+
-     xwl_screen->width = width;
-     xwl_screen->height = height;
- 
-@@ -597,14 +600,15 @@ xwl_output_set_emulated_mode(struct xwl_output *xwl_output, ClientPtr client,
-                                              new_emulated_height);
- }
- 
--static void
--apply_output_change(struct xwl_output *xwl_output)
-+void
-+xwl_output_apply_changes(struct xwl_output *xwl_output)
- {
-     struct xwl_screen *xwl_screen = xwl_output->xwl_screen;
-     struct xwl_output *it;
-     int mode_width, mode_height, count;
-     int width = 0, height = 0, has_this_output = 0;
-     RRModePtr *randr_modes;
-+    int32_t scale = xwl_screen->global_output_scale;
- 
-     /* Clear out the "done" received flags */
-     xwl_output->wl_output_done = FALSE;
-@@ -623,10 +627,10 @@ apply_output_change(struct xwl_output *xwl_output)
-     }
-     if (xwl_output->randr_output) {
-         /* Build a fresh modes array using the current refresh rate */
--        randr_modes = output_get_rr_modes(xwl_output, mode_width, mode_height, &count);
-+        randr_modes = output_get_rr_modes(xwl_output, mode_width * scale, mode_height * scale, &count);
-         RROutputSetModes(xwl_output->randr_output, randr_modes, count, 1);
-         RRCrtcNotify(xwl_output->randr_crtc, randr_modes[0],
--                     xwl_output->x, xwl_output->y,
-+                     xwl_output->x * scale, xwl_output->y * scale,
-                      xwl_output->rotation, NULL, 1, &xwl_output->randr_output);
-         /* RROutputSetModes takes ownership of the passed in modes, so we only
-          * have to free the pointer array.
-@@ -686,7 +690,7 @@ output_handle_done(void *data, struct wl_output *wl_output)
-      */
-     if (xwl_output->xdg_output_done || !xwl_output->xdg_output ||
-         zxdg_output_v1_get_version(xwl_output->xdg_output) >= 3)
--        apply_output_change(xwl_output);
-+        xwl_output_apply_changes(xwl_output);
- }
- 
- static void
-@@ -746,7 +750,7 @@ xdg_output_handle_done(void *data, struct zxdg_output_v1 *xdg_output)
-     xwl_output->xdg_output_done = TRUE;
-     if (xwl_output->wl_output_done &&
-         zxdg_output_v1_get_version(xdg_output) < 3)
--        apply_output_change(xwl_output);
-+        xwl_output_apply_changes(xwl_output);
- }
- 
- static void
-@@ -857,6 +861,8 @@ xwl_output_create(struct xwl_screen *xwl_screen, uint32_t id,
-         RRCrtcGammaSetSize(xwl_output->randr_crtc, 256);
-         RROutputSetCrtcs(xwl_output->randr_output, &xwl_output->randr_crtc, 1);
-         RROutputSetConnection(xwl_output->randr_output, RR_Connected);
-+
-+        xwl_output->scale = 1;
-     }
-     /* We want the output to be in the list as soon as created so we can
-      * use it when binding to the xdg-output protocol...
-diff --git a/hw/xwayland/xwayland-output.h b/hw/xwayland/xwayland-output.h
-index a95288e4f..46d1ead2a 100644
---- a/hw/xwayland/xwayland-output.h
-+++ b/hw/xwayland/xwayland-output.h
-@@ -53,7 +53,7 @@ struct xwl_output {
-     struct wl_output *output;
-     struct zxdg_output_v1 *xdg_output;
-     uint32_t server_output_id;
--    int32_t x, y, width, height, refresh;
-+    int32_t x, y, width, height, refresh, scale;
-     Rotation rotation;
-     Bool wl_output_done;
-     Bool xdg_output_done;
-@@ -102,6 +102,8 @@ void xwl_output_set_emulated_mode(struct xwl_output *xwl_output,
- void xwl_output_set_window_randr_emu_props(struct xwl_screen *xwl_screen,
-                                            WindowPtr window);
- 
-+void xwl_output_apply_changes(struct xwl_output *xwl_output);
-+
- void xwl_screen_init_xdg_output(struct xwl_screen *xwl_screen);
- 
- #endif /* XWAYLAND_OUTPUT_H */
-diff --git a/hw/xwayland/xwayland-present.c b/hw/xwayland/xwayland-present.c
-index 189e7cfd6..555434031 100644
---- a/hw/xwayland/xwayland-present.c
-+++ b/hw/xwayland/xwayland-present.c
-@@ -764,6 +764,8 @@ xwl_present_flip(WindowPtr present_window,
- 
-     /* We can flip directly to the main surface (full screen window without clips) */
-     wl_surface_attach(xwl_window->surface, buffer, 0, 0);
-+    wl_surface_set_buffer_scale(xwl_window->surface,
-+                                xwl_window->xwl_screen->global_output_scale);
- 
-     if (xorg_list_is_empty(&xwl_present_window->frame_callback_list)) {
-         xorg_list_add(&xwl_present_window->frame_callback_list,
-diff --git a/hw/xwayland/xwayland-screen.c b/hw/xwayland/xwayland-screen.c
-index 46ab4fed7..b2d7022e6 100644
---- a/hw/xwayland/xwayland-screen.c
-+++ b/hw/xwayland/xwayland-screen.c
-@@ -51,6 +51,7 @@
- #include "xwayland-pixmap.h"
- #include "xwayland-present.h"
- #include "xwayland-shm.h"
-+#include "xwayland-window-buffers.h"
- 
- #ifdef MITSHM
- #include "shmint.h"
-@@ -111,6 +112,12 @@ xwl_screen_has_resolution_change_emulation(struct xwl_screen *xwl_screen)
-     return xwl_screen->rootless && xwl_screen_has_viewport_support(xwl_screen);
- }
- 
-+int
-+xwl_scale_to(struct xwl_screen *xwl_screen, int value)
-+{
-+    return value / (double)xwl_screen->global_output_scale + 0.5;
-+}
-+
- /* Return the output @ 0x0, falling back to the first output in the list */
- struct xwl_output *
- xwl_screen_get_first_output(struct xwl_screen *xwl_screen)
-@@ -128,6 +135,38 @@ xwl_screen_get_first_output(struct xwl_screen *xwl_screen)
-     return xorg_list_first_entry(&xwl_screen->output_list, struct xwl_output, link);
- }
- 
-+static void
-+xwl_screen_set_global_scale_from_property(struct xwl_screen *screen,
-+                                          PropertyPtr prop)
-+{
-+    CARD32 *propdata;
-+
-+    if (prop->type != XA_CARDINAL || prop->format != 32 || prop->size != 1) {
-+        // TODO: handle warnings more cleanly.
-+        LogMessageVerb(X_WARNING, 0, "Bad value for property %s.\n",
-+                        NameForAtom(prop->propertyName));
-+        return;
-+    }
-+
-+    propdata = prop->data;
-+    xwl_screen_set_global_scale(screen, propdata[0]);
-+}
-+
-+static void
-+xwl_screen_update_property(struct xwl_screen *screen,
-+                           PropertyStateRec *propstate)
-+{
-+    switch (propstate->state) {
-+    case PropertyNewValue:
-+        xwl_screen_set_global_scale_from_property(screen, propstate->prop);
-+        break;
-+    case PropertyDelete:
-+        xwl_screen_set_global_scale(screen, 1);
-+        break;
-+    }
-+}
-+
-+
- struct xwl_output *
- xwl_screen_get_fixed_or_first_output(struct xwl_screen *xwl_screen)
- {
-@@ -144,19 +183,24 @@ xwl_property_callback(CallbackListPtr *pcbl, void *closure,
-     ScreenPtr screen = closure;
-     PropertyStateRec *rec = calldata;
-     struct xwl_screen *xwl_screen;
--    struct xwl_window *xwl_window;
- 
-     if (rec->win->drawable.pScreen != screen)
-         return;
- 
--    xwl_window = xwl_window_get(rec->win);
--    if (!xwl_window)
--        return;
--
-     xwl_screen = xwl_screen_get(screen);
- 
--    if (rec->prop->propertyName == xwl_screen->allow_commits_prop)
--        xwl_window_update_property(xwl_window, rec);
-+    if (rec->prop->propertyName == xwl_screen->allow_commits_prop) {
-+        struct xwl_window *xwl_window;
-+
-+        xwl_window = xwl_window_get(rec->win);
-+        if (!xwl_window)
-+            return;
-+
-+         xwl_window_update_property(xwl_window, rec);
-+    }
-+    else if (rec->prop->propertyName == xwl_screen->global_output_scale_prop) {
-+        xwl_screen_update_property(xwl_screen, rec);
-+    }
- }
- 
- static void
-@@ -638,8 +682,14 @@ void xwl_surface_damage(struct xwl_screen *xwl_screen,
- {
-     if (wl_surface_get_version(surface) >= WL_SURFACE_DAMAGE_BUFFER_SINCE_VERSION)
-         wl_surface_damage_buffer(surface, x, y, width, height);
--    else
-+    else {
-+        x = xwl_scale_to(xwl_screen, x);
-+        y = xwl_scale_to(xwl_screen, y);
-+        width = xwl_scale_to(xwl_screen, width);
-+        height = xwl_scale_to(xwl_screen, height);
-+
-         wl_surface_damage(surface, x, y, width, height);
-+    }
- }
- 
- void
-@@ -655,6 +705,30 @@ xwl_screen_roundtrip(struct xwl_screen *xwl_screen)
-         xwl_give_up("could not connect to wayland server\n");
- }
- 
-+void
-+xwl_screen_set_global_scale(struct xwl_screen *xwl_screen, int32_t scale)
-+{
-+    struct xwl_output *it;
-+    struct xwl_window *xwl_window;
-+
-+    xwl_screen->global_output_scale = scale;
-+
-+    /* change randr resolutions and positions */
-+    xorg_list_for_each_entry(it, &xwl_screen->output_list, link) {
-+        xwl_output_apply_changes(it);
-+    }
-+
-+    if (!xwl_screen->rootless && xwl_screen->screen->root) {
-+        /* Clear all the buffers, so that they'll be remade with the new sizes
-+         * (this doesn't occur automatically because as far as Xorg is
-+         *  concerned, the window's size is the same) */
-+        xorg_list_for_each_entry(xwl_window, &xwl_screen->window_list, link_window) {
-+            xwl_window_buffers_recycle(xwl_window);
-+        }
-+    }
-+}
-+
-+
- static int
- xwl_server_grab(ClientPtr client)
- {
-@@ -712,6 +786,7 @@ Bool
- xwl_screen_init(ScreenPtr pScreen, int argc, char **argv)
- {
-     static const char allow_commits[] = "_XWAYLAND_ALLOW_COMMITS";
-+    static const char global_output_scale[] = "_XWAYLAND_GLOBAL_OUTPUT_SCALE";
-     struct xwl_screen *xwl_screen;
-     Pixel red_mask, blue_mask, green_mask;
-     int ret, bpc, green_bpc, i;
-@@ -746,6 +821,7 @@ xwl_screen_init(ScreenPtr pScreen, int argc, char **argv)
- #ifdef XWL_HAS_GLAMOR
-     xwl_screen->glamor = 1;
- #endif
-+    xwl_screen->global_output_scale = 1;
- 
-     for (i = 1; i < argc; i++) {
-         if (strcmp(argv[i], "-rootless") == 0) {
-@@ -988,6 +1064,13 @@ xwl_screen_init(ScreenPtr pScreen, int argc, char **argv)
-     if (xwl_screen->allow_commits_prop == BAD_RESOURCE)
-         return FALSE;
- 
-+    xwl_screen->global_output_scale_prop = MakeAtom(global_output_scale,
-+                                                    strlen(global_output_scale),
-+                                                    TRUE);
-+    if (xwl_screen->global_output_scale_prop == BAD_RESOURCE)
-+        return FALSE;
-+
-+
-     AddCallback(&PropertyStateCallback, xwl_property_callback, pScreen);
-     AddCallback(&RootWindowFinalizeCallback, xwl_root_window_finalized_callback, pScreen);
- 
-diff --git a/hw/xwayland/xwayland-screen.h b/hw/xwayland/xwayland-screen.h
-index fadd0526e..2ce6ce5ab 100644
---- a/hw/xwayland/xwayland-screen.h
-+++ b/hw/xwayland/xwayland-screen.h
-@@ -87,6 +87,7 @@ struct xwl_screen {
-     struct xorg_list damage_window_list;
-     struct xorg_list window_list;
- 
-+    int32_t global_output_scale;
-     int wayland_fd;
-     struct wl_display *display;
-     struct wl_registry *registry;
-@@ -134,6 +135,7 @@ struct xwl_screen {
-     struct glamor_context *glamor_ctx;
- 
-     Atom allow_commits_prop;
-+    Atom global_output_scale_prop;
- 
-     /* The preferred GLVND vendor. If NULL, "mesa" is assumed. */
-     const char *glvnd_vendor;
-@@ -166,6 +168,8 @@ void xwl_screen_roundtrip (struct xwl_screen *xwl_screen);
- void xwl_surface_damage(struct xwl_screen *xwl_screen,
-                         struct wl_surface *surface,
-                         int32_t x, int32_t y, int32_t width, int32_t height);
-+int xwl_scale_to(struct xwl_screen *xwl_screen, int value);
-+void xwl_screen_set_global_scale(struct xwl_screen *xwl_screen, int32_t scale);
- int xwl_screen_get_next_output_serial(struct xwl_screen * xwl_screen);
- 
- #endif /* XWAYLAND_SCREEN_H */
-diff --git a/hw/xwayland/xwayland-window.c b/hw/xwayland/xwayland-window.c
-index 6b7f38605..2f1e0dee1 100644
---- a/hw/xwayland/xwayland-window.c
-+++ b/hw/xwayland/xwayland-window.c
-@@ -788,7 +788,8 @@ xwl_create_root_surface(struct xwl_window *xwl_window)
-     }
- 
-     wl_region_add(region, 0, 0,
--                  window->drawable.width, window->drawable.height);
-+                 xwl_scale_to(xwl_screen, window->drawable.width),
-+                 xwl_scale_to(xwl_screen, window->drawable.height));
-     wl_surface_set_opaque_region(xwl_window->surface, region);
-     wl_region_destroy(region);
- 
-@@ -1322,6 +1323,7 @@ xwl_window_post_damage(struct xwl_window *xwl_window)
- #endif
- 
-     wl_surface_attach(xwl_window->surface, buffer, 0, 0);
-+    wl_surface_set_buffer_scale(xwl_window->surface, xwl_screen->global_output_scale);
- 
-     /* Arbitrary limit to try to avoid flooding the Wayland
-      * connection. If we flood it too much anyway, this could

nix/patches/xwayland-vsync.patch

@@ -1,12 +0,0 @@
---- a/hw/xwayland/xwayland-present.c
-+++ b/hw/xwayland/xwayland-present.c
-@@ -824,7 +824,8 @@
-         dixDestroyPixmap(vblank->pixmap, vblank->pixmap->drawable.id);
-         vblank->pixmap = NULL;
-
--        if (xwl_present_queue_vblank(screen, window, vblank->crtc,
-+        if (vblank->target_msc > crtc_msc &&
-+            xwl_present_queue_vblank(screen, window, vblank->crtc,
-                                      vblank->event_id, crtc_msc + 1)
-             == Success)
-             return;

nix/wlroots.nix

@@ -1,73 +1,28 @@
 {
+  lib,
   version,
   src,
-  #
   wlroots,
-  xwayland,
-  fetchpatch,
-  lib,
   hwdata,
-  libliftoff,
   libdisplay-info,
-  hidpiXWayland ? true,
+  libliftoff,
   enableXWayland ? true,
-  nvidiaPatches ? false,
+  enableNvidiaPatches ? false,
 }:
-assert (lib.assertMsg (hidpiXWayland -> enableXWayland) ''
-  wlroots-hyprland: cannot have hidpiXWayland when enableXWayland is false.
-'');
-  (wlroots.overrideAttrs
-    (old: {
-      inherit version src;
-      pname =
-        old.pname
-        + "-hyprland"
-        + (
-          if hidpiXWayland
-          then "-hidpi"
-          else ""
-        )
-        + (
-          if nvidiaPatches
-          then "-nvidia"
-          else ""
-        );
-      patches =
-        (old.patches or [])
-        ++ (lib.optionals (enableXWayland && hidpiXWayland) [
-          # adapted from https://gitlab.freedesktop.org/lilydjwg/wlroots/-/commit/6c5ffcd1fee9e44780a6a8792f74ecfbe24a1ca7
-          ./patches/wlroots-hidpi.patch
-          (fetchpatch {
-            url = "https://gitlab.freedesktop.org/wlroots/wlroots/-/commit/18595000f3a21502fd60bf213122859cc348f9af.diff";
-            sha256 = "sha256-jvfkAMh3gzkfuoRhB4E9T5X1Hu62wgUjj4tZkJm0mrI=";
-            revert = true;
-          })
-        ])
-        ++ (lib.optionals nvidiaPatches [
-          ./patches/wlroots-nvidia.patch
-        ]);
-      postPatch =
-        (old.postPatch or "")
-        + (
-          if nvidiaPatches
-          then ''
-            substituteInPlace render/gles2/renderer.c --replace "glFlush();" "glFinish();"
-          ''
-          else ""
-        );
-      buildInputs = old.buildInputs ++ [hwdata libliftoff libdisplay-info];
+wlroots.overrideAttrs (old: {
+  inherit version src enableXWayland;
 
-      NIX_CFLAGS_COMPILE = toString [
-        "-Wno-error=maybe-uninitialized"
-      ];
-    }))
-  .override {
-    xwayland = xwayland.overrideAttrs (old: {
-      patches =
-        (old.patches or [])
-        ++ (lib.optionals hidpiXWayland [
-          ./patches/xwayland-vsync.patch
-          ./patches/xwayland-hidpi.patch
-        ]);
-    });
-  }
+  pname = "${old.pname}-hyprland${lib.optionalString enableNvidiaPatches "-nvidia"}";
+
+  patches =
+    (old.patches or [])
+    ++ (lib.optionals enableNvidiaPatches [
+      ./patches/wlroots-nvidia.patch
+    ]);
+
+  buildInputs = old.buildInputs ++ [hwdata libliftoff libdisplay-info];
+
+  NIX_CFLAGS_COMPILE = toString [
+    "-Wno-error=maybe-uninitialized"
+  ];
+})

props.json

@@ -1,3 +1,3 @@
 {
-    "version": "0.28.0"
+    "version": "0.31.0"
 }

protocols/ext-workspace-unstable-v1.xml

@@ -1,306 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<protocol name="ext_workspace_unstable_v1">
-  <copyright>
-    Copyright © 2019 Christopher Billington
-    Copyright © 2020 Ilia Bozhinov
-
-    Permission to use, copy, modify, distribute, and sell this
-    software and its documentation for any purpose is hereby granted
-    without fee, provided that the above copyright notice appear in
-    all copies and that both that copyright notice and this permission
-    notice appear in supporting documentation, and that the name of
-    the copyright holders not be used in advertising or publicity
-    pertaining to distribution of the software without specific,
-    written prior permission.  The copyright holders make no
-    representations about the suitability of this software for any
-    purpose.  It is provided "as is" without express or implied
-    warranty.
-
-    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
-    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
-    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
-    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
-    THIS SOFTWARE.
-  </copyright>
-
-  <interface name="zext_workspace_manager_v1" version="1">
-    <description summary="list and control workspaces">
-      Workspaces, also called virtual desktops, are groups of surfaces. A
-      compositor with a concept of workspaces may only show some such groups of
-      surfaces (those of 'active' workspaces) at a time. 'Activating' a
-      workspace is a request for the compositor to display that workspace's
-      surfaces as normal, whereas the compositor may hide or otherwise
-      de-emphasise surfaces that are associated only with 'inactive' workspaces.
-      Workspaces are grouped by which sets of outputs they correspond to, and
-      may contain surfaces only from those outputs. In this way, it is possible
-      for each output to have its own set of workspaces, or for all outputs (or
-      any other arbitrary grouping) to share workspaces. Compositors may
-      optionally conceptually arrange each group of workspaces in an
-      N-dimensional grid.
-
-      The purpose of this protocol is to enable the creation of taskbars and
-      docks by providing them with a list of workspaces and their properties,
-      and allowing them to activate and deactivate workspaces.
-
-      After a client binds the zext_workspace_manager_v1, each workspace will be
-      sent via the workspace event.
-    </description>
-
-    <event name="workspace_group">
-      <description summary="a workspace group has been created">
-        This event is emitted whenever a new workspace group has been created.
-
-        All initial details of the workspace group (workspaces, outputs) will be
-        sent immediately after this event via the corresponding events in
-        zext_workspace_group_handle_v1.
-      </description>
-      <arg name="workspace_group" type="new_id" interface="zext_workspace_group_handle_v1"/>
-    </event>
-
-    <request name="commit">
-      <description summary="all requests about the workspaces have been sent">
-        The client must send this request after it has finished sending other
-        requests. The compositor must process a series of requests preceding a
-        commit request atomically.
-
-        This allows changes to the workspace properties to be seen as atomic,
-        even if they happen via multiple events, and even if they involve
-        multiple zext_workspace_handle_v1 objects, for example, deactivating one
-        workspace and activating another.
-      </description>
-    </request>
-
-    <event name="done">
-      <description summary="all information about the workspace groups has been sent">
-        This event is sent after all changes in all workspace groups have been
-        sent.
-
-        This allows changes to one or more zext_workspace_group_handle_v1
-        properties to be seen as atomic, even if they happen via multiple
-        events. In particular, an output moving from one workspace group to
-        another sends an output_enter event and an output_leave event to the two
-        zext_workspace_group_handle_v1 objects in question. The compositor sends
-        the done event only after updating the output information in both
-        workspace groups.
-      </description>
-    </event>
-
-    <event name="finished">
-      <description summary="the compositor has finished with the workspace_manager">
-        This event indicates that the compositor is done sending events to the
-        zext_workspace_manager_v1. The server will destroy the object
-        immediately after sending this request, so it will become invalid and
-        the client should free any resources associated with it.
-      </description>
-    </event>
-
-    <request name="stop">
-      <description summary="stop sending events">
-        Indicates the client no longer wishes to receive events for new
-        workspace groups. However the compositor may emit further workspace
-        events, until the finished event is emitted.
-
-        The client must not send any more requests after this one.
-      </description>
-    </request>
-  </interface>
-
-  <interface name="zext_workspace_group_handle_v1" version="1">
-    <description summary="a workspace group assigned to a set of outputs">
-      A zext_workspace_group_handle_v1 object represents a a workspace group
-      that is assigned a set of outputs and contains a number of workspaces.
-
-      The set of outputs assigned to the workspace group is conveyed to the client via
-      output_enter and output_leave events, and its workspaces are conveyed with
-      workspace events.
-
-      For example, a compositor which has a set of workspaces for each output may
-      advertise a workspace group (and its workspaces) per output, whereas a compositor
-      where a workspace spans all outputs may advertise a single workspace group for all
-      outputs.
-    </description>
-
-    <event name="output_enter">
-      <description summary="output assigned to workspace group">
-        This event is emitted whenever an output is assigned to the workspace
-        group.
-      </description>
-      <arg name="output" type="object" interface="wl_output"/>
-    </event>
-
-    <event name="output_leave">
-      <description summary="output removed from workspace group">
-        This event is emitted whenever an output is removed from the workspace
-        group.
-      </description>
-      <arg name="output" type="object" interface="wl_output"/>
-    </event>
-
-    <event name="workspace">
-      <description summary="workspace added to workspace group">
-        This event is emitted whenever a new workspace has been created.
-
-        All initial details of the workspace (name, coordinates, state) will
-        be sent immediately after this event via the corresponding events in
-        zext_workspace_handle_v1.
-      </description>
-      <arg name="workspace" type="new_id" interface="zext_workspace_handle_v1"/>
-    </event>
-
-    <event name="remove">
-      <description summary="this workspace group has been destroyed">
-        This event means the zext_workspace_group_handle_v1 has been destroyed.
-        It is guaranteed there won't be any more events for this
-        zext_workspace_group_handle_v1. The zext_workspace_group_handle_v1 becomes
-        inert so any requests will be ignored except the destroy request.
-
-        The compositor must remove all workspaces belonging to a workspace group
-        before removing the workspace group.
-      </description>
-    </event>
-
-    <request name="create_workspace">
-      <description summary="create a new workspace">
-        Request that the compositor create a new workspace with the given name.
-
-        There is no guarantee that the compositor will create a new workspace,
-        or that the created workspace will have the provided name.
-      </description>
-      <arg name="workspace" type="string"/>
-    </request>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy the zext_workspace_handle_v1 object">
-        Destroys the zext_workspace_handle_v1 object.
-
-        This request should be called either when the client does not want to
-        use the workspace object any more or after the remove event to finalize
-        the destruction of the object.
-      </description>
-    </request>
-  </interface>
-
-  <interface name="zext_workspace_handle_v1" version="1">
-    <description summary="a workspace handing a group of surfaces">
-      A zext_workspace_handle_v1 object represents a a workspace that handles a
-      group of surfaces.
-
-      Each workspace has a name, conveyed to the client with the name event; a
-      list of states, conveyed to the client with the state event; and
-      optionally a set of coordinates, conveyed to the client with the
-      coordinates event. The client may request that the compositor activate or
-      deactivate the workspace.
-
-      Each workspace can belong to only a single workspace group.
-      Depepending on the compositor policy, there might be workspaces with
-      the same name in different workspace groups, but these workspaces are still
-      separate (e.g. one of them might be active while the other is not).
-    </description>
-
-    <event name="name">
-      <description summary="workspace name changed">
-        This event is emitted immediately after the zext_workspace_handle_v1 is
-        created and whenever the name of the workspace changes.
-      </description>
-      <arg name="name" type="string"/>
-    </event>
-
-    <event name="coordinates">
-      <description summary="workspace coordinates changed">
-        This event is used to organize workspaces into an N-dimensional grid
-        within a workspace group, and if supported, is emitted immediately after
-        the zext_workspace_handle_v1 is created and whenever the coordinates of
-        the workspace change. Compositors may not send this event if they do not
-        conceptually arrange workspaces in this way. If compositors simply
-        number workspaces, without any geometric interpretation, they may send
-        1D coordinates, which clients should not interpret as implying any
-        geometry. Sending an empty array means that the compositor no longer
-        orders the workspace geometrically.
-
-        Coordinates have an arbitrary number of dimensions N with an uint32
-        position along each dimension. By convention if N > 1, the first
-        dimension is X, the second Y, the third Z, and so on. The compositor may
-        chose to utilize these events for a more novel workspace layout
-        convention, however. No guarantee is made about the grid being filled or
-        bounded; there may be a workspace at coordinate 1 and another at
-        coordinate 1000 and none in between. Within a workspace group, however,
-        workspaces must have unique coordinates of equal dimensionality.
-      </description>
-      <arg name="coordinates" type="array"/>
-    </event>
-
-    <event name="state">
-      <description summary="the state of the workspace changed">
-        This event is emitted immediately after the zext_workspace_handle_v1 is
-        created and each time the workspace state changes, either because of a
-        compositor action or because of a request in this protocol.
-      </description>
-      <arg name="state" type="array"/>
-    </event>
-
-    <enum name="state">
-      <description summary="types of states on the workspace">
-        The different states that a workspace can have.
-      </description>
-
-      <entry name="active" value="0" summary="the workspace is active"/>
-      <entry name="urgent" value="1" summary="the workspace requests attention"/>
-      <entry name="hidden" value="2">
-        <description summary="the workspace is not visible">
-          The workspace is not visible in its workspace group, and clients
-          attempting to visualize the compositor workspace state should not
-          display such workspaces.
-        </description>
-      </entry>
-    </enum>
-
-    <event name="remove">
-      <description summary="this workspace has been destroyed">
-        This event means the zext_workspace_handle_v1 has been destroyed. It is
-        guaranteed there won't be any more events for this
-        zext_workspace_handle_v1. The zext_workspace_handle_v1 becomes inert so
-        any requests will be ignored except the destroy request.
-      </description>
-    </event>
-
-    <request name="destroy" type="destructor">
-      <description summary="destroy the zext_workspace_handle_v1 object">
-        Destroys the zext_workspace_handle_v1 object.
-
-        This request should be called either when the client does not want to
-        use the workspace object any more or after the remove event to finalize
-        the destruction of the object.
-      </description>
-    </request>
-
-    <request name="activate">
-      <description summary="activate the workspace">
-        Request that this workspace be activated.
-
-        There is no guarantee the workspace will be actually activated, and
-        behaviour may be compositor-dependent. For example, activating a
-        workspace may or may not deactivate all other workspaces in the same
-        group.
-      </description>
-    </request>
-
-    <request name="deactivate">
-      <description summary="activate the workspace">
-        Request that this workspace be deactivated.
-
-        There is no guarantee the workspace will be actually deactivated.
-      </description>
-    </request>
-
-    <request name="remove">
-      <description summary="remove the workspace">
-        Request that this workspace be removed.
-
-        There is no guarantee the workspace will be actually removed.
-      </description>
-    </request>
-  </interface>
-</protocol>

protocols/meson.build

@@ -25,11 +25,11 @@ protocols = [
   [wl_protocol_dir, 'unstable/xdg-output/xdg-output-unstable-v1.xml'],
   [wl_protocol_dir, 'staging/fractional-scale/fractional-scale-v1.xml'],
   [wl_protocol_dir, 'staging/cursor-shape/cursor-shape-v1.xml'],
+  [wl_protocol_dir, 'staging/tearing-control/tearing-control-v1.xml'],
   ['wlr-foreign-toplevel-management-unstable-v1.xml'],
   ['wlr-layer-shell-unstable-v1.xml'],
   ['wlr-output-power-management-unstable-v1.xml'],
   ['wlr-screencopy-unstable-v1.xml'],
-  ['ext-workspace-unstable-v1.xml'],
   ['pointer-constraints-unstable-v1.xml'],
   ['tablet-unstable-v2.xml'],
   ['idle.xml'],

scripts/generateVersion.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+cp -fr ./src/version.h.in ./src/version.h
+
+HASH=$(git rev-parse HEAD)
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+MESSAGE=$(git show ${GIT_COMMIT_HASH} | head -n 5 | tail -n 1 | sed -e 's/#//g' -e 's/\"//g')
+DIRTY=$(git diff-index --quiet HEAD -- || echo dirty)
+TAG=$(git describe --tags)
+
+sed -i -e "s#@HASH@#${HASH}#" ./src/version.h
+sed -i -e "s#@BRANCH@#${BRANCH}#" ./src/version.h
+sed -i -e "s#@MESSAGE@#${MESSAGE}#" ./src/version.h
+sed -i -e "s#@DIRTY@#${DIRTY}#" ./src/version.h
+sed -i -e "s#@TAG@#${TAG}#" ./src/version.h

src/Compositor.cpp

@@ -10,13 +10,12 @@
 #include <ranges>
 
 int handleCritSignal(int signo, void* data) {
-    Debug::log(LOG, "Hyprland received signal %d", signo);
+    Debug::log(LOG, "Hyprland received signal {}", signo);
 
-    if (signo == SIGTERM || signo == SIGINT || signo == SIGKILL) {
+    if (signo == SIGTERM || signo == SIGINT || signo == SIGKILL)
         g_pCompositor->cleanup();
-    }
 
-    return 0; // everything went fine
+    return 0;
 }
 
 void handleUnrecoverableSignal(int sig) {
@@ -35,6 +34,13 @@ void handleUnrecoverableSignal(int sig) {
     abort();
 }
 
+void handleUserSignal(int sig) {
+    if (sig == SIGUSR1) {
+        // means we have to unwind a timed out event
+        throw std::exception();
+    }
+}
+
 CCompositor::CCompositor() {
     m_iHyprlandPID = getpid();
 
@@ -54,9 +60,9 @@ CCompositor::CCompositor() {
 
     Debug::init(m_szInstanceSignature);
 
-    Debug::log(LOG, "Instance Signature: %s", m_szInstanceSignature.c_str());
+    Debug::log(LOG, "Instance Signature: {}", m_szInstanceSignature);
 
-    Debug::log(LOG, "Hyprland PID: %i", m_iHyprlandPID);
+    Debug::log(LOG, "Hyprland PID: {}", m_iHyprlandPID);
 
     Debug::log(LOG, "===== SYSTEM INFO: =====");
 
@@ -70,11 +76,30 @@ CCompositor::CCompositor() {
 
     setRandomSplash();
 
-    Debug::log(LOG, "\nCurrent splash: %s\n\n", m_szCurrentSplash.c_str());
+    Debug::log(LOG, "\nCurrent splash: {}\n\n", m_szCurrentSplash);
 }
 
 CCompositor::~CCompositor() {
     cleanup();
+    g_pPluginSystem.reset();
+    g_pHyprNotificationOverlay.reset();
+    g_pDebugOverlay.reset();
+    g_pEventManager.reset();
+    g_pSessionLockManager.reset();
+    g_pProtocolManager.reset();
+    g_pXWaylandManager.reset();
+    g_pHyprRenderer.reset();
+    g_pHyprOpenGL.reset();
+    g_pInputManager.reset();
+    g_pThreadManager.reset();
+    g_pConfigManager.reset();
+    g_pLayoutManager.reset();
+    g_pHyprError.reset();
+    g_pConfigManager.reset();
+    g_pAnimationManager.reset();
+    g_pKeybindManager.reset();
+    g_pHookSystem.reset();
+    g_pWatchdog.reset();
 }
 
 void CCompositor::setRandomSplash() {
@@ -95,34 +120,40 @@ void CCompositor::initServer() {
     wl_event_loop_add_signal(m_sWLEventLoop, SIGTERM, handleCritSignal, nullptr);
     signal(SIGSEGV, handleUnrecoverableSignal);
     signal(SIGABRT, handleUnrecoverableSignal);
+    signal(SIGUSR1, handleUserSignal);
     //wl_event_loop_add_signal(m_sWLEventLoop, SIGINT, handleCritSignal, nullptr);
 
     initManagers(STAGE_PRIORITY);
 
+    if (const auto ENV = getenv("HYPRLAND_TRACE"); ENV && std::string(ENV) == "1")
+        Debug::trace = true;
+
     wlr_log_init(WLR_INFO, NULL);
 
     const auto LOGWLR = getenv("HYPRLAND_LOG_WLR");
     if (LOGWLR && std::string(LOGWLR) == "1")
         wlr_log_init(WLR_DEBUG, Debug::wlrLog);
+    else
+        wlr_log_init(WLR_ERROR, Debug::wlrLog);
 
     m_sWLRBackend = wlr_backend_autocreate(m_sWLDisplay, &m_sWLRSession);
 
     if (!m_sWLRBackend) {
         Debug::log(CRIT, "m_sWLRBackend was NULL!");
-        throw std::runtime_error("wlr_backend_autocreate() failed!");
+        throwError("wlr_backend_autocreate() failed!");
     }
 
     m_iDRMFD = wlr_backend_get_drm_fd(m_sWLRBackend);
     if (m_iDRMFD < 0) {
         Debug::log(CRIT, "Couldn't query the DRM FD!");
-        throw std::runtime_error("wlr_backend_get_drm_fd() failed!");
+        throwError("wlr_backend_get_drm_fd() failed!");
     }
 
     m_sWLRRenderer = wlr_gles2_renderer_create_with_drm_fd(m_iDRMFD);
 
     if (!m_sWLRRenderer) {
         Debug::log(CRIT, "m_sWLRRenderer was NULL!");
-        throw std::runtime_error("wlr_gles2_renderer_create_with_drm_fd() failed!");
+        throwError("wlr_gles2_renderer_create_with_drm_fd() failed!");
     }
 
     wlr_renderer_init_wl_shm(m_sWLRRenderer, m_sWLDisplay);
@@ -138,14 +169,14 @@ void CCompositor::initServer() {
 
     if (!m_sWLRAllocator) {
         Debug::log(CRIT, "m_sWLRAllocator was NULL!");
-        throw std::runtime_error("wlr_allocator_autocreate() failed!");
+        throwError("wlr_allocator_autocreate() failed!");
     }
 
     m_sWLREGL = wlr_gles2_renderer_get_egl(m_sWLRRenderer);
 
     if (!m_sWLREGL) {
         Debug::log(CRIT, "m_sWLREGL was NULL!");
-        throw std::runtime_error("wlr_gles2_renderer_get_egl() failed!");
+        throwError("wlr_gles2_renderer_get_egl() failed!");
     }
 
     m_sWLRCompositor    = wlr_compositor_create(m_sWLDisplay, 6, m_sWLRRenderer);
@@ -163,9 +194,6 @@ void CCompositor::initServer() {
 
     m_sWLROutputPowerMgr = wlr_output_power_manager_v1_create(m_sWLDisplay);
 
-    m_sWLRScene = wlr_scene_create();
-    wlr_scene_attach_output_layout(m_sWLRScene, m_sWLROutputLayout);
-
     m_sWLRXDGShell = wlr_xdg_shell_create(m_sWLDisplay, 5);
 
     m_sWLRCursor = wlr_cursor_create();
@@ -178,7 +206,7 @@ void CCompositor::initServer() {
     int        cursorSize = 24;
     try {
         cursorSize = std::stoi(XCURSORENV);
-    } catch (std::exception& e) { Debug::log(ERR, "XCURSOR_SIZE invalid in check #2? (%s)", XCURSORENV); }
+    } catch (std::exception& e) { Debug::log(ERR, "XCURSOR_SIZE invalid in check #2? ({})", XCURSORENV); }
 
     m_sWLRXCursorMgr = wlr_xcursor_manager_create(nullptr, cursorSize);
     wlr_xcursor_manager_load(m_sWLRXCursorMgr, 1);
@@ -201,8 +229,6 @@ void CCompositor::initServer() {
     m_sWLRInhibitMgr     = wlr_input_inhibit_manager_create(m_sWLDisplay);
     m_sWLRKbShInhibitMgr = wlr_keyboard_shortcuts_inhibit_v1_create(m_sWLDisplay);
 
-    m_sWLREXTWorkspaceMgr = wlr_ext_workspace_manager_v1_create(m_sWLDisplay);
-
     m_sWLRPointerConstraints = wlr_pointer_constraints_v1_create(m_sWLDisplay);
 
     m_sWLRRelPointerMgr = wlr_relative_pointer_manager_v1_create(m_sWLDisplay);
@@ -242,9 +268,11 @@ void CCompositor::initServer() {
 
     m_sWLRCursorShapeMgr = wlr_cursor_shape_manager_v1_create(m_sWLDisplay, 1);
 
+    m_sWLRTearingControlMgr = wlr_tearing_control_manager_v1_create(m_sWLDisplay, 1);
+
     if (!m_sWLRHeadlessBackend) {
         Debug::log(CRIT, "Couldn't create the headless backend");
-        throw std::runtime_error("wlr_headless_backend_create() failed!");
+        throwError("wlr_headless_backend_create() failed!");
     }
 
     wlr_single_pixel_buffer_manager_v1_create(m_sWLDisplay);
@@ -300,6 +328,7 @@ void CCompositor::initAllSignals() {
     addWLSignal(&m_sWLRSessionLockMgr->events.new_lock, &Events::listen_newSessionLock, m_sWLRSessionLockMgr, "SessionLockMgr");
     addWLSignal(&m_sWLRGammaCtrlMgr->events.set_gamma, &Events::listen_setGamma, m_sWLRGammaCtrlMgr, "GammaCtrlMgr");
     addWLSignal(&m_sWLRCursorShapeMgr->events.request_set_shape, &Events::listen_setCursorShape, m_sWLRCursorShapeMgr, "CursorShapeMgr");
+    addWLSignal(&m_sWLRTearingControlMgr->events.new_object, &Events::listen_newTearingHint, m_sWLRTearingControlMgr, "TearingControlMgr");
 
     if (m_sWRLDRMLeaseMgr)
         addWLSignal(&m_sWRLDRMLeaseMgr->events.request, &Events::listen_leaseRequest, &m_sWRLDRMLeaseMgr, "DRM");
@@ -312,6 +341,8 @@ void CCompositor::cleanup() {
     if (!m_sWLDisplay || m_bIsShuttingDown)
         return;
 
+    removeLockFile();
+
     m_bIsShuttingDown = true;
 
 #ifdef USES_SYSTEMD
@@ -375,6 +406,7 @@ void CCompositor::initManagers(eManagersInitStage stage) {
             g_pLayoutManager = std::make_unique<CLayoutManager>();
 
             g_pConfigManager->init();
+            g_pWatchdog = std::make_unique<CWatchdog>(); // requires config
         } break;
         case STAGE_LATE: {
             Debug::log(LOG, "Creating the ThreadManager!");
@@ -416,6 +448,23 @@ void CCompositor::initManagers(eManagersInitStage stage) {
     }
 }
 
+void CCompositor::createLockFile() {
+    const auto    PATH = "/tmp/hypr/" + m_szInstanceSignature + ".lock";
+
+    std::ofstream ofs(PATH, std::ios::trunc);
+
+    ofs << m_iHyprlandPID << "\n" << m_szWLDisplaySocket << "\n";
+
+    ofs.close();
+}
+
+void CCompositor::removeLockFile() {
+    const auto PATH = "/tmp/hypr/" + m_szInstanceSignature + ".lock";
+
+    if (std::filesystem::exists(PATH))
+        std::filesystem::remove(PATH);
+}
+
 void CCompositor::startCompositor() {
     initAllSignals();
 
@@ -425,10 +474,10 @@ void CCompositor::startCompositor() {
         const auto RETVAL       = wl_display_add_socket(m_sWLDisplay, CANDIDATESTR.c_str());
         if (RETVAL >= 0) {
             m_szWLDisplaySocket = CANDIDATESTR;
-            Debug::log(LOG, "wl_display_add_socket for %s succeeded with %i", CANDIDATESTR.c_str(), RETVAL);
+            Debug::log(LOG, "wl_display_add_socket for {} succeeded with {}", CANDIDATESTR, RETVAL);
             break;
         } else {
-            Debug::log(WARN, "wl_display_add_socket for %s returned %i: skipping candidate %i", CANDIDATESTR.c_str(), RETVAL, candidate);
+            Debug::log(WARN, "wl_display_add_socket for {} returned {}: skipping candidate {}", CANDIDATESTR, RETVAL, candidate);
         }
     }
 
@@ -442,7 +491,7 @@ void CCompositor::startCompositor() {
     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 and wl_display_add_socket_auto failed)");
+        throwError("m_szWLDisplaySocket was null! (wl_display_add_socket and wl_display_add_socket_auto failed)");
     }
 
     setenv("WAYLAND_DISPLAY", m_szWLDisplaySocket.c_str(), 1);
@@ -458,16 +507,16 @@ void CCompositor::startCompositor() {
             "dbus-update-activation-environment --systemd WAYLAND_DISPLAY XDG_CURRENT_DESKTOP HYPRLAND_INSTANCE_SIGNATURE",
             nullptr);
 
-    Debug::log(LOG, "Running on WAYLAND_DISPLAY: %s", m_szWLDisplaySocket.c_str());
+    Debug::log(LOG, "Running on WAYLAND_DISPLAY: {}", m_szWLDisplaySocket);
 
     if (!wlr_backend_start(m_sWLRBackend)) {
         Debug::log(CRIT, "Backend did not start!");
         wlr_backend_destroy(m_sWLRBackend);
         wl_display_destroy(m_sWLDisplay);
-        throw std::runtime_error("The backend could not start!");
+        throwError("The backend could not start!");
     }
 
-    wlr_cursor_set_xcursor(m_sWLRCursor, m_sWLRXCursorMgr, "left_ptr");
+    g_pHyprRenderer->setCursorFromName("left_ptr");
 
 #ifdef USES_SYSTEMD
     if (sd_booted() > 0)
@@ -477,6 +526,8 @@ void CCompositor::startCompositor() {
         Debug::log(LOG, "systemd integration is baked in but system itself is not booted à la systemd!");
 #endif
 
+    createLockFile();
+
     // This blocks until we are done.
     Debug::log(LOG, "Hyprland is ready, running the event loop!");
     wl_display_run(m_sWLDisplay);
@@ -503,7 +554,7 @@ CMonitor* CCompositor::getMonitorFromName(const std::string& name) {
 
 CMonitor* CCompositor::getMonitorFromDesc(const std::string& desc) {
     for (auto& m : m_vMonitors) {
-        if (m->output->description && std::string(m->output->description).find(desc) == 0)
+        if (m->output->description && std::string(m->output->description).starts_with(desc))
             return m.get();
     }
     return nullptr;
@@ -794,6 +845,34 @@ wlr_surface* CCompositor::vectorWindowToSurface(const Vector2D& pos, CWindow* pW
     return PSURFACE->surface;
 }
 
+Vector2D CCompositor::vectorToSurfaceLocal(const Vector2D& vec, CWindow* pWindow, wlr_surface* pSurface) {
+    if (!windowValidMapped(pWindow))
+        return {};
+
+    if (pWindow->m_bIsX11)
+        return vec - pWindow->m_vRealPosition.goalv();
+
+    const auto                         PSURFACE = pWindow->m_uSurface.xdg;
+
+    std::tuple<wlr_surface*, int, int> iterData = {pSurface, -1337, -1337};
+
+    wlr_xdg_surface_for_each_surface(
+        PSURFACE,
+        [](wlr_surface* surf, int x, int y, void* data) {
+            const auto PDATA = (std::tuple<wlr_surface*, int, int>*)data;
+            if (surf == std::get<0>(*PDATA)) {
+                std::get<1>(*PDATA) = x;
+                std::get<2>(*PDATA) = y;
+            }
+        },
+        &iterData);
+
+    if (std::get<1>(iterData) == -1337 && std::get<2>(iterData) == -1337)
+        return vec - pWindow->m_vRealPosition.goalv();
+
+    return vec - pWindow->m_vRealPosition.goalv() - Vector2D{std::get<1>(iterData), std::get<2>(iterData)};
+}
+
 CMonitor* CCompositor::getMonitorFromOutput(wlr_output* out) {
     for (auto& m : m_vMonitors) {
         if (m->output == out) {
@@ -811,7 +890,13 @@ void CCompositor::focusWindow(CWindow* pWindow, wlr_surface* pSurface) {
         return;
     }
 
+    g_pLayoutManager->getCurrentLayout()->bringWindowToTop(pWindow);
+
     if (!pWindow || !windowValidMapped(pWindow)) {
+
+        if (!m_pLastWindow && !pWindow)
+            return;
+
         const auto PLASTWINDOW = m_pLastWindow;
         m_pLastWindow          = nullptr;
 
@@ -854,8 +939,9 @@ void CCompositor::focusWindow(CWindow* pWindow, wlr_surface* pSurface) {
         // This is to fix incorrect feedback on the focus history.
         const auto PWORKSPACE            = getWorkspaceByID(pWindow->m_iWorkspaceID);
         PWORKSPACE->m_pLastFocusedWindow = pWindow;
-        const auto PMONITOR              = getMonitorFromID(PWORKSPACE->m_iMonitorID);
-        PMONITOR->changeWorkspace(PWORKSPACE);
+        PWORKSPACE->rememberPrevWorkspace(getWorkspaceByID(m_pLastMonitor->activeWorkspace));
+        const auto PMONITOR = getMonitorFromID(PWORKSPACE->m_iMonitorID);
+        PMONITOR->changeWorkspace(PWORKSPACE, false, true);
         // changeworkspace already calls focusWindow
         return;
     }
@@ -884,25 +970,25 @@ void CCompositor::focusWindow(CWindow* pWindow, wlr_surface* pSurface) {
 
     updateWindowAnimatedDecorationValues(pWindow);
 
-    // Handle urgency hint on the workspace
-    if (pWindow->m_bIsUrgent) {
+    if (pWindow->m_bIsUrgent)
         pWindow->m_bIsUrgent = false;
-        if (!hasUrgentWindowOnWorkspace(pWindow->m_iWorkspaceID)) {
-            const auto PWORKSPACE = getWorkspaceByID(pWindow->m_iWorkspaceID);
-            if (PWORKSPACE->m_pWlrHandle) {
-                wlr_ext_workspace_handle_v1_set_urgent(PWORKSPACE->m_pWlrHandle, 0);
-            }
-        }
-    }
 
     // Send an event
     g_pEventManager->postEvent(SHyprIPCEvent{"activewindow", g_pXWaylandManager->getAppIDClass(pWindow) + "," + pWindow->m_szTitle});
-    g_pEventManager->postEvent(SHyprIPCEvent{"activewindowv2", getFormat("%lx", pWindow)});
+    g_pEventManager->postEvent(SHyprIPCEvent{"activewindowv2", std::format("{:x}", (uintptr_t)pWindow)});
 
     EMIT_HOOK_EVENT("activeWindow", pWindow);
 
     g_pLayoutManager->getCurrentLayout()->onWindowFocusChange(pWindow);
 
+    // TODO: implement this better
+    if (!PLASTWINDOW && pWindow->m_sGroupData.pNextWindow) {
+        for (auto curr = pWindow->m_sGroupData.pNextWindow; curr != pWindow; curr = curr->m_sGroupData.pNextWindow) {
+            if (curr->m_phForeignToplevel)
+                wlr_foreign_toplevel_handle_v1_set_activated(curr->m_phForeignToplevel, false);
+        }
+    }
+
     if (pWindow->m_phForeignToplevel)
         wlr_foreign_toplevel_handle_v1_set_activated(pWindow->m_phForeignToplevel, true);
 
@@ -918,7 +1004,7 @@ void CCompositor::focusWindow(CWindow* pWindow, wlr_surface* pSurface) {
     // move to front of the window history
     const auto HISTORYPIVOT = std::find_if(m_vWindowFocusHistory.begin(), m_vWindowFocusHistory.end(), [&](const auto& other) { return other == pWindow; });
     if (HISTORYPIVOT == m_vWindowFocusHistory.end()) {
-        Debug::log(ERR, "BUG THIS: Window %lx has no pivot in history", pWindow);
+        Debug::log(ERR, "BUG THIS: {} has no pivot in history", pWindow);
     } else {
         std::rotate(m_vWindowFocusHistory.begin(), HISTORYPIVOT, HISTORYPIVOT + 1);
     }
@@ -963,9 +1049,9 @@ void CCompositor::focusSurface(wlr_surface* pSurface, CWindow* pWindowOwner) {
     wl_signal_emit_mutable(&m_sSeat.seat->keyboard_state.events.focus_change, &event);
 
     if (pWindowOwner)
-        Debug::log(LOG, "Set keyboard focus to surface %lx, with window name: %s", pSurface, pWindowOwner->m_szTitle.c_str());
+        Debug::log(LOG, "Set keyboard focus to surface {:x}, with {}", (uintptr_t)pSurface, pWindowOwner);
     else
-        Debug::log(LOG, "Set keyboard focus to surface %lx", pSurface);
+        Debug::log(LOG, "Set keyboard focus to surface {:x}", (uintptr_t)pSurface);
 
     g_pXWaylandManager->activateSurface(pSurface, true);
     m_pLastFocus = pSurface;
@@ -1102,19 +1188,28 @@ void CCompositor::sanityCheckWorkspaces() {
     auto it = m_vWorkspaces.begin();
     while (it != m_vWorkspaces.end()) {
 
-        if ((*it)->m_bIndestructible)
-            continue;
-
-        const auto WINDOWSONWORKSPACE = getWindowsOnWorkspace((*it)->m_iID);
-
-        if ((*it)->m_bIsSpecialWorkspace && WINDOWSONWORKSPACE == 0) {
-            getMonitorFromID((*it)->m_iMonitorID)->setSpecialWorkspace(nullptr);
-
-            it = m_vWorkspaces.erase(it);
+        const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(it->get());
+        if (WORKSPACERULE.isPersistent) {
+            ++it;
             continue;
         }
 
+        const auto WINDOWSONWORKSPACE = getWindowsOnWorkspace((*it)->m_iID);
+
         if ((WINDOWSONWORKSPACE == 0 && !isWorkspaceVisible((*it)->m_iID))) {
+
+            if ((*it)->m_bIsSpecialWorkspace) {
+                if ((*it)->m_fAlpha.fl() > 0.f /* don't abruptly end the fadeout */) {
+                    ++it;
+                    continue;
+                }
+
+                const auto PMONITOR = getMonitorFromID((*it)->m_iMonitorID);
+
+                if (PMONITOR && PMONITOR->specialWorkspaceID == (*it)->m_iID)
+                    PMONITOR->setSpecialWorkspace(nullptr);
+            }
+
             it = m_vWorkspaces.erase(it);
             continue;
         }
@@ -1160,6 +1255,26 @@ CWindow* CCompositor::getFirstWindowOnWorkspace(const int& id) {
     return nullptr;
 }
 
+CWindow* CCompositor::getTopLeftWindowOnWorkspace(const int& id) {
+    const auto PWORKSPACE = getWorkspaceByID(id);
+
+    if (!PWORKSPACE)
+        return nullptr;
+
+    const auto PMONITOR = getMonitorFromID(PWORKSPACE->m_iMonitorID);
+
+    for (auto& w : m_vWindows) {
+        if (w->m_iWorkspaceID != id || !w->m_bIsMapped || w->isHidden())
+            continue;
+
+        const auto WINDOWIDEALBB = w->getWindowIdealBoundingBoxIgnoreReserved();
+
+        if (WINDOWIDEALBB.x <= PMONITOR->vecPosition.x + 1 && WINDOWIDEALBB.y <= PMONITOR->vecPosition.y + 1)
+            return w.get();
+    }
+    return nullptr;
+}
+
 bool CCompositor::doesSeatAcceptInput(wlr_surface* surface) {
     if (g_pSessionLockManager->isSessionLocked()) {
         if (g_pSessionLockManager->isSurfaceSessionLock(surface))
@@ -1193,15 +1308,24 @@ bool CCompositor::isWindowActive(CWindow* pWindow) {
     return PSURFACE == m_pLastFocus || pWindow == m_pLastWindow;
 }
 
-void CCompositor::moveWindowToTop(CWindow* pWindow) {
+void CCompositor::changeWindowZOrder(CWindow* pWindow, bool top) {
     if (!windowValidMapped(pWindow))
         return;
 
-    auto moveToTop = [&](CWindow* pw) -> void {
-        for (auto it = m_vWindows.begin(); it != m_vWindows.end(); ++it) {
-            if (it->get() == pw) {
-                std::rotate(it, it + 1, m_vWindows.end());
-                break;
+    auto moveToZ = [&](CWindow* pw, bool top) -> void {
+        if (top) {
+            for (auto it = m_vWindows.begin(); it != m_vWindows.end(); ++it) {
+                if (it->get() == pw) {
+                    std::rotate(it, it + 1, m_vWindows.end());
+                    break;
+                }
+            }
+        } else {
+            for (auto it = m_vWindows.rbegin(); it != m_vWindows.rend(); ++it) {
+                if (it->get() == pw) {
+                    std::rotate(it, it + 1, m_vWindows.rend());
+                    break;
+                }
             }
         }
 
@@ -1209,28 +1333,36 @@ void CCompositor::moveWindowToTop(CWindow* pWindow) {
             g_pHyprRenderer->damageMonitor(getMonitorFromID(pw->m_iMonitorID));
     };
 
-    moveToTop(pWindow);
+    if (top)
+        pWindow->m_bCreatedOverFullscreen = true;
 
-    pWindow->m_bCreatedOverFullscreen = true;
-
-    if (!pWindow->m_bIsX11)
+    if (!pWindow->m_bIsX11) {
+        moveToZ(pWindow, top);
         return;
+    } else {
+        // move X11 window stack
 
-    // move all children
+        std::deque<CWindow*> toMove;
 
-    std::deque<CWindow*> toMove;
+        auto                 x11Stack = [&](CWindow* pw, bool top, auto&& x11Stack) -> void {
+            if (top)
+                toMove.emplace_back(pw);
+            else
+                toMove.emplace_front(pw);
 
-    for (auto& w : m_vWindows) {
-        if (w->m_bIsMapped && w->m_bMappedX11 && !w->isHidden() && w->m_bIsX11 && w->X11TransientFor() == pWindow) {
-            toMove.emplace_back(w.get());
+            for (auto& w : m_vWindows) {
+                if (w->m_bIsMapped && w->m_bMappedX11 && !w->isHidden() && w->m_bIsX11 && w->X11TransientFor() == pw) {
+                    x11Stack(w.get(), top, x11Stack);
+                }
+            }
+        };
+
+        x11Stack(pWindow, top, x11Stack);
+
+        for (auto it : toMove) {
+            moveToZ(it, top);
         }
     }
-
-    for (auto& pw : toMove) {
-        moveToTop(pw);
-
-        moveWindowToTop(pw);
-    }
 }
 
 void CCompositor::cleanupFadingOut(const int& monid) {
@@ -1419,13 +1551,6 @@ CWindow* CCompositor::getWindowInDirection(CWindow* pWindow, char dir) {
     return nullptr;
 }
 
-void CCompositor::deactivateAllWLRWorkspaces(wlr_ext_workspace_handle_v1* exclude) {
-    for (auto& w : m_vWorkspaces) {
-        if (w->m_pWlrHandle && w->m_pWlrHandle != exclude)
-            w->setActive(false);
-    }
-}
-
 CWindow* CCompositor::getNextWindowOnWorkspace(CWindow* pWindow, bool focusableOnly) {
     bool gotToWindow = false;
     for (auto& w : m_vWindows) {
@@ -1492,7 +1617,7 @@ CWorkspace* CCompositor::getWorkspaceByName(const std::string& name) {
 }
 
 CWorkspace* CCompositor::getWorkspaceByString(const std::string& str) {
-    if (str.find("name:") == 0) {
+    if (str.starts_with("name:")) {
         return getWorkspaceByName(str.substr(str.find_first_of(':') + 1));
     }
 
@@ -1504,15 +1629,6 @@ CWorkspace* CCompositor::getWorkspaceByString(const std::string& str) {
     return nullptr;
 }
 
-CWorkspace* CCompositor::getWorkspaceByWorkspaceHandle(const wlr_ext_workspace_handle_v1* handle) {
-    for (auto& ws : m_vWorkspaces) {
-        if (ws->m_pWlrHandle == handle)
-            return ws.get();
-    }
-
-    return nullptr;
-}
-
 bool CCompositor::isPointOnAnyMonitor(const Vector2D& point) {
     for (auto& m : m_vMonitors) {
         if (VECINRECT(point, m->vecPosition.x, m->vecPosition.y, m->vecSize.x + m->vecPosition.x, m->vecSize.y + m->vecPosition.y))
@@ -1626,10 +1742,12 @@ void CCompositor::updateWindowAnimatedDecorationValues(CWindow* pWindow) {
     // optimization
     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 GROUPACTIVECOL         = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("general:col.group_border_active")->data.get();
-    static auto* const GROUPINACTIVECOL       = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("general:col.group_border")->data.get();
-    static auto* const GROUPACTIVELOCKEDCOL   = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("general:col.group_border_locked_active")->data.get();
-    static auto* const GROUPINACTIVELOCKEDCOL = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("general:col.group_border_locked")->data.get();
+    static auto* const NOGROUPACTIVECOL       = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("general:col.nogroup_border_active")->data.get();
+    static auto* const NOGROUPINACTIVECOL     = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("general:col.nogroup_border")->data.get();
+    static auto* const GROUPACTIVECOL         = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("group:col.border_active")->data.get();
+    static auto* const GROUPINACTIVECOL       = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("group:col.border_inactive")->data.get();
+    static auto* const GROUPACTIVELOCKEDCOL   = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("group:col.border_locked_active")->data.get();
+    static auto* const GROUPINACTIVELOCKEDCOL = (CGradientValueData*)g_pConfigManager->getConfigValuePtr("group:col.border_locked_inactive")->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;
@@ -1655,12 +1773,14 @@ void CCompositor::updateWindowAnimatedDecorationValues(CWindow* pWindow) {
     else {
         const bool GROUPLOCKED = pWindow->m_sGroupData.pNextWindow ? pWindow->getGroupHead()->m_sGroupData.locked : false;
         if (pWindow == m_pLastWindow) {
-            const auto* const ACTIVECOLOR = !pWindow->m_sGroupData.pNextWindow ? ACTIVECOL : (GROUPLOCKED ? GROUPACTIVELOCKEDCOL : GROUPACTIVECOL);
+            const auto* const ACTIVECOLOR =
+                !pWindow->m_sGroupData.pNextWindow ? (!pWindow->m_sGroupData.deny ? ACTIVECOL : NOGROUPACTIVECOL) : (GROUPLOCKED ? GROUPACTIVELOCKEDCOL : GROUPACTIVECOL);
             setBorderColor(pWindow->m_sSpecialRenderData.activeBorderColor.toUnderlying() >= 0 ?
                                CGradientValueData(CColor(pWindow->m_sSpecialRenderData.activeBorderColor.toUnderlying())) :
                                *ACTIVECOLOR);
         } else {
-            const auto* const INACTIVECOLOR = !pWindow->m_sGroupData.pNextWindow ? INACTIVECOL : (GROUPLOCKED ? GROUPINACTIVELOCKEDCOL : GROUPINACTIVECOL);
+            const auto* const INACTIVECOLOR =
+                !pWindow->m_sGroupData.pNextWindow ? (!pWindow->m_sGroupData.deny ? INACTIVECOL : NOGROUPINACTIVECOL) : (GROUPLOCKED ? GROUPINACTIVELOCKEDCOL : GROUPINACTIVECOL);
             setBorderColor(pWindow->m_sSpecialRenderData.inactiveBorderColor.toUnderlying() >= 0 ?
                                CGradientValueData(CColor(pWindow->m_sSpecialRenderData.inactiveBorderColor.toUnderlying())) :
                                *INACTIVECOLOR);
@@ -1856,14 +1976,14 @@ CMonitor* CCompositor::getMonitorFromString(const std::string& name) {
             Debug::log(ERR, "Error in getMonitorFromString: invalid arg 1");
             return nullptr;
         }
-    } else if (name.find("desc:") == 0) {
+    } else if (name.starts_with("desc:")) {
         const auto DESCRIPTION = name.substr(5);
 
         for (auto& m : m_vMonitors) {
             if (!m->output)
                 continue;
 
-            if (m->output->description && std::string(m->output->description).find(DESCRIPTION) == 0) {
+            if (m->output->description && std::string(m->output->description).starts_with(DESCRIPTION)) {
                 return m.get();
             }
         }
@@ -1895,7 +2015,7 @@ void CCompositor::moveWorkspaceToMonitor(CWorkspace* pWorkspace, CMonitor* pMoni
     if (pWorkspace->m_iMonitorID == pMonitor->ID)
         return;
 
-    Debug::log(LOG, "moveWorkspaceToMonitor: Moving %d to monitor %d", pWorkspace->m_iID, pMonitor->ID);
+    Debug::log(LOG, "moveWorkspaceToMonitor: Moving {} to monitor {}", pWorkspace->m_iID, pMonitor->ID);
 
     const auto POLDMON = getMonitorFromID(pWorkspace->m_iMonitorID);
 
@@ -1922,12 +2042,12 @@ void CCompositor::moveWorkspaceToMonitor(CWorkspace* pWorkspace, CMonitor* pMoni
             }())
                 nextWorkspaceOnMonitorID++;
 
-            Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with new %d", nextWorkspaceOnMonitorID);
+            Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with new {}", nextWorkspaceOnMonitorID);
 
             g_pCompositor->createNewWorkspace(nextWorkspaceOnMonitorID, POLDMON->ID);
         }
 
-        Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with existing %d", nextWorkspaceOnMonitorID);
+        Debug::log(LOG, "moveWorkspaceToMonitor: Plugging gap with existing {}", nextWorkspaceOnMonitorID);
         POLDMON->changeWorkspace(nextWorkspaceOnMonitorID);
     }
 
@@ -1964,7 +2084,7 @@ void CCompositor::moveWorkspaceToMonitor(CWorkspace* pWorkspace, CMonitor* pMoni
     }
 
     if (SWITCHINGISACTIVE && POLDMON == g_pCompositor->m_pLastMonitor) { // if it was active, preserve its' status. If it wasn't, don't.
-        Debug::log(LOG, "moveWorkspaceToMonitor: SWITCHINGISACTIVE, active %d -> %d", pMonitor->activeWorkspace, pWorkspace->m_iID);
+        Debug::log(LOG, "moveWorkspaceToMonitor: SWITCHINGISACTIVE, active {} -> {}", pMonitor->activeWorkspace, pWorkspace->m_iID);
 
         if (const auto PWORKSPACE = getWorkspaceByID(pMonitor->activeWorkspace); PWORKSPACE)
             getWorkspaceByID(pMonitor->activeWorkspace)->startAnim(false, false);
@@ -2029,9 +2149,11 @@ void CCompositor::updateFullscreenFadeOnWorkspace(CWorkspace* pWorkspace) {
 
     const auto PMONITOR = getMonitorFromID(pWorkspace->m_iMonitorID);
 
-    for (auto& ls : PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
-        if (!ls->fadingOut)
-            ls->alpha = FULLSCREEN && pWorkspace->m_efFullscreenMode == FULLSCREEN_FULL ? 0.f : 1.f;
+    if (pWorkspace->m_iID == PMONITOR->activeWorkspace) {
+        for (auto& ls : PMONITOR->m_aLayerSurfaceLayers[ZWLR_LAYER_SHELL_V1_LAYER_TOP]) {
+            if (!ls->fadingOut)
+                ls->alpha = FULLSCREEN && pWorkspace->m_efFullscreenMode == FULLSCREEN_FULL ? 0.f : 1.f;
+        }
     }
 }
 
@@ -2048,14 +2170,16 @@ void CCompositor::setWindowFullscreen(CWindow* pWindow, bool on, eFullscreenMode
 
     const auto PWORKSPACE = getWorkspaceByID(pWindow->m_iWorkspaceID);
 
+    const auto MODE = mode == FULLSCREEN_INVALID ? PWORKSPACE->m_efFullscreenMode : mode;
+
     if (PWORKSPACE->m_bHasFullscreenWindow && on) {
         Debug::log(LOG, "Rejecting fullscreen ON on a fullscreen workspace");
         return;
     }
 
-    g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(pWindow, mode, on);
+    g_pLayoutManager->getCurrentLayout()->fullscreenRequestForWindow(pWindow, MODE, on);
 
-    g_pXWaylandManager->setWindowFullscreen(pWindow, pWindow->m_bIsFullscreen && mode == FULLSCREEN_FULL);
+    g_pXWaylandManager->setWindowFullscreen(pWindow, pWindow->m_bIsFullscreen && MODE == FULLSCREEN_FULL);
 
     pWindow->updateDynamicRules();
     updateWindowAnimatedDecorationValues(pWindow);
@@ -2121,19 +2245,19 @@ CWindow* CCompositor::getWindowByRegex(const std::string& regexp) {
 
     std::regex       regexCheck(regexp);
     std::string      matchCheck;
-    if (regexp.find("title:") == 0) {
+    if (regexp.starts_with("title:")) {
         mode       = MODE_TITLE_REGEX;
         regexCheck = std::regex(regexp.substr(6));
-    } else if (regexp.find("address:") == 0) {
+    } else if (regexp.starts_with("address:")) {
         mode       = MODE_ADDRESS;
         matchCheck = regexp.substr(8);
-    } else if (regexp.find("pid:") == 0) {
+    } else if (regexp.starts_with("pid:")) {
         mode       = MODE_PID;
         matchCheck = regexp.substr(4);
     }
 
     for (auto& w : g_pCompositor->m_vWindows) {
-        if (!w->m_bIsMapped || (w->isHidden() && !w->m_sGroupData.pNextWindow))
+        if (!w->m_bIsMapped || (w->isHidden() && !g_pLayoutManager->getCurrentLayout()->isWindowReachable(w.get())))
             continue;
 
         switch (mode) {
@@ -2150,13 +2274,13 @@ CWindow* CCompositor::getWindowByRegex(const std::string& regexp) {
                 break;
             }
             case MODE_ADDRESS: {
-                std::string addr = getFormat("0x%lx", w.get());
+                std::string addr = std::format("0x{:x}", (uintptr_t)w.get());
                 if (matchCheck != addr)
                     continue;
                 break;
             }
             case MODE_PID: {
-                std::string pid = getFormat("%d", w->getPID());
+                std::string pid = std::format("{}", w->getPID());
                 if (matchCheck != pid)
                     continue;
                 break;
@@ -2244,22 +2368,29 @@ Vector2D CCompositor::parseWindowVectorArgsRelative(const std::string& args, con
     if (!args.contains(' '))
         return relativeTo;
 
+    const auto  PMONITOR = m_pLastMonitor;
+
+    bool        xIsPercent = false;
+    bool        yIsPercent = false;
+    bool        isExact    = false;
+
     std::string x = args.substr(0, args.find_first_of(' '));
     std::string y = args.substr(args.find_first_of(' ') + 1);
 
     if (x == "exact") {
-        std::string newX = y.substr(0, y.find_first_of(' '));
-        std::string newY = y.substr(y.find_first_of(' ') + 1);
+        x       = y.substr(0, y.find_first_of(' '));
+        y       = y.substr(y.find_first_of(' ') + 1);
+        isExact = true;
+    }
 
-        if (!isNumber(newX) || !isNumber(newY)) {
-            Debug::log(ERR, "parseWindowVectorArgsRelative: exact args not numbers");
-            return relativeTo;
-        }
+    if (x.contains('%')) {
+        xIsPercent = true;
+        x          = x.substr(0, x.length() - 1);
+    }
 
-        const int X = std::stoi(newX);
-        const int Y = std::stoi(newY);
-
-        return Vector2D(X, Y);
+    if (y.contains('%')) {
+        yIsPercent = true;
+        y          = y.substr(0, y.length() - 1);
     }
 
     if (!isNumber(x) || !isNumber(y)) {
@@ -2267,10 +2398,18 @@ Vector2D CCompositor::parseWindowVectorArgsRelative(const std::string& args, con
         return relativeTo;
     }
 
-    const int X = std::stoi(x);
-    const int Y = std::stoi(y);
+    int X = 0;
+    int Y = 0;
 
-    return Vector2D(X + relativeTo.x, Y + relativeTo.y);
+    if (isExact) {
+        X = xIsPercent ? std::stof(x) * 0.01 * PMONITOR->vecSize.x : std::stoi(x);
+        Y = yIsPercent ? std::stof(y) * 0.01 * PMONITOR->vecSize.y : std::stoi(y);
+    } else {
+        X = xIsPercent ? std::stof(x) * 0.01 * relativeTo.x + relativeTo.x : std::stoi(x) + relativeTo.x;
+        Y = yIsPercent ? std::stof(y) * 0.01 * relativeTo.y + relativeTo.y : std::stoi(y) + relativeTo.y;
+    }
+
+    return Vector2D(X, Y);
 }
 
 void CCompositor::forceReportSizesToWindowsOnWorkspace(const int& wid) {
@@ -2305,10 +2444,6 @@ CWorkspace* CCompositor::createNewWorkspace(const int& id, const int& monid, con
 
     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;
 
@@ -2324,9 +2459,10 @@ void CCompositor::renameWorkspace(const int& id, const std::string& name) {
     if (isWorkspaceSpecial(id))
         return;
 
-    Debug::log(LOG, "renameWorkspace: Renaming workspace %d to '%s'", id, name.c_str());
-    wlr_ext_workspace_handle_v1_set_name(PWORKSPACE->m_pWlrHandle, name.c_str());
+    Debug::log(LOG, "renameWorkspace: Renaming workspace {} to '{}'", id, name);
     PWORKSPACE->m_szName = name;
+
+    g_pEventManager->postEvent({"renameworkspace", std::to_string(PWORKSPACE->m_iID) + "," + PWORKSPACE->m_szName});
 }
 
 void CCompositor::setActiveMonitor(CMonitor* pMonitor) {
@@ -2361,21 +2497,12 @@ int CCompositor::getNewSpecialID() {
 }
 
 void CCompositor::performUserChecks() {
-    static constexpr auto BAD_PORTALS = {"kde", "gnome"};
-
-    static auto* const    PSUPPRESSPORTAL = &g_pConfigManager->getConfigValuePtr("misc:suppress_portal_warnings")->intValue;
-
-    if (!*PSUPPRESSPORTAL) {
-        if (std::ranges::any_of(BAD_PORTALS, [&](const std::string& portal) { return std::filesystem::exists("/usr/share/xdg-desktop-portal/portals/" + portal + ".portal"); })) {
-            // bad portal detected
-            g_pHyprNotificationOverlay->addNotification("You have one or more incompatible xdg-desktop-portal impls installed. Please remove incompatible ones to avoid issues.",
-                                                        CColor(0), 15000, ICON_ERROR);
-        }
-
-        if (std::filesystem::exists("/usr/share/xdg-desktop-portal/portals/hyprland.portal") && std::filesystem::exists("/usr/share/xdg-desktop-portal/portals/wlr.portal")) {
-            g_pHyprNotificationOverlay->addNotification("You have xdg-desktop-portal-hyprland and -wlr installed simultaneously. Please uninstall one to avoid issues.", CColor(0),
-                                                        15000, ICON_ERROR);
-        }
+    const auto atomicEnv    = getenv("WLR_DRM_NO_ATOMIC");
+    const auto atomicEnvStr = std::string(atomicEnv ? atomicEnv : "");
+    if (g_pConfigManager->getInt("general:allow_tearing") == 1 && atomicEnvStr != "1") {
+        g_pHyprNotificationOverlay->addNotification("You have enabled tearing, but immediate presentations are not available on your configuration. Try adding "
+                                                    "env = WLR_DRM_NO_ATOMIC,1 to your config.",
+                                                    CColor(0), 15000, ICON_WARNING);
     }
 }
 
@@ -2394,6 +2521,7 @@ void CCompositor::moveWindowToWorkspaceSafe(CWindow* pWindow, CWorkspace* pWorks
 
     pWindow->moveToWorkspace(pWorkspace->m_iID);
     pWindow->updateToplevel();
+    pWindow->updateDynamicRules();
 
     if (!pWindow->m_bIsFloating) {
         g_pLayoutManager->getCurrentLayout()->onWindowRemovedTiling(pWindow);
@@ -2448,3 +2576,101 @@ void CCompositor::setIdleActivityInhibit(bool enabled) {
     wlr_idle_set_enabled(g_pCompositor->m_sWLRIdle, g_pCompositor->m_sSeat.seat, enabled);
     wlr_idle_notifier_v1_set_inhibited(g_pCompositor->m_sWLRIdleNotifier, !enabled);
 }
+void CCompositor::arrangeMonitors() {
+    static auto* const     PXWLFORCESCALEZERO = &g_pConfigManager->getConfigValuePtr("xwayland:force_zero_scaling")->intValue;
+
+    std::vector<CMonitor*> toArrange;
+    std::vector<CMonitor*> arranged;
+
+    for (auto& m : m_vMonitors)
+        toArrange.push_back(m.get());
+
+    Debug::log(LOG, "arrangeMonitors: {} to arrange", toArrange.size());
+
+    for (auto it = toArrange.begin(); it != toArrange.end();) {
+        auto m = *it;
+
+        if (m->activeMonitorRule.offset != Vector2D{-INT32_MAX, -INT32_MAX}) {
+            // explicit.
+            Debug::log(LOG, "arrangeMonitors: {} explicit {:j2}", m->szName, m->activeMonitorRule.offset);
+
+            m->moveTo(m->activeMonitorRule.offset);
+            arranged.push_back(m);
+            it = toArrange.erase(it);
+
+            if (it == toArrange.end())
+                break;
+
+            continue;
+        }
+
+        ++it;
+    }
+
+    // auto left
+    int maxOffset = 0;
+    for (auto& m : arranged) {
+        if (m->vecPosition.x + m->vecSize.x > maxOffset)
+            maxOffset = m->vecPosition.x + m->vecSize.x;
+    }
+
+    for (auto& m : toArrange) {
+        Debug::log(LOG, "arrangeMonitors: {} auto [{}, {:.2f}]", m->szName, maxOffset, 0.f);
+        m->moveTo({maxOffset, 0});
+        maxOffset += m->vecSize.x;
+    }
+
+    // reset maxOffset (reuse)
+    // and set xwayland positions aka auto for all
+    maxOffset = 0;
+    for (auto& m : m_vMonitors) {
+        Debug::log(LOG, "arrangeMonitors: {} xwayland [{}, {:.2f}]", m->szName, maxOffset, 0.f);
+        m->vecXWaylandPosition = {maxOffset, 0};
+        maxOffset += (*PXWLFORCESCALEZERO ? m->vecTransformedSize.x : m->vecSize.x);
+
+        if (*PXWLFORCESCALEZERO)
+            m->xwaylandScale = m->scale;
+        else
+            m->xwaylandScale = 1.f;
+    }
+}
+
+void CCompositor::enterUnsafeState() {
+    if (m_bUnsafeState)
+        return;
+
+    Debug::log(LOG, "Entering unsafe state");
+
+    m_bUnsafeState = true;
+
+    // create a backup monitor
+    wlr_backend* headless = nullptr;
+    wlr_multi_for_each_backend(
+        m_sWLRBackend,
+        [](wlr_backend* b, void* data) {
+            if (wlr_backend_is_headless(b))
+                *((wlr_backend**)data) = b;
+        },
+        &headless);
+
+    if (!headless) {
+        Debug::log(WARN, "Entering an unsafe state without a headless backend");
+        return;
+    }
+
+    m_pUnsafeOutput = wlr_headless_add_output(headless, 1920, 1080);
+}
+
+void CCompositor::leaveUnsafeState() {
+    if (!m_bUnsafeState)
+        return;
+
+    Debug::log(LOG, "Leaving unsafe state");
+
+    m_bUnsafeState = false;
+
+    if (m_pUnsafeOutput)
+        wlr_output_destroy(m_pUnsafeOutput);
+
+    m_pUnsafeOutput = nullptr;
+}

src/Compositor.hpp

@@ -27,6 +27,7 @@
 #include "render/OpenGL.hpp"
 #include "hyprerror/HyprError.hpp"
 #include "plugins/PluginSystem.hpp"
+#include "helpers/Watchdog.hpp"
 
 enum eManagersInitStage
 {
@@ -62,12 +63,10 @@ class CCompositor {
     wlr_virtual_keyboard_manager_v1*           m_sWLRVKeyboardMgr;
     wlr_output_manager_v1*                     m_sWLROutputMgr;
     wlr_presentation*                          m_sWLRPresentation;
-    wlr_scene*                                 m_sWLRScene;
     wlr_input_inhibit_manager*                 m_sWLRInhibitMgr;
     wlr_keyboard_shortcuts_inhibit_manager_v1* m_sWLRKbShInhibitMgr;
     wlr_egl*                                   m_sWLREGL;
     int                                        m_iDRMFD;
-    wlr_ext_workspace_manager_v1*              m_sWLREXTWorkspaceMgr;
     wlr_pointer_constraints_v1*                m_sWLRPointerConstraints;
     wlr_relative_pointer_manager_v1*           m_sWLRRelPointerMgr;
     wlr_server_decoration_manager*             m_sWLRServerDecoMgr;
@@ -87,6 +86,7 @@ class CCompositor {
     wlr_session_lock_manager_v1*               m_sWLRSessionLockMgr;
     wlr_gamma_control_manager_v1*              m_sWLRGammaCtrlMgr;
     wlr_cursor_shape_manager_v1*               m_sWLRCursorShapeMgr;
+    wlr_tearing_control_manager_v1*            m_sWLRTearingControlMgr;
     // ------------------------------------------------- //
 
     std::string                               m_szWLDisplaySocket   = "";
@@ -107,6 +107,8 @@ class CCompositor {
     void                                      initServer();
     void                                      startCompositor();
     void                                      cleanup();
+    void                                      createLockFile();
+    void                                      removeLockFile();
 
     wlr_surface*                              m_pLastFocus   = nullptr;
     CWindow*                                  m_pLastWindow  = nullptr;
@@ -119,7 +121,8 @@ class CCompositor {
     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_bUnsafeState    = false;   // unsafe state is when there is no monitors.
+    wlr_output*                               m_pUnsafeOutput   = nullptr; // fallback output for the unsafe state
     bool                                      m_bIsShuttingDown = false;
 
     // ------------------------------------------------- //
@@ -139,6 +142,7 @@ class CCompositor {
     CWindow*       vectorToWindowTiled(const Vector2D&);
     wlr_surface*   vectorToLayerSurface(const Vector2D&, std::vector<std::unique_ptr<SLayerSurface>>*, Vector2D*, SLayerSurface**);
     wlr_surface*   vectorWindowToSurface(const Vector2D&, CWindow*, Vector2D& sl);
+    Vector2D       vectorToSurfaceLocal(const Vector2D&, CWindow*, wlr_surface*);
     CWindow*       windowFromCursor();
     CWindow*       windowFloatingFromCursor();
     CMonitor*      getMonitorFromOutput(wlr_output*);
@@ -150,20 +154,19 @@ class CCompositor {
     CWorkspace*    getWorkspaceByID(const int&);
     CWorkspace*    getWorkspaceByName(const std::string&);
     CWorkspace*    getWorkspaceByString(const std::string&);
-    CWorkspace*    getWorkspaceByWorkspaceHandle(const wlr_ext_workspace_handle_v1*);
     void           sanityCheckWorkspaces();
     void           updateWorkspaceWindowDecos(const int&);
     int            getWindowsOnWorkspace(const int&);
     CWindow*       getUrgentWindow();
     bool           hasUrgentWindowOnWorkspace(const int&);
     CWindow*       getFirstWindowOnWorkspace(const int&);
+    CWindow*       getTopLeftWindowOnWorkspace(const int&);
     CWindow*       getFullscreenWindowOnWorkspace(const int&);
     bool           doesSeatAcceptInput(wlr_surface*);
     bool           isWindowActive(CWindow*);
-    void           moveWindowToTop(CWindow*);
+    void           changeWindowZOrder(CWindow*, bool);
     void           cleanupFadingOut(const int& monid);
     CWindow*       getWindowInDirection(CWindow*, char);
-    void           deactivateAllWLRWorkspaces(wlr_ext_workspace_handle_v1* exclude = nullptr);
     CWindow*       getNextWindowOnWorkspace(CWindow*, bool focusableOnly = false);
     CWindow*       getPrevWindowOnWorkspace(CWindow*, bool focusableOnly = false);
     int            getNextAvailableNamedWorkspace();
@@ -201,6 +204,9 @@ class CCompositor {
     CWindow*       getForceFocus();
     void           notifyIdleActivity();
     void           setIdleActivityInhibit(bool inhibit);
+    void           arrangeMonitors();
+    void           enterUnsafeState();
+    void           leaveUnsafeState();
 
     std::string    explicitConfigPath;
 

src/Window.cpp

@@ -1,6 +1,7 @@
 #include "Window.hpp"
 #include "Compositor.hpp"
 #include "render/decorations/CHyprDropShadowDecoration.hpp"
+#include "render/decorations/CHyprGroupBarDecoration.hpp"
 
 CWindow::CWindow() {
     m_vRealPosition.create(AVARTYPE_VECTOR, g_pConfigManager->getAnimationPropertyConfig("windowsIn"), (void*)this, AVARDAMAGE_ENTIRE);
@@ -22,25 +23,19 @@ CWindow::~CWindow() {
     }
 }
 
-wlr_box CWindow::getFullWindowBoundingBox() {
-    static auto* const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+SWindowDecorationExtents CWindow::getFullWindowExtents() {
+    if (m_bFadingOut)
+        return m_eOriginalClosedExtents;
 
-    const auto         PWORKSPACE = g_pCompositor->getWorkspaceByID(m_iWorkspaceID);
-
-    const auto         WORKSPACERULE = PWORKSPACE ? g_pConfigManager->getWorkspaceRuleFor(PWORKSPACE) : SWorkspaceRule{};
-
-    auto borderSize = m_sSpecialRenderData.borderSize.toUnderlying() != -1 ? m_sSpecialRenderData.borderSize.toUnderlying() : WORKSPACERULE.borderSize.value_or(*PBORDERSIZE);
-    if (m_sAdditionalConfigData.borderSize.toUnderlying() != -1)
-        borderSize = m_sAdditionalConfigData.borderSize.toUnderlying();
-
-    borderSize *= m_sSpecialRenderData.border && !m_sAdditionalConfigData.forceNoBorder;
+    const int BORDERSIZE = getRealBorderSize();
 
     if (m_sAdditionalConfigData.dimAround) {
         const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
-        return {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
+        return {{m_vRealPosition.vec().x - PMONITOR->vecPosition.x, m_vRealPosition.vec().y - PMONITOR->vecPosition.y},
+                {PMONITOR->vecSize.x - (m_vRealPosition.vec().x - PMONITOR->vecPosition.x), PMONITOR->vecSize.y - (m_vRealPosition.vec().y - PMONITOR->vecPosition.y)}};
     }
 
-    SWindowDecorationExtents maxExtents = {{borderSize + 2, borderSize + 2}, {borderSize + 2, borderSize + 2}};
+    SWindowDecorationExtents maxExtents = {{BORDERSIZE + 2, BORDERSIZE + 2}, {BORDERSIZE + 2, BORDERSIZE + 2}};
 
     for (auto& wd : m_dWindowDecorations) {
 
@@ -90,7 +85,17 @@ wlr_box CWindow::getFullWindowBoundingBox() {
             maxExtents.bottomRight.y = surfaceExtents.y + surfaceExtents.height - m_pWLSurface.wlr()->current.height;
     }
 
-    // Add extents to the real base BB and return
+    return maxExtents;
+}
+
+wlr_box CWindow::getFullWindowBoundingBox() {
+    if (m_sAdditionalConfigData.dimAround) {
+        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        return {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
+    }
+
+    auto    maxExtents = getFullWindowExtents();
+
     wlr_box finalBox = {m_vRealPosition.vec().x - maxExtents.topLeft.x, m_vRealPosition.vec().y - maxExtents.topLeft.y,
                         m_vRealSize.vec().x + maxExtents.topLeft.x + maxExtents.bottomRight.x, m_vRealSize.vec().y + maxExtents.topLeft.y + maxExtents.bottomRight.y};
 
@@ -130,14 +135,14 @@ wlr_box CWindow::getWindowIdealBoundingBoxIgnoreReserved() {
 }
 
 wlr_box CWindow::getWindowInputBox() {
-    static auto* const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+    const int BORDERSIZE = getRealBorderSize();
 
     if (m_sAdditionalConfigData.dimAround) {
         const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
         return {PMONITOR->vecPosition.x, PMONITOR->vecPosition.y, PMONITOR->vecSize.x, PMONITOR->vecSize.y};
     }
 
-    SWindowDecorationExtents maxExtents = {{*PBORDERSIZE + 2, *PBORDERSIZE + 2}, {*PBORDERSIZE + 2, *PBORDERSIZE + 2}};
+    SWindowDecorationExtents maxExtents = {{BORDERSIZE + 2, BORDERSIZE + 2}, {BORDERSIZE + 2, BORDERSIZE + 2}};
 
     for (auto& wd : m_dWindowDecorations) {
 
@@ -333,8 +338,10 @@ void CWindow::moveToWorkspace(int workspaceID) {
 
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(m_iWorkspaceID);
 
+    updateSpecialRenderData();
+
     if (PWORKSPACE) {
-        g_pEventManager->postEvent(SHyprIPCEvent{"movewindow", getFormat("%lx,%s", this, PWORKSPACE->m_szName.c_str())});
+        g_pEventManager->postEvent(SHyprIPCEvent{"movewindow", std::format("{:x},{}", (uintptr_t)this, PWORKSPACE->m_szName)});
         EMIT_HOOK_EVENT("moveWindow", (std::vector<void*>{this, PWORKSPACE}));
     }
 
@@ -342,6 +349,9 @@ void CWindow::moveToWorkspace(int workspaceID) {
         m_pSwallowed->moveToWorkspace(workspaceID);
         m_pSwallowed->m_iMonitorID = m_iMonitorID;
     }
+
+    // update xwayland coords
+    g_pXWaylandManager->setWindowSize(this, m_vRealSize.vec());
 }
 
 CWindow* CWindow::X11TransientFor() {
@@ -377,6 +387,8 @@ void unregisterVar(void* ptr) {
 }
 
 void CWindow::onUnmap() {
+    static auto* const PCLOSEONLASTSPECIAL = &g_pConfigManager->getConfigValuePtr("misc:close_special_on_empty")->intValue;
+
     if (g_pCompositor->m_pLastWindow == this)
         g_pCompositor->m_pLastWindow = nullptr;
 
@@ -396,6 +408,17 @@ void CWindow::onUnmap() {
     m_pWLSurface.unassign();
 
     hyprListener_unmapWindow.removeCallback();
+
+    if (*PCLOSEONLASTSPECIAL && g_pCompositor->getWindowsOnWorkspace(m_iWorkspaceID) == 0 && g_pCompositor->isWorkspaceSpecial(m_iWorkspaceID)) {
+        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        if (PMONITOR && PMONITOR->specialWorkspaceID == m_iWorkspaceID)
+            PMONITOR->setSpecialWorkspace(nullptr);
+    }
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+
+    if (PMONITOR && PMONITOR->solitaryClient == this)
+        PMONITOR->solitaryClient = nullptr;
 }
 
 void CWindow::onMap() {
@@ -474,15 +497,17 @@ void CWindow::applyDynamicRule(const SWindowRule& r) {
     } else if (r.szRule == "opaque") {
         if (!m_sAdditionalConfigData.forceOpaqueOverridden)
             m_sAdditionalConfigData.forceOpaque = true;
-    } else if (r.szRule.find("rounding") == 0) {
+    } else if (r.szRule == "immediate") {
+        m_sAdditionalConfigData.forceTearing = true;
+    } else if (r.szRule.starts_with("rounding")) {
         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("bordersize") == 0) {
+        } catch (std::exception& e) { Debug::log(ERR, "Rounding rule \"{}\" failed with: {}", r.szRule, e.what()); }
+    } else if (r.szRule.starts_with("bordersize")) {
         try {
             m_sAdditionalConfigData.borderSize = std::stoi(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
-        } catch (std::exception& e) { Debug::log(ERR, "Bordersize rule \"%s\" failed with: %s", r.szRule.c_str(), e.what()); }
-    } else if (r.szRule.find("opacity") == 0) {
+        } catch (std::exception& e) { Debug::log(ERR, "Bordersize rule \"{}\" failed with: {}", r.szRule, e.what()); }
+    } else if (r.szRule.starts_with("opacity")) {
         try {
             CVarList vars(r.szRule, 0, ' ');
 
@@ -512,13 +537,13 @@ void CWindow::applyDynamicRule(const SWindowRule& r) {
                     opacityIDX++;
                 }
             }
-        } catch (std::exception& e) { Debug::log(ERR, "Opacity rule \"%s\" failed with: %s", r.szRule.c_str(), e.what()); }
+        } catch (std::exception& e) { Debug::log(ERR, "Opacity rule \"{}\" failed with: {}", r.szRule, e.what()); }
     } else if (r.szRule == "noanim") {
         m_sAdditionalConfigData.forceNoAnims = true;
-    } else if (r.szRule.find("animation") == 0) {
+    } else if (r.szRule.starts_with("animation")) {
         auto STYLE                             = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
         m_sAdditionalConfigData.animationStyle = STYLE;
-    } else if (r.szRule.find("bordercolor") == 0) {
+    } else if (r.szRule.starts_with("bordercolor")) {
         try {
             std::string colorPart = removeBeginEndSpacesTabs(r.szRule.substr(r.szRule.find_first_of(' ') + 1));
 
@@ -529,9 +554,17 @@ void CWindow::applyDynamicRule(const SWindowRule& r) {
             } 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()); }
+        } catch (std::exception& e) { Debug::log(ERR, "BorderColor rule \"{}\" failed with: {}", r.szRule, e.what()); }
     } else if (r.szRule == "dimaround") {
         m_sAdditionalConfigData.dimAround = true;
+    } else if (r.szRule == "keepaspectratio") {
+        m_sAdditionalConfigData.keepAspectRatio = true;
+    } else if (r.szRule.starts_with("xray")) {
+        CVarList vars(r.szRule, 0, ' ');
+
+        try {
+            m_sAdditionalConfigData.xray = configStringToInt(vars[1]);
+        } catch (...) {}
     }
 }
 
@@ -546,12 +579,15 @@ void CWindow::updateDynamicRules() {
     m_sAdditionalConfigData.forceNoDim       = false;
     if (!m_sAdditionalConfigData.forceOpaqueOverridden)
         m_sAdditionalConfigData.forceOpaque = false;
-    m_sAdditionalConfigData.forceNoAnims   = false;
-    m_sAdditionalConfigData.animationStyle = std::string("");
-    m_sAdditionalConfigData.rounding       = -1;
-    m_sAdditionalConfigData.dimAround      = false;
-    m_sAdditionalConfigData.forceRGBX      = false;
-    m_sAdditionalConfigData.borderSize     = -1;
+    m_sAdditionalConfigData.forceNoAnims    = false;
+    m_sAdditionalConfigData.animationStyle  = std::string("");
+    m_sAdditionalConfigData.rounding        = -1;
+    m_sAdditionalConfigData.dimAround       = false;
+    m_sAdditionalConfigData.forceRGBX       = false;
+    m_sAdditionalConfigData.borderSize      = -1;
+    m_sAdditionalConfigData.keepAspectRatio = false;
+    m_sAdditionalConfigData.xray            = -1;
+    m_sAdditionalConfigData.forceTearing    = false;
 
     const auto WINDOWRULES = g_pConfigManager->getMatchingRules(this);
     for (auto& r : WINDOWRULES) {
@@ -565,29 +601,27 @@ void CWindow::updateDynamicRules() {
 // it is assumed that the point is within the real window box (m_vRealPosition, m_vRealSize)
 // otherwise behaviour is undefined
 bool CWindow::isInCurvedCorner(double x, double y) {
-    static auto* const ROUNDING   = &g_pConfigManager->getConfigValuePtr("decoration:rounding")->intValue;
-    static auto* const BORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
-
-    if (BORDERSIZE >= ROUNDING || ROUNDING == 0)
+    const int ROUNDING = rounding();
+    if (getRealBorderSize() >= ROUNDING)
         return false;
 
     // (x0, y0), (x0, y1), ... are the center point of rounding at each corner
-    double x0 = m_vRealPosition.vec().x + *ROUNDING;
-    double y0 = m_vRealPosition.vec().y + *ROUNDING;
-    double x1 = m_vRealPosition.vec().x + m_vRealSize.vec().x - *ROUNDING;
-    double y1 = m_vRealPosition.vec().y + m_vRealSize.vec().y - *ROUNDING;
+    double x0 = m_vRealPosition.vec().x + ROUNDING;
+    double y0 = m_vRealPosition.vec().y + ROUNDING;
+    double x1 = m_vRealPosition.vec().x + m_vRealSize.vec().x - ROUNDING;
+    double y1 = m_vRealPosition.vec().y + m_vRealSize.vec().y - ROUNDING;
 
     if (x < x0 && y < y0) {
-        return Vector2D{x0, y0}.distance(Vector2D{x, y}) > (double)*ROUNDING;
+        return Vector2D{x0, y0}.distance(Vector2D{x, y}) > (double)ROUNDING;
     }
     if (x > x1 && y < y0) {
-        return Vector2D{x1, y0}.distance(Vector2D{x, y}) > (double)*ROUNDING;
+        return Vector2D{x1, y0}.distance(Vector2D{x, y}) > (double)ROUNDING;
     }
     if (x < x0 && y > y1) {
-        return Vector2D{x0, y1}.distance(Vector2D{x, y}) > (double)*ROUNDING;
+        return Vector2D{x0, y1}.distance(Vector2D{x, y}) > (double)ROUNDING;
     }
     if (x > x1 && y > y1) {
-        return Vector2D{x1, y1}.distance(Vector2D{x, y}) > (double)*ROUNDING;
+        return Vector2D{x1, y1}.distance(Vector2D{x, y}) > (double)ROUNDING;
     }
 
     return false;
@@ -615,6 +649,69 @@ bool CWindow::hasPopupAt(const Vector2D& pos) {
     return resultSurf;
 }
 
+void CWindow::applyGroupRules() {
+    if ((m_eGroupRules & GROUP_SET && m_bFirstMap) || m_eGroupRules & GROUP_SET_ALWAYS)
+        createGroup();
+
+    if (m_sGroupData.pNextWindow && ((m_eGroupRules & GROUP_LOCK && m_bFirstMap) || m_eGroupRules & GROUP_LOCK_ALWAYS))
+        getGroupHead()->m_sGroupData.locked = true;
+}
+
+void CWindow::createGroup() {
+    if (m_sGroupData.deny) {
+        Debug::log(LOG, "createGroup: window:{:x},title:{} is denied as a group, ignored", (uintptr_t)this, this->m_szTitle);
+        return;
+    }
+    if (!m_sGroupData.pNextWindow) {
+        m_sGroupData.pNextWindow = this;
+        m_sGroupData.head        = true;
+        m_sGroupData.locked      = false;
+        m_sGroupData.deny        = false;
+
+        m_dWindowDecorations.emplace_back(std::make_unique<CHyprGroupBarDecoration>(this));
+        updateWindowDecos();
+
+        g_pLayoutManager->getCurrentLayout()->recalculateWindow(this);
+        g_pCompositor->updateAllWindowsAnimatedDecorationValues();
+    }
+}
+
+void CWindow::destroyGroup() {
+    if (m_sGroupData.pNextWindow == this) {
+        if (m_eGroupRules & GROUP_SET_ALWAYS) {
+            Debug::log(LOG, "destoryGroup: window:{:x},title:{} has rule [group set always], ignored", (uintptr_t)this, this->m_szTitle);
+            return;
+        }
+        m_sGroupData.pNextWindow = nullptr;
+        updateWindowDecos();
+        return;
+    }
+
+    CWindow*              curr = this;
+    std::vector<CWindow*> members;
+    do {
+        const auto PLASTWIN                = curr;
+        curr                               = curr->m_sGroupData.pNextWindow;
+        PLASTWIN->m_sGroupData.pNextWindow = nullptr;
+        curr->setHidden(false);
+        members.push_back(curr);
+    } while (curr != this);
+
+    for (auto& w : members) {
+        if (w->m_sGroupData.head)
+            g_pLayoutManager->getCurrentLayout()->onWindowRemoved(curr);
+        w->m_sGroupData.head = false;
+    }
+
+    const bool GROUPSLOCKEDPREV        = g_pKeybindManager->m_bGroupsLocked;
+    g_pKeybindManager->m_bGroupsLocked = true;
+    for (auto& w : members) {
+        g_pLayoutManager->getCurrentLayout()->onWindowCreated(w);
+        w->updateWindowDecos();
+    }
+    g_pKeybindManager->m_bGroupsLocked = GROUPSLOCKEDPREV;
+}
+
 CWindow* CWindow::getGroupHead() {
     CWindow* curr = this;
     while (!curr->m_sGroupData.head)
@@ -636,6 +733,27 @@ CWindow* CWindow::getGroupCurrent() {
     return curr;
 }
 
+int CWindow::getGroupSize() {
+    int      size = 1;
+    CWindow* curr = this;
+    while (curr->m_sGroupData.pNextWindow != this) {
+        curr = curr->m_sGroupData.pNextWindow;
+        size++;
+    }
+    return size;
+}
+
+CWindow* CWindow::getGroupWindowByIndex(int index) {
+    const int SIZE = getGroupSize();
+    index          = ((index % SIZE) + SIZE) % SIZE;
+    CWindow* curr  = getGroupHead();
+    while (index > 0) {
+        curr = curr->m_sGroupData.pNextWindow;
+        index--;
+    }
+    return curr;
+}
+
 void CWindow::setGroupCurrent(CWindow* pWindow) {
     CWindow* curr     = this->m_sGroupData.pNextWindow;
     bool     isMember = false;
@@ -663,7 +781,7 @@ void CWindow::setGroupCurrent(CWindow* pWindow) {
         g_pCompositor->setWindowFullscreen(PCURRENT, false, WORKSPACE->m_efFullscreenMode);
 
     PCURRENT->setHidden(true);
-    pWindow->setHidden(false);
+    pWindow->setHidden(false); // can remove m_pLastWindow
 
     g_pLayoutManager->getCurrentLayout()->replaceWindowDataWith(PCURRENT, pWindow);
 
@@ -684,10 +802,11 @@ void CWindow::setGroupCurrent(CWindow* pWindow) {
 }
 
 void CWindow::insertWindowToGroup(CWindow* pWindow) {
-    static const auto* USECURRPOS = &g_pConfigManager->getConfigValuePtr("misc:group_insert_after_current")->intValue;
+    const auto BEGINAT = this;
+    const auto ENDAT   = m_sGroupData.pNextWindow;
 
-    const auto         BEGINAT = *USECURRPOS ? this : getGroupTail();
-    const auto         ENDAT   = *USECURRPOS ? m_sGroupData.pNextWindow : getGroupHead();
+    if (!pWindow->getDecorationByType(DECORATION_GROUPBAR))
+        pWindow->m_dWindowDecorations.emplace_back(std::make_unique<CHyprGroupBarDecoration>(pWindow));
 
     if (!pWindow->m_sGroupData.pNextWindow) {
         BEGINAT->m_sGroupData.pNextWindow = pWindow;
@@ -786,3 +905,35 @@ float CWindow::rounding() {
 
     return rounding;
 }
+
+void CWindow::updateSpecialRenderData() {
+    const auto PWORKSPACE    = g_pCompositor->getWorkspaceByID(m_iWorkspaceID);
+    const auto WORKSPACERULE = PWORKSPACE ? g_pConfigManager->getWorkspaceRuleFor(PWORKSPACE) : SWorkspaceRule{};
+    bool       border        = true;
+
+    if (m_bIsFloating && g_pConfigManager->getConfigValuePtr("general:no_border_on_floating")->intValue == 1)
+        border = false;
+
+    m_sSpecialRenderData.border     = WORKSPACERULE.border.value_or(border);
+    m_sSpecialRenderData.borderSize = WORKSPACERULE.borderSize.value_or(-1);
+    m_sSpecialRenderData.decorate   = WORKSPACERULE.decorate.value_or(true);
+    m_sSpecialRenderData.rounding   = WORKSPACERULE.rounding.value_or(true);
+    m_sSpecialRenderData.shadow     = WORKSPACERULE.shadow.value_or(true);
+}
+
+int CWindow::getRealBorderSize() {
+    if (!m_sSpecialRenderData.border || m_sAdditionalConfigData.forceNoBorder)
+        return 0;
+
+    if (m_sAdditionalConfigData.borderSize.toUnderlying() != -1)
+        return m_sAdditionalConfigData.borderSize.toUnderlying();
+
+    if (m_sSpecialRenderData.borderSize.toUnderlying() != -1)
+        return m_sSpecialRenderData.borderSize.toUnderlying();
+
+    return g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+}
+
+bool CWindow::canBeTorn() {
+    return (m_sAdditionalConfigData.forceTearing.toUnderlying() || m_bTearingHint) && g_pHyprRenderer->m_bTearingEnvSatisfied;
+}

src/Window.hpp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "defines.hpp"
-#include "events/Events.hpp"
 #include "helpers/SubsurfaceTree.hpp"
 #include "helpers/AnimatedVariable.hpp"
 #include "render/decorations/IHyprWindowDecoration.hpp"
@@ -9,6 +8,8 @@
 #include "config/ConfigDataValues.hpp"
 #include "helpers/Vector2D.hpp"
 #include "helpers/WLSurface.hpp"
+#include "macros.hpp"
+#include "managers/XWaylandManager.hpp"
 
 enum eIdleInhibitMode
 {
@@ -18,6 +19,19 @@ enum eIdleInhibitMode
     IDLEINHIBIT_FOCUS
 };
 
+enum eGroupRules
+{
+    // effective only during first map, except for _ALWAYS variant
+    GROUP_NONE        = 0,
+    GROUP_SET         = 1 << 0, // Open as new group or add to focused group
+    GROUP_SET_ALWAYS  = 1 << 1,
+    GROUP_BARRED      = 1 << 2, // Don't insert to focused group.
+    GROUP_LOCK        = 1 << 3, // Lock m_sGroupData.lock
+    GROUP_LOCK_ALWAYS = 1 << 4,
+    GROUP_INVADE      = 1 << 5, // Force enter a group, event if lock is engaged
+    GROUP_OVERRIDE    = 1 << 6, // Override other rules
+};
+
 template <typename T>
 class CWindowOverridableVar {
   public:
@@ -105,6 +119,7 @@ struct SWindowSpecialRenderData {
     bool                       rounding   = true;
     bool                       border     = true;
     bool                       decorate   = true;
+    bool                       shadow     = true;
 };
 
 struct SWindowAdditionalConfigData {
@@ -122,7 +137,10 @@ struct SWindowAdditionalConfigData {
     CWindowOverridableVar<bool> noMaxSize             = false;
     CWindowOverridableVar<bool> dimAround             = false;
     CWindowOverridableVar<bool> forceRGBX             = false;
+    CWindowOverridableVar<bool> keepAspectRatio       = false;
+    CWindowOverridableVar<int>  xray                  = -1; // -1 means unset, takes precedence over the renderdata one
     CWindowOverridableVar<int>  borderSize            = -1; // -1 means unset, takes precedence over the renderdata one
+    CWindowOverridableVar<bool> forceTearing          = false;
 };
 
 struct SWindowRule {
@@ -241,11 +259,12 @@ class CWindow {
     CAnimatedVariable  m_fBorderAngleAnimationProgress;
 
     // Fade in-out
-    CAnimatedVariable m_fAlpha;
-    bool              m_bFadingOut     = false;
-    bool              m_bReadyToDelete = false;
-    Vector2D          m_vOriginalClosedPos;  // these will be used for calculations later on in
-    Vector2D          m_vOriginalClosedSize; // drawing the closing animations
+    CAnimatedVariable        m_fAlpha;
+    bool                     m_bFadingOut     = false;
+    bool                     m_bReadyToDelete = false;
+    Vector2D                 m_vOriginalClosedPos;  // these will be used for calculations later on in
+    Vector2D                 m_vOriginalClosedSize; // drawing the closing animations
+    SWindowDecorationExtents m_eOriginalClosedExtents;
 
     // For pinned (sticky) windows
     bool m_bPinned = false;
@@ -296,8 +315,12 @@ class CWindow {
     struct SGroupData {
         CWindow* pNextWindow = nullptr; // nullptr means no grouping. Self means single group.
         bool     head        = false;
-        bool     locked      = false;
+        bool     locked      = false; // per group lock
+        bool     deny        = false; // deny window from enter a group or made a group
     } m_sGroupData;
+    uint16_t m_eGroupRules = GROUP_NONE;
+
+    bool     m_bTearingHint = false;
 
     // For the list lookup
     bool operator==(const CWindow& rhs) {
@@ -307,6 +330,7 @@ class CWindow {
 
     // methods
     wlr_box                  getFullWindowBoundingBox();
+    SWindowDecorationExtents getFullWindowExtents();
     wlr_box                  getWindowInputBox();
     wlr_box                  getWindowIdealBoundingBoxIgnoreReserved();
     void                     updateWindowDecos();
@@ -329,15 +353,24 @@ class CWindow {
     Vector2D                 middle();
     bool                     opaque();
     float                    rounding();
+    bool                     canBeTorn();
+
+    int                      getRealBorderSize();
+    void                     updateSpecialRenderData();
 
     void                     onBorderAngleAnimEnd(void* ptr);
     bool                     isInCurvedCorner(double x, double y);
     bool                     hasPopupAt(const Vector2D& pos);
 
+    void                     applyGroupRules();
+    void                     createGroup();
+    void                     destroyGroup();
     CWindow*                 getGroupHead();
     CWindow*                 getGroupTail();
     CWindow*                 getGroupCurrent();
     CWindow*                 getGroupPrevious();
+    CWindow*                 getGroupWindowByIndex(int);
+    int                      getGroupSize();
     void                     setGroupCurrent(CWindow* pWindow);
     void                     insertWindowToGroup(CWindow* pWindow);
     void                     updateGroupOutputs();
@@ -347,3 +380,44 @@ class CWindow {
     // For hidden windows and stuff
     bool m_bHidden = false;
 };
+
+/**
+    format specification
+    - 'x', only address, equivalent of (uintpr_t)CWindow*
+    - 'm', with monitor id
+    - 'w', with workspace id
+    - 'c', with application class
+*/
+
+template <typename CharT>
+struct std::formatter<CWindow*, CharT> : std::formatter<CharT> {
+    bool formatAddressOnly = false;
+    bool formatWorkspace   = false;
+    bool formatMonitor     = false;
+    bool formatClass       = false;
+    FORMAT_PARSE(                           //
+        FORMAT_FLAG('x', formatAddressOnly) //
+        FORMAT_FLAG('m', formatMonitor)     //
+        FORMAT_FLAG('w', formatWorkspace)   //
+        FORMAT_FLAG('c', formatClass),
+        CWindow*)
+
+    template <typename FormatContext>
+    auto format(CWindow* const& w, FormatContext& ctx) const {
+        auto&& out = ctx.out();
+        if (formatAddressOnly)
+            return std::format_to(out, "{:x}", (uintptr_t)w);
+        if (!w)
+            return std::format_to(out, "[Window nullptr]");
+
+        std::format_to(out, "[");
+        std::format_to(out, "Window {:x}: title: \"{}\"", (uintptr_t)w, w->m_szTitle);
+        if (formatWorkspace)
+            std::format_to(out, ", workspace: {}", w->m_iWorkspaceID);
+        if (formatMonitor)
+            std::format_to(out, ", monitor: {}", w->m_iMonitorID);
+        if (formatClass)
+            std::format_to(out, ", class: {}", g_pXWaylandManager->getAppIDClass(w));
+        return std::format_to(out, "]");
+    }
+};

src/config/ConfigDataValues.hpp

@@ -7,7 +7,7 @@ enum eConfigValueDataTypes {
     CVD_TYPE_GRADIENT = 0
 };
 
-interface ICustomConfigValueData {
+class ICustomConfigValueData {
   public:
     virtual ~ICustomConfigValueData() = 0;
 

src/config/ConfigManager.hpp

@@ -14,12 +14,12 @@
 #include <xf86drmMode.h>
 #include "../Window.hpp"
 #include "../helpers/WLClasses.hpp"
+#include "../helpers/Monitor.hpp"
+#include "../helpers/VarList.hpp"
 
 #include "defaultConfig.hpp"
 #include "ConfigDataValues.hpp"
 
-#define STRVAL_EMPTY "[[EMPTY]]"
-
 #define INITANIMCFG(name)           animationConfig[name] = {}
 #define CREATEANIMCFG(name, parent) animationConfig[name] = {false, "", "", 0.f, -1, &animationConfig["global"], &animationConfig[parent]}
 
@@ -35,31 +35,20 @@ struct SConfigValue {
     bool                                    set = false; // used for device configs
 };
 
-struct SMonitorRule {
-    std::string         name        = "";
-    Vector2D            resolution  = Vector2D(1280, 720);
-    Vector2D            offset      = Vector2D(0, 0);
-    float               scale       = 1;
-    float               refreshRate = 60;
-    bool                disabled    = false;
-    wl_output_transform transform   = WL_OUTPUT_TRANSFORM_NORMAL;
-    std::string         mirrorOf    = "";
-    bool                enable10bit = false;
-    drmModeModeInfo     drmMode     = {};
-};
-
 struct SWorkspaceRule {
     std::string            monitor         = "";
     std::string            workspaceString = "";
     std::string            workspaceName   = "";
     int                    workspaceId     = -1;
     bool                   isDefault       = false;
+    bool                   isPersistent    = false;
     std::optional<int64_t> gapsIn;
     std::optional<int64_t> gapsOut;
     std::optional<int64_t> borderSize;
     std::optional<int>     border;
     std::optional<int>     rounding;
     std::optional<int>     decorate;
+    std::optional<int>     shadow;
 };
 
 struct SMonitorAdditionalReservedArea {
@@ -86,73 +75,6 @@ struct SExecRequestedRule {
     uint64_t    iPid   = 0;
 };
 
-class CVarList {
-  public:
-    /* passing 's' as a separator will use std::isspace */
-    CVarList(const std::string& in, long unsigned int lastArgNo = 0, const char separator = ',') {
-        std::string curitem  = "";
-        std::string argZ     = in;
-        const bool  SPACESEP = separator == 's';
-
-        auto        nextItem = [&]() {
-            auto idx = lastArgNo != 0 && m_vArgs.size() >= lastArgNo - 1 ? std::string::npos : ([&]() -> size_t {
-                if (!SPACESEP)
-                    return argZ.find_first_of(separator);
-
-                uint64_t pos = -1;
-                while (!std::isspace(argZ[++pos]) && pos < argZ.length())
-                    ;
-
-                return pos < argZ.length() ? pos : std::string::npos;
-            }());
-
-            if (idx != std::string::npos) {
-                curitem = argZ.substr(0, idx);
-                argZ    = argZ.substr(idx + 1);
-            } else {
-                curitem = argZ;
-                argZ    = STRVAL_EMPTY;
-            }
-        };
-
-        nextItem();
-
-        while (curitem != STRVAL_EMPTY) {
-            m_vArgs.push_back(removeBeginEndSpacesTabs(curitem));
-            nextItem();
-        }
-    };
-
-    ~CVarList() = default;
-
-    size_t size() const {
-        return m_vArgs.size();
-    }
-
-    std::string operator[](const long unsigned int& idx) const {
-        if (idx >= m_vArgs.size())
-            return "";
-        return m_vArgs[idx];
-    }
-
-    // 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;
-};
-
 class CConfigManager {
   public:
     CConfigManager();
@@ -162,14 +84,17 @@ class CConfigManager {
 
     int                                                             getInt(const std::string&);
     float                                                           getFloat(const std::string&);
+    Vector2D                                                        getVec(const std::string&);
     std::string                                                     getString(const std::string&);
     void                                                            setFloat(const std::string&, float);
     void                                                            setInt(const std::string&, int);
+    void                                                            setVec(const std::string&, Vector2D);
     void                                                            setString(const std::string&, const std::string&);
 
-    int                                                             getDeviceInt(const std::string&, const std::string&, std::optional<bool> touchpad = {});
-    float                                                           getDeviceFloat(const std::string&, const std::string&, std::optional<bool> touchpad = {});
-    std::string                                                     getDeviceString(const std::string&, const std::string&, std::optional<bool> touchpad = {});
+    int                                                             getDeviceInt(const std::string&, const std::string&, const std::string& fallback = "");
+    float                                                           getDeviceFloat(const std::string&, const std::string&, const std::string& fallback = "");
+    Vector2D                                                        getDeviceVec(const std::string&, const std::string&, const std::string& fallback = "");
+    std::string                                                     getDeviceString(const std::string&, const std::string&, const std::string& fallback = "");
     bool                                                            deviceConfigExists(const std::string&);
     bool                                                            shouldBlurLS(const std::string&);
 
@@ -266,7 +191,7 @@ class CConfigManager {
     void         applyUserDefinedVars(std::string&, const size_t);
     void         loadConfigLoadVars();
     SConfigValue getConfigValueSafe(const std::string&);
-    SConfigValue getConfigValueSafeDevice(const std::string&, const std::string&, std::optional<bool> touchpad);
+    SConfigValue getConfigValueSafeDevice(const std::string&, const std::string&, const std::string& fallback = "");
     void         parseLine(std::string&);
     void         configSetValueSafe(const std::string&, const std::string&);
     void         handleDeviceConfig(const std::string&, const std::string&);

src/config/defaultConfig.hpp

@@ -58,6 +58,9 @@ general {
     col.inactive_border = rgba(595959aa)
 
     layout = dwindle
+
+    # Please see https://wiki.hyprland.org/Configuring/Tearing/ before you turn this on
+    allow_tearing = false
 }
 
 decoration {
@@ -108,6 +111,11 @@ gestures {
     workspace_swipe = off
 }
 
+misc {
+    # See https://wiki.hyprland.org/Configuring/Variables/ for more
+    force_default_wallpaper = -1 # Set to 0 to disable the anime mascot wallpapers
+}
+
 # Example per-device config
 # See https://wiki.hyprland.org/Configuring/Keywords/#executing for more
 device:epic-mouse-v1 {

src/debug/CrashReporter.cpp

@@ -1,7 +1,6 @@
 #include "CrashReporter.hpp"
 #include <random>
 #include <sys/utsname.h>
-#include <execinfo.h>
 #include <fstream>
 #include <signal.h>
 
@@ -14,19 +13,19 @@
 std::string getRandomMessage() {
 
     const std::vector<std::string>  MESSAGES = {"Sorry, didn't mean to...",
-                                                "This was an accident, I swear!",
-                                                "Calm down, it was a misinput! MISINPUT!",
-                                                "Oops",
-                                                "Vaxry is going to be upset.",
-                                                "Who tried dividing by zero?!",
-                                                "Maybe you should try dusting your PC in the meantime?",
-                                                "I tried so hard, and got so far...",
-                                                "I don't feel so good...",
-                                                "*thud*",
-                                                "Well this is awkward.",
-                                                "\"stable\"",
-                                                "I hope you didn't have any unsaved progress.",
-                                                "All these computers..."};
+                                               "This was an accident, I swear!",
+                                               "Calm down, it was a misinput! MISINPUT!",
+                                               "Oops",
+                                               "Vaxry is going to be upset.",
+                                               "Who tried dividing by zero?!",
+                                               "Maybe you should try dusting your PC in the meantime?",
+                                               "I tried so hard, and got so far...",
+                                               "I don't feel so good...",
+                                               "*thud*",
+                                               "Well this is awkward.",
+                                               "\"stable\"",
+                                               "I hope you didn't have any unsaved progress.",
+                                               "All these computers..."};
 
     std::random_device              dev;
     std::mt19937                    engine(dev());
@@ -45,15 +44,15 @@ void CrashReporter::createAndSaveCrash(int sig) {
     finalCrashReport += "--------------------------------------------\n   Hyprland Crash Report\n--------------------------------------------\n";
     finalCrashReport += getRandomMessage() + "\n\n";
 
-    finalCrashReport += getFormat("Hyprland received signal %d (%s)\n\n", sig, strsignal(sig));
+    finalCrashReport += std::format("Hyprland received signal {} ({})\n\n", sig, (const char*)strsignal(sig));
 
-    finalCrashReport += getFormat("Version: %s\nTag: %s\n\n", GIT_COMMIT_HASH, GIT_TAG);
+    finalCrashReport += std::format("Version: {}\nTag: {}\n\n", GIT_COMMIT_HASH, GIT_TAG);
 
     if (g_pPluginSystem && !g_pPluginSystem->getAllPlugins().empty()) {
         finalCrashReport += "Hyprland seems to be running with plugins. This crash might not be Hyprland's fault.\nPlugins:\n";
 
         for (auto& p : g_pPluginSystem->getAllPlugins()) {
-            finalCrashReport += getFormat("\t%s (%s) %s\n", p->name.c_str(), p->author.c_str(), p->version.c_str());
+            finalCrashReport += std::format("\t{} ({}) {}\n", p->name, p->author, p->version);
         }
 
         finalCrashReport += "\n\n";
@@ -65,7 +64,7 @@ void CrashReporter::createAndSaveCrash(int sig) {
     uname(&unameInfo);
 
     finalCrashReport +=
-        getFormat("\tSystem name: %s\n\tNode name: %s\n\tRelease: %s\n\tVersion: %s\n\n", unameInfo.sysname, unameInfo.nodename, unameInfo.release, unameInfo.version);
+        std::format("\tSystem name: {}\n\tNode name: {}\n\tRelease: {}\n\tVersion: {}\n\n", unameInfo.sysname, unameInfo.nodename, unameInfo.release, unameInfo.version);
 
 #if defined(__DragonFly__) || defined(__FreeBSD__)
     const std::string GPUINFO = execAndGet("pciconf -lv | fgrep -A4 vga");
@@ -75,16 +74,11 @@ void CrashReporter::createAndSaveCrash(int sig) {
 
     finalCrashReport += "GPU:\n\t" + GPUINFO;
 
-    finalCrashReport += getFormat("\n\nos-release:\n\t%s\n\n\n", replaceInString(execAndGet("cat /etc/os-release"), "\n", "\n\t").c_str());
+    finalCrashReport += std::format("\n\nos-release:\n\t{}\n\n\n", replaceInString(execAndGet("cat /etc/os-release"), "\n", "\n\t"));
 
     finalCrashReport += "Backtrace:\n";
 
-    void*  bt[1024];
-    size_t btSize;
-    char** btSymbols;
-
-    btSize    = backtrace(bt, 1024);
-    btSymbols = backtrace_symbols(bt, btSize);
+    const auto CALLSTACK = getBacktrace();
 
 #if defined(KERN_PROC_PATHNAME)
     int mib[] = {
@@ -111,20 +105,18 @@ void CrashReporter::createAndSaveCrash(int sig) {
     const auto FPATH = std::filesystem::canonical("/proc/self/exe");
 #endif
 
-    for (size_t i = 0; i < btSize; ++i) {
-        finalCrashReport += getFormat("\t#%lu | %s\n", i, btSymbols[i]);
+    for (size_t i = 0; i < CALLSTACK.size(); ++i) {
+        finalCrashReport += std::format("\t#{} | {}\n", i, CALLSTACK[i].desc);
 
 #ifdef __clang__
-        const auto CMD = getFormat("llvm-addr2line -e %s -f 0x%lx", FPATH.c_str(), (uint64_t)bt[i]);
+        const auto CMD = std::format("llvm-addr2line -e {} -f 0x{:x}", FPATH.c_str(), (uint64_t)CALLSTACK[i].adr);
 #else
-        const auto CMD = getFormat("addr2line -e %s -f 0x%lx", FPATH.c_str(), (uint64_t)bt[i]);
+        const auto CMD = std::format("addr2line -e {} -f 0x{:x}", FPATH.c_str(), (uint64_t)CALLSTACK[i].adr);
 #endif
         const auto ADDR2LINE = replaceInString(execAndGet(CMD.c_str()), "\n", "\n\t\t");
         finalCrashReport += "\t\t" + ADDR2LINE.substr(0, ADDR2LINE.length() - 2);
     }
 
-    free(btSymbols);
-
     finalCrashReport += "\n\nLog tail:\n";
 
     finalCrashReport += execAndGet(("cat \"" + Debug::logFile + "\" | tail -n 50").c_str());
@@ -137,7 +129,7 @@ void CrashReporter::createAndSaveCrash(int sig) {
 
     std::ofstream ofs;
     std::string   path;
-    if (!CACHE_HOME) {
+    if (!CACHE_HOME || std::string(CACHE_HOME).empty()) {
         if (!std::filesystem::exists(std::string(HOME) + "/.hyprland")) {
             std::filesystem::create_directory(std::string(HOME) + "/.hyprland");
             std::filesystem::permissions(std::string(HOME) + "/.hyprland", std::filesystem::perms::all, std::filesystem::perm_options::replace);
@@ -146,7 +138,7 @@ void CrashReporter::createAndSaveCrash(int sig) {
         path = std::string(HOME) + "/.hyprland/hyprlandCrashReport" + std::to_string(PID) + ".txt";
         ofs.open(path, std::ios::trunc);
 
-    } else if (CACHE_HOME) {
+    } else {
         if (!std::filesystem::exists(std::string(CACHE_HOME) + "/hyprland")) {
             std::filesystem::create_directory(std::string(CACHE_HOME) + "/hyprland");
             std::filesystem::permissions(std::string(CACHE_HOME) + "/hyprland", std::filesystem::perms::all, std::filesystem::perm_options::replace);
@@ -154,8 +146,6 @@ void CrashReporter::createAndSaveCrash(int sig) {
 
         path = std::string(CACHE_HOME) + "/hyprland/hyprlandCrashReport" + std::to_string(PID) + ".txt";
         ofs.open(path, std::ios::trunc);
-    } else {
-        return;
     }
 
     ofs << finalCrashReport;
@@ -163,5 +153,5 @@ void CrashReporter::createAndSaveCrash(int sig) {
     ofs.close();
 
     Debug::disableStdout = false;
-    Debug::log(CRIT, "Hyprland has crashed :( Consult the crash report at %s for more information.", path.c_str());
+    Debug::log(CRIT, "Hyprland has crashed :( Consult the crash report at {} for more information.", path);
 }

src/debug/HyprCtl.cpp

@@ -37,41 +37,42 @@ std::string monitorsRequest(HyprCtl::eHyprCtlOutputFormat format) {
             if (!m->output)
                 continue;
 
-            result += getFormat(
-                R"#({
-    "id": %i,
-    "name": "%s",
-    "description": "%s",
-    "make": "%s",
-    "model": "%s",
-    "serial": "%s",
-    "width": %i,
-    "height": %i,
-    "refreshRate": %f,
-    "x": %i,
-    "y": %i,
-    "activeWorkspace": {
-        "id": %i,
-        "name": "%s"
-    },
-    "specialWorkspace": {
-        "id": %i,
-        "name": "%s"
-    },
-    "reserved": [%i, %i, %i, %i],
-    "scale": %.2f,
-    "transform": %i,
-    "focused": %s,
-    "dpmsStatus": %s,
-    "vrr": %s
-},)#",
-                m->ID, escapeJSONStrings(m->szName).c_str(), escapeJSONStrings(m->output->description ? m->output->description : "").c_str(),
-                (m->output->make ? m->output->make : ""), (m->output->model ? m->output->model : ""), (m->output->serial ? m->output->serial : ""), (int)m->vecPixelSize.x,
-                (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y, m->activeWorkspace,
-                escapeJSONStrings(g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName).c_str(), m->specialWorkspaceID,
-                escapeJSONStrings(getWorkspaceNameFromSpecialID(m->specialWorkspaceID)).c_str(), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y,
+            result += std::format(
+                R"#({{
+    "id": {},
+    "name": "{}",
+    "description": "{}",
+    "make": "{}",
+    "model": "{}",
+    "serial": "{}",
+    "width": {},
+    "height": {},
+    "refreshRate": {:.5f},
+    "x": {},
+    "y": {},
+    "activeWorkspace": {{
+        "id": {},
+        "name": "{}"
+    }},
+    "specialWorkspace": {{
+        "id": {},
+        "name": "{}"
+    }},
+    "reserved": [{}, {}, {}, {}],
+    "scale": {:.2f},
+    "transform": {},
+    "focused": {},
+    "dpmsStatus": {},
+    "vrr": {},
+    "activelyTearing": {}
+}},)#",
+                m->ID, escapeJSONStrings(m->szName), escapeJSONStrings(m->output->description ? m->output->description : ""), (m->output->make ? m->output->make : ""),
+                (m->output->model ? m->output->model : ""), (m->output->serial ? m->output->serial : ""), (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate,
+                (int)m->vecPosition.x, (int)m->vecPosition.y, m->activeWorkspace, escapeJSONStrings(g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName),
+                m->specialWorkspaceID, escapeJSONStrings(getWorkspaceNameFromSpecialID(m->specialWorkspaceID)), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y,
                 (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m.get() == g_pCompositor->m_pLastMonitor ? "true" : "false"),
-                (m->dpmsStatus ? "true" : "false"), (m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED ? "true" : "false"));
+                (m->dpmsStatus ? "true" : "false"), (m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED ? "true" : "false"),
+                m->tearingState.activelyTearing ? "true" : "false");
         }
 
         trimTrailingComma(result);
@@ -82,17 +83,17 @@ std::string monitorsRequest(HyprCtl::eHyprCtlOutputFormat format) {
             if (!m->output)
                 continue;
 
-            result += getFormat("Monitor %s (ID %i):\n\t%ix%i@%f at %ix%i\n\tdescription: %s\n\tmake: %s\n\tmodel: %s\n\tserial: %s\n\tactive workspace: %i (%s)\n\tspecial "
-                                "workspace: %i (%s)\n\treserved: %i "
-                                "%i %i %i\n\tscale: %.2f\n\ttransform: "
-                                "%i\n\tfocused: %s\n\tdpmsStatus: %i\n\tvrr: %i\n\n",
-                                m->szName.c_str(), m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y,
-                                (m->output->description ? m->output->description : ""), (m->output->make ? m->output->make : ""), (m->output->model ? m->output->model : ""),
-                                (m->output->serial ? m->output->serial : ""), m->activeWorkspace, g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName.c_str(),
-                                m->specialWorkspaceID, getWorkspaceNameFromSpecialID(m->specialWorkspaceID).c_str(), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y,
-                                (int)m->vecReservedBottomRight.x, (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform,
-                                (m.get() == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus,
-                                (int)(m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED));
+            result +=
+                std::format("Monitor {} (ID {}):\n\t{}x{}@{:.5f} at {}x{}\n\tdescription: {}\n\tmake: {}\n\tmodel: {}\n\tserial: {}\n\tactive workspace: {} ({})\n\tspecial "
+                            "workspace: {} ({})\n\treserved: {} "
+                            "{} {} {}\n\tscale: {:.2f}\n\ttransform: "
+                            "{}\n\tfocused: {}\n\tdpmsStatus: {}\n\tvrr: {}\n\tactivelyTearing: {}\n\n",
+                            m->szName, m->ID, (int)m->vecPixelSize.x, (int)m->vecPixelSize.y, m->refreshRate, (int)m->vecPosition.x, (int)m->vecPosition.y,
+                            (m->output->description ? m->output->description : ""), (m->output->make ? m->output->make : ""), (m->output->model ? m->output->model : ""),
+                            (m->output->serial ? m->output->serial : ""), m->activeWorkspace, g_pCompositor->getWorkspaceByID(m->activeWorkspace)->m_szName, m->specialWorkspaceID,
+                            getWorkspaceNameFromSpecialID(m->specialWorkspaceID), (int)m->vecReservedTopLeft.x, (int)m->vecReservedTopLeft.y, (int)m->vecReservedBottomRight.x,
+                            (int)m->vecReservedBottomRight.y, m->scale, (int)m->transform, (m.get() == g_pCompositor->m_pLastMonitor ? "yes" : "no"), (int)m->dpmsStatus,
+                            (int)(m->output->adaptive_sync_status == WLR_OUTPUT_ADAPTIVE_SYNC_ENABLED), m->tearingState.activelyTearing);
         }
     }
 
@@ -113,7 +114,6 @@ static std::string getGroupedData(CWindow* w, HyprCtl::eHyprCtlOutputFormat form
     } while (curr != w);
 
     const auto         comma = isJson ? ", " : ",";
-    const auto         fmt   = isJson ? "\"0x%lx\"" : "%lx";
     std::ostringstream result;
 
     bool               first = true;
@@ -122,8 +122,10 @@ static std::string getGroupedData(CWindow* w, HyprCtl::eHyprCtlOutputFormat form
             first = false;
         else
             result << comma;
-
-        result << getFormat(fmt, gw);
+        if (isJson)
+            result << std::format("\"0x{:x}\"", (uintptr_t)gw);
+        else
+            result << std::format("{:x}", (uintptr_t)gw);
     }
 
     return result.str();
@@ -131,58 +133,57 @@ static std::string getGroupedData(CWindow* w, HyprCtl::eHyprCtlOutputFormat form
 
 static std::string getWindowData(CWindow* w, HyprCtl::eHyprCtlOutputFormat format) {
     if (format == HyprCtl::FORMAT_JSON) {
-        return getFormat(
-            R"#({
-    "address": "0x%lx",
-    "mapped": %s,
-    "hidden": %s,
-    "at": [%i, %i],
-    "size": [%i, %i],
-    "workspace": {
-        "id": %i,
-        "name": "%s"
-    },
-    "floating": %s,
-    "monitor": %i,
-    "class": "%s",
-    "title": "%s",
-    "initialClass": "%s",
-    "initialTitle": "%s",
-    "pid": %i,
-    "xwayland": %s,
-    "pinned": %s,
-    "fullscreen": %s,
-    "fullscreenMode": %i,
-    "fakeFullscreen": %s,
-    "grouped": [%s],
-    "swallowing": %s
-},)#",
-            w, (w->m_bIsMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y,
+        return std::format(
+            R"#({{
+    "address": "0x{:x}",
+    "mapped": {},
+    "hidden": {},
+    "at": [{}, {}],
+    "size": [{}, {}],
+    "workspace": {{
+        "id": {},
+        "name": "{}"
+    }},
+    "floating": {},
+    "monitor": {},
+    "class": "{}",
+    "title": "{}",
+    "initialClass": "{}",
+    "initialTitle": "{}",
+    "pid": {},
+    "xwayland": {},
+    "pinned": {},
+    "fullscreen": {},
+    "fullscreenMode": {},
+    "fakeFullscreen": {},
+    "grouped": [{}],
+    "swallowing": "0x{:x}"
+}},)#",
+            (uintptr_t)w, (w->m_bIsMapped ? "true" : "false"), (w->isHidden() ? "true" : "false"), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y,
             (int)w->m_vRealSize.goalv().x, (int)w->m_vRealSize.goalv().y, w->m_iWorkspaceID,
             escapeJSONStrings(w->m_iWorkspaceID == -1                                ? "" :
                                   g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName :
-                                                                                       std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID)))
-                .c_str(),
-            ((int)w->m_bIsFloating == 1 ? "true" : "false"), w->m_iMonitorID, escapeJSONStrings(g_pXWaylandManager->getAppIDClass(w)).c_str(),
-            escapeJSONStrings(g_pXWaylandManager->getTitle(w)).c_str(), escapeJSONStrings(w->m_szInitialClass).c_str(), escapeJSONStrings(w->m_szInitialTitle).c_str(), w->getPID(),
+                                                                                       std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID))),
+            ((int)w->m_bIsFloating == 1 ? "true" : "false"), (int64_t)w->m_iMonitorID, escapeJSONStrings(g_pXWaylandManager->getAppIDClass(w)),
+            escapeJSONStrings(g_pXWaylandManager->getTitle(w)), escapeJSONStrings(w->m_szInitialClass), escapeJSONStrings(w->m_szInitialTitle), w->getPID(),
             ((int)w->m_bIsX11 == 1 ? "true" : "false"), (w->m_bPinned ? "true" : "false"), (w->m_bIsFullscreen ? "true" : "false"),
-            (w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0),
-            w->m_bFakeFullscreenState ? "true" : "false", getGroupedData(w, format).c_str(), (w->m_pSwallowed ? getFormat("\"0x%lx\"", w->m_pSwallowed).c_str() : "null"));
+            (w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? (int)g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0),
+            w->m_bFakeFullscreenState ? "true" : "false", getGroupedData(w, format), (uintptr_t)w->m_pSwallowed);
     } else {
-        return getFormat(
-            "Window %lx -> %s:\n\tmapped: %i\n\thidden: %i\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\tinitialClass: %s\n\tinitialTitle: %s\n\tpid: "
-            "%i\n\txwayland: %i\n\tpinned: "
-            "%i\n\tfullscreen: %i\n\tfullscreenmode: %i\n\tfakefullscreen: %i\n\tgrouped: %s\n\tswallowing: %lx\n\n",
-            w, w->m_szTitle.c_str(), (int)w->m_bIsMapped, (int)w->isHidden(), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y, (int)w->m_vRealSize.goalv().x,
-            (int)w->m_vRealSize.goalv().y, w->m_iWorkspaceID,
+        return std::format(
+            "Window {:x} -> {}:\n\tmapped: {}\n\thidden: {}\n\tat: {},{}\n\tsize: {},{}\n\tworkspace: {} ({})\n\tfloating: {}\n\tmonitor: {}\n\tclass: {}\n\ttitle: "
+            "{}\n\tinitialClass: {}\n\tinitialTitle: {}\n\tpid: "
+            "{}\n\txwayland: {}\n\tpinned: "
+            "{}\n\tfullscreen: {}\n\tfullscreenmode: {}\n\tfakefullscreen: {}\n\tgrouped: {}\n\tswallowing: {:x}\n\n",
+            (uintptr_t)w, w->m_szTitle, (int)w->m_bIsMapped, (int)w->isHidden(), (int)w->m_vRealPosition.goalv().x, (int)w->m_vRealPosition.goalv().y,
+            (int)w->m_vRealSize.goalv().x, (int)w->m_vRealSize.goalv().y, w->m_iWorkspaceID,
             (w->m_iWorkspaceID == -1                                ? "" :
-                 g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName.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->m_szInitialClass.c_str(),
-            w->m_szInitialTitle.c_str(), w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (int)w->m_bIsFullscreen,
+                 g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_szName :
+                                                                      std::string("Invalid workspace " + std::to_string(w->m_iWorkspaceID))),
+            (int)w->m_bIsFloating, (int64_t)w->m_iMonitorID, g_pXWaylandManager->getAppIDClass(w), g_pXWaylandManager->getTitle(w), w->m_szInitialClass, w->m_szInitialTitle,
+            w->getPID(), (int)w->m_bIsX11, (int)w->m_bPinned, (int)w->m_bIsFullscreen,
             (w->m_bIsFullscreen ? (g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID) ? g_pCompositor->getWorkspaceByID(w->m_iWorkspaceID)->m_efFullscreenMode : 0) : 0),
-            (int)w->m_bFakeFullscreenState, getGroupedData(w, format).c_str(), w->m_pSwallowed);
+            (int)w->m_bFakeFullscreenState, getGroupedData(w, format), (uintptr_t)w->m_pSwallowed);
     }
 }
 
@@ -210,28 +211,34 @@ static std::string getWorkspaceData(CWorkspace* w, HyprCtl::eHyprCtlOutputFormat
     const auto PLASTW   = w->getLastFocusedWindow();
     const auto PMONITOR = g_pCompositor->getMonitorFromID(w->m_iMonitorID);
     if (format == HyprCtl::FORMAT_JSON) {
-        return getFormat(R"#({
-    "id": %i,
-    "name": "%s",
-    "monitor": "%s",
-    "windows": %i,
-    "hasfullscreen": %s,
-    "lastwindow": "0x%lx",
-    "lastwindowtitle": "%s"
-})#",
-                         w->m_iID, escapeJSONStrings(w->m_szName).c_str(), escapeJSONStrings(PMONITOR ? PMONITOR->szName : "?").c_str(),
-                         g_pCompositor->getWindowsOnWorkspace(w->m_iID), ((int)w->m_bHasFullscreenWindow == 1 ? "true" : "false"), PLASTW,
-                         PLASTW ? escapeJSONStrings(PLASTW->m_szTitle).c_str() : "");
+        return std::format(R"#({{
+    "id": {},
+    "name": "{}",
+    "monitor": "{}",
+    "windows": {},
+    "hasfullscreen": {},
+    "lastwindow": "0x{:x}",
+    "lastwindowtitle": "{}"
+}})#",
+                           w->m_iID, escapeJSONStrings(w->m_szName), escapeJSONStrings(PMONITOR ? PMONITOR->szName : "?"), g_pCompositor->getWindowsOnWorkspace(w->m_iID),
+                           ((int)w->m_bHasFullscreenWindow == 1 ? "true" : "false"), (uintptr_t)PLASTW, PLASTW ? escapeJSONStrings(PLASTW->m_szTitle) : "");
     } else {
-        return getFormat("workspace ID %i (%s) on monitor %s:\n\twindows: %i\n\thasfullscreen: %i\n\tlastwindow: 0x%lx\n\tlastwindowtitle: %s\n\n", w->m_iID, w->m_szName.c_str(),
-                         PMONITOR ? PMONITOR->szName.c_str() : "?", g_pCompositor->getWindowsOnWorkspace(w->m_iID), (int)w->m_bHasFullscreenWindow, PLASTW,
-                         PLASTW ? PLASTW->m_szTitle.c_str() : "");
+        return std::format("workspace ID {} ({}) on monitor {}:\n\twindows: {}\n\thasfullscreen: {}\n\tlastwindow: 0x{:x}\n\tlastwindowtitle: {}\n\n", w->m_iID, w->m_szName,
+                           PMONITOR ? PMONITOR->szName : "?", g_pCompositor->getWindowsOnWorkspace(w->m_iID), (int)w->m_bHasFullscreenWindow, (uintptr_t)PLASTW,
+                           PLASTW ? PLASTW->m_szTitle : "");
     }
 }
 
 std::string activeWorkspaceRequest(HyprCtl::eHyprCtlOutputFormat format) {
+    if (!g_pCompositor->m_pLastMonitor)
+        return "unsafe state";
+
     std::string result = "";
     auto        w      = g_pCompositor->getWorkspaceByID(g_pCompositor->m_pLastMonitor->activeWorkspace);
+
+    if (!w)
+        return "internal error";
+
     return getWorkspaceData(w, format);
 }
 
@@ -277,30 +284,30 @@ std::string layersRequest(HyprCtl::eHyprCtlOutputFormat format) {
         result += "{\n";
 
         for (auto& mon : g_pCompositor->m_vMonitors) {
-            result += getFormat(
-                R"#("%s": {
-    "levels": {
+            result += std::format(
+                R"#("{}": {{
+    "levels": {{
 )#",
-                escapeJSONStrings(mon->szName).c_str());
+                escapeJSONStrings(mon->szName));
 
             int layerLevel = 0;
             for (auto& level : mon->m_aLayerSurfaceLayers) {
-                result += getFormat(
+                result += std::format(
                     R"#(
-        "%i": [
+        "{}": [
 )#",
                     layerLevel);
                 for (auto& layer : level) {
-                    result += getFormat(
-                        R"#(                {
-                    "address": "0x%lx",
-                    "x": %i,
-                    "y": %i,
-                    "w": %i,
-                    "h": %i,
-                    "namespace": "%s"
-                },)#",
-                        layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width, layer->geometry.height, escapeJSONStrings(layer->szNamespace).c_str());
+                    result += std::format(
+                        R"#(                {{
+                    "address": "0x{:x}",
+                    "x": {},
+                    "y": {},
+                    "w": {},
+                    "h": {},
+                    "namespace": "{}"
+                }},)#",
+                        (uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width, layer->geometry.height, escapeJSONStrings(layer->szNamespace));
                 }
 
                 trimTrailingComma(result);
@@ -324,15 +331,15 @@ std::string layersRequest(HyprCtl::eHyprCtlOutputFormat format) {
 
     } else {
         for (auto& mon : g_pCompositor->m_vMonitors) {
-            result += getFormat("Monitor %s:\n", mon->szName.c_str());
+            result += std::format("Monitor {}:\n", mon->szName);
             int                                     layerLevel = 0;
             static const std::array<std::string, 4> levelNames = {"background", "bottom", "top", "overlay"};
             for (auto& level : mon->m_aLayerSurfaceLayers) {
-                result += getFormat("\tLayer level %i (%s):\n", layerLevel, levelNames[layerLevel].c_str());
+                result += std::format("\tLayer level {} ({}):\n", layerLevel, levelNames[layerLevel]);
 
                 for (auto& layer : level) {
-                    result += getFormat("\t\tLayer %lx: xywh: %i %i %i %i, namespace: %s\n", layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width,
-                                        layer->geometry.height, layer->szNamespace.c_str());
+                    result += std::format("\t\tLayer {:x}: xywh: {} {} {} {}, namespace: {}\n", (uintptr_t)layer.get(), layer->geometry.x, layer->geometry.y, layer->geometry.width,
+                                          layer->geometry.height, layer->szNamespace);
                 }
 
                 layerLevel++;
@@ -352,13 +359,13 @@ std::string devicesRequest(HyprCtl::eHyprCtlOutputFormat format) {
         result += "\"mice\": [\n";
 
         for (auto& m : g_pInputManager->m_lMice) {
-            result += getFormat(
-                R"#(    {
-        "address": "0x%lx",
-        "name": "%s",
-        "defaultSpeed": %f
-    },)#",
-                &m, escapeJSONStrings(m.name).c_str(),
+            result += std::format(
+                R"#(    {{
+        "address": "0x{:x}",
+        "name": "{}",
+        "defaultSpeed": {:.5f}
+    }},)#",
+                (uintptr_t)&m, escapeJSONStrings(m.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);
         }
 
@@ -368,21 +375,21 @@ std::string devicesRequest(HyprCtl::eHyprCtlOutputFormat format) {
         result += "\"keyboards\": [\n";
         for (auto& k : g_pInputManager->m_lKeyboards) {
             const auto KM = g_pInputManager->getActiveLayoutForKeyboard(&k);
-            result += getFormat(
-                R"#(    {
-        "address": "0x%lx",
-        "name": "%s",
-        "rules": "%s",
-        "model": "%s",
-        "layout": "%s",
-        "variant": "%s",
-        "options": "%s",
-        "active_keymap": "%s",
-        "main": %s
-    },)#",
-                &k, escapeJSONStrings(k.name).c_str(), escapeJSONStrings(k.currentRules.rules).c_str(), escapeJSONStrings(k.currentRules.model).c_str(),
-                escapeJSONStrings(k.currentRules.layout).c_str(), escapeJSONStrings(k.currentRules.variant).c_str(), escapeJSONStrings(k.currentRules.options).c_str(),
-                escapeJSONStrings(KM).c_str(), (k.active ? "true" : "false"));
+            result += std::format(
+                R"#(    {{
+        "address": "0x{:x}",
+        "name": "{}",
+        "rules": "{}",
+        "model": "{}",
+        "layout": "{}",
+        "variant": "{}",
+        "options": "{}",
+        "active_keymap": "{}",
+        "main": {}
+    }},)#",
+                (uintptr_t)&k, escapeJSONStrings(k.name), escapeJSONStrings(k.currentRules.rules), escapeJSONStrings(k.currentRules.model),
+                escapeJSONStrings(k.currentRules.layout), escapeJSONStrings(k.currentRules.variant), escapeJSONStrings(k.currentRules.options), escapeJSONStrings(KM),
+                (k.active ? "true" : "false"));
         }
 
         trimTrailingComma(result);
@@ -391,35 +398,35 @@ std::string devicesRequest(HyprCtl::eHyprCtlOutputFormat format) {
         result += "\"tablets\": [\n";
 
         for (auto& d : g_pInputManager->m_lTabletPads) {
-            result += getFormat(
-                R"#(    {
-        "address": "0x%lx",
+            result += std::format(
+                R"#(    {{
+        "address": "0x{:x}",
         "type": "tabletPad",
-        "belongsTo": {
-            "address": "0x%lx",
-            "name": "%s"
-        }
-    },)#",
-                &d, d.pTabletParent, escapeJSONStrings(d.pTabletParent ? d.pTabletParent->name : "").c_str());
+        "belongsTo": {{
+            "address": "0x{:x}",
+            "name": "{}"
+        }}
+    }},)#",
+                (uintptr_t)&d, (uintptr_t)d.pTabletParent, escapeJSONStrings(d.pTabletParent ? d.pTabletParent->name : ""));
         }
 
         for (auto& d : g_pInputManager->m_lTablets) {
-            result += getFormat(
-                R"#(    {
-        "address": "0x%lx",
-        "name": "%s"
-    },)#",
-                &d, escapeJSONStrings(d.name).c_str());
+            result += std::format(
+                R"#(    {{
+        "address": "0x{:x}",
+        "name": "{}"
+    }},)#",
+                (uintptr_t)&d, escapeJSONStrings(d.name));
         }
 
         for (auto& d : g_pInputManager->m_lTabletTools) {
-            result += getFormat(
-                R"#(    {
-        "address": "0x%lx",
+            result += std::format(
+                R"#(    {{
+        "address": "0x{:x}",
         "type": "tabletTool",
-        "belongsTo": "0x%lx"
-    },)#",
-                &d, d.wlrTabletTool ? d.wlrTabletTool->data : 0);
+        "belongsTo": "0x{:x}"
+    }},)#",
+                (uintptr_t)&d, d.wlrTabletTool ? (uintptr_t)d.wlrTabletTool->data : 0);
         }
 
         trimTrailingComma(result);
@@ -428,12 +435,12 @@ std::string devicesRequest(HyprCtl::eHyprCtlOutputFormat format) {
         result += "\"touch\": [\n";
 
         for (auto& d : g_pInputManager->m_lTouchDevices) {
-            result += getFormat(
-                R"#(    {
-        "address": "0x%lx",
-        "name": "%s"
-    },)#",
-                &d, d.name.c_str());
+            result += std::format(
+                R"#(    {{
+        "address": "0x{:x}",
+        "name": "{}"
+    }},)#",
+                (uintptr_t)&d, d.name);
         }
 
         trimTrailingComma(result);
@@ -442,12 +449,12 @@ std::string devicesRequest(HyprCtl::eHyprCtlOutputFormat format) {
         result += "\"switches\": [\n";
 
         for (auto& d : g_pInputManager->m_lSwitches) {
-            result += getFormat(
-                R"#(    {
-        "address": "0x%lx",
-        "name": "%s"
-    },)#",
-                &d, d.pWlrDevice ? d.pWlrDevice->name : "");
+            result += std::format(
+                R"#(    {{
+        "address": "0x{:x}",
+        "name": "{}"
+    }},)#",
+                (uintptr_t)&d, d.pWlrDevice ? d.pWlrDevice->name : "");
         }
 
         trimTrailingComma(result);
@@ -459,8 +466,8 @@ std::string devicesRequest(HyprCtl::eHyprCtlOutputFormat format) {
         result += "mice:\n";
 
         for (auto& m : g_pInputManager->m_lMice) {
-            result += getFormat(
-                "\tMouse at %lx:\n\t\t%s\n\t\t\tdefault speed: %f\n", &m, m.name.c_str(),
+            result += std::format(
+                "\tMouse at {:x}:\n\t\t{}\n\t\t\tdefault speed: {:.5f}\n", (uintptr_t)&m, m.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));
         }
 
@@ -468,35 +475,35 @@ std::string devicesRequest(HyprCtl::eHyprCtlOutputFormat format) {
 
         for (auto& k : g_pInputManager->m_lKeyboards) {
             const auto KM = g_pInputManager->getActiveLayoutForKeyboard(&k);
-            result += getFormat("\tKeyboard at %lx:\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 += std::format("\tKeyboard at {:x}:\n\t\t{}\n\t\t\trules: r \"{}\", m \"{}\", l \"{}\", v \"{}\", o \"{}\"\n\t\t\tactive keymap: {}\n\t\t\tmain: {}\n",
+                                  (uintptr_t)&k, k.name, k.currentRules.rules, k.currentRules.model, k.currentRules.layout, k.currentRules.variant, k.currentRules.options, KM,
+                                  (k.active ? "yes" : "no"));
         }
 
         result += "\n\nTablets:\n";
 
         for (auto& d : g_pInputManager->m_lTabletPads) {
-            result += getFormat("\tTablet Pad at %lx (belongs to %lx -> %s)\n", &d, d.pTabletParent, d.pTabletParent ? d.pTabletParent->name.c_str() : "");
+            result += std::format("\tTablet Pad at {:x} (belongs to {:x} -> {})\n", (uintptr_t)&d, (uintptr_t)d.pTabletParent, d.pTabletParent ? d.pTabletParent->name : "");
         }
 
         for (auto& d : g_pInputManager->m_lTablets) {
-            result += getFormat("\tTablet at %lx:\n\t\t%s\n", &d, d.name.c_str());
+            result += std::format("\tTablet at {:x}:\n\t\t{}\n", (uintptr_t)&d, d.name);
         }
 
         for (auto& d : g_pInputManager->m_lTabletTools) {
-            result += getFormat("\tTablet Tool at %lx (belongs to %lx)\n", &d, d.wlrTabletTool ? d.wlrTabletTool->data : 0);
+            result += std::format("\tTablet Tool at {:x} (belongs to {:x})\n", (uintptr_t)&d, d.wlrTabletTool ? (uintptr_t)d.wlrTabletTool->data : 0);
         }
 
         result += "\n\nTouch:\n";
 
         for (auto& d : g_pInputManager->m_lTouchDevices) {
-            result += getFormat("\tTouch Device at %lx:\n\t\t%s\n", &d, d.name.c_str());
+            result += std::format("\tTouch Device at {:x}:\n\t\t{}\n", (uintptr_t)&d, d.name);
         }
 
         result += "\n\nSwitches:\n";
 
         for (auto& d : g_pInputManager->m_lSwitches) {
-            result += getFormat("\tSwitch Device at %lx:\n\t\t%s\n", &d, d.pWlrDevice ? d.pWlrDevice->name : "");
+            result += std::format("\tSwitch Device at {:x}:\n\t\t{}\n", (uintptr_t)&d, d.pWlrDevice ? d.pWlrDevice->name : "");
         }
     }
 
@@ -509,31 +516,31 @@ std::string animationsRequest(HyprCtl::eHyprCtlOutputFormat format) {
         ret += "animations:\n";
 
         for (auto& ac : g_pConfigManager->getAnimationConfig()) {
-            ret += getFormat("\n\tname: %s\n\t\toverriden: %i\n\t\tbezier: %s\n\t\tenabled: %i\n\t\tspeed: %.2f\n\t\tstyle: %s\n", ac.first.c_str(), (int)ac.second.overridden,
-                             ac.second.internalBezier.c_str(), ac.second.internalEnabled, ac.second.internalSpeed, ac.second.internalStyle.c_str());
+            ret += std::format("\n\tname: {}\n\t\toverriden: {}\n\t\tbezier: {}\n\t\tenabled: {}\n\t\tspeed: {:.2f}\n\t\tstyle: {}\n", ac.first, (int)ac.second.overridden,
+                               ac.second.internalBezier, ac.second.internalEnabled, ac.second.internalSpeed, ac.second.internalStyle);
         }
 
         ret += "beziers:\n";
 
         for (auto& bz : g_pAnimationManager->getAllBeziers()) {
-            ret += getFormat("\n\tname: %s\n", bz.first.c_str());
+            ret += std::format("\n\tname: {}\n", bz.first);
         }
     } else {
         // json
 
         ret += "[[";
         for (auto& ac : g_pConfigManager->getAnimationConfig()) {
-            ret += getFormat(R"#(
-{
-    "name": "%s",
-    "overridden": %s,
-    "bezier": "%s",
-    "enabled": %s,
-    "speed": %.2f,
-    "style": "%s"
-},)#",
-                             ac.first.c_str(), ac.second.overridden ? "true" : "false", ac.second.internalBezier.c_str(), ac.second.internalEnabled ? "true" : "false",
-                             ac.second.internalSpeed, ac.second.internalStyle.c_str());
+            ret += std::format(R"#(
+{{
+    "name": "{}",
+    "overridden": {},
+    "bezier": "{}",
+    "enabled": {},
+    "speed": {:.2f},
+    "style": "{}"
+}},)#",
+                               ac.first, ac.second.overridden ? "true" : "false", ac.second.internalBezier, ac.second.internalEnabled ? "true" : "false", ac.second.internalSpeed,
+                               ac.second.internalStyle);
         }
 
         ret[ret.length() - 1] = ']';
@@ -541,11 +548,11 @@ std::string animationsRequest(HyprCtl::eHyprCtlOutputFormat format) {
         ret += ",\n[";
 
         for (auto& bz : g_pAnimationManager->getAllBeziers()) {
-            ret += getFormat(R"#(
-{
-    "name": "%s"
-},)#",
-                             bz.first.c_str());
+            ret += std::format(R"#(
+{{
+    "name": "{}"
+}},)#",
+                               bz.first);
         }
 
         trimTrailingComma(ret);
@@ -561,16 +568,16 @@ std::string globalShortcutsRequest(HyprCtl::eHyprCtlOutputFormat format) {
     const auto  SHORTCUTS = g_pProtocolManager->m_pGlobalShortcutsProtocolManager->getAllShortcuts();
     if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL) {
         for (auto& sh : SHORTCUTS)
-            ret += getFormat("%s:%s -> %s\n", sh.appid.c_str(), sh.id.c_str(), sh.description.c_str());
+            ret += std::format("{}:{} -> {}\n", sh.appid, sh.id, sh.description);
     } else {
         ret += "[";
         for (auto& sh : SHORTCUTS) {
-            ret += getFormat(R"#(
-{
-    "name": "%s",
-    "description": "%s"
-},)#",
-                             escapeJSONStrings(sh.appid + ":" + sh.id).c_str(), escapeJSONStrings(sh.description).c_str());
+            ret += std::format(R"#(
+{{
+    "name": "{}",
+    "description": "{}"
+}},)#",
+                               escapeJSONStrings(sh.appid + ":" + sh.id), escapeJSONStrings(sh.description));
         }
         trimTrailingComma(ret);
         ret += "]\n";
@@ -595,31 +602,30 @@ std::string bindsRequest(HyprCtl::eHyprCtlOutputFormat format) {
             if (kb.nonConsuming)
                 ret += "n";
 
-            ret += getFormat("\n\tmodmask: %u\n\tsubmap: %s\n\tkey: %s\n\tkeycode: %d\n\tdispatcher: %s\n\targ: %s\n\n", kb.modmask, kb.submap.c_str(), kb.key.c_str(), kb.keycode,
-                             kb.handler.c_str(), kb.arg.c_str());
+            ret += std::format("\n\tmodmask: {}\n\tsubmap: {}\n\tkey: {}\n\tkeycode: {}\n\tdispatcher: {}\n\targ: {}\n\n", kb.modmask, kb.submap, kb.key, kb.keycode, kb.handler,
+                               kb.arg);
         }
     } else {
         // json
         ret += "[";
         for (auto& kb : g_pKeybindManager->m_lKeybinds) {
-            ret += getFormat(
+            ret += std::format(
                 R"#(
-{
-    "locked": %s,
-    "mouse": %s,
-    "release": %s,
-    "repeat": %s,
-    "non_consuming": %s,
-    "modmask": %u,
-    "submap": "%s",
-    "key": "%s",
-    "keycode": %i,
-    "dispatcher": "%s",
-    "arg": "%s"
-},)#",
+{{
+    "locked": {},
+    "mouse": {},
+    "release": {},
+    "repeat": {},
+    "non_consuming": {},
+    "modmask": {},
+    "submap": "{}",
+    "key": "{}",
+    "keycode": {},
+    "dispatcher": "{}",
+    "arg": "{}"
+}},)#",
                 kb.locked ? "true" : "false", kb.mouse ? "true" : "false", kb.release ? "true" : "false", kb.repeat ? "true" : "false", kb.nonConsuming ? "true" : "false",
-                kb.modmask, escapeJSONStrings(kb.submap).c_str(), escapeJSONStrings(kb.key).c_str(), kb.keycode, escapeJSONStrings(kb.handler).c_str(),
-                escapeJSONStrings(kb.arg).c_str());
+                kb.modmask, escapeJSONStrings(kb.submap), escapeJSONStrings(kb.key), kb.keycode, escapeJSONStrings(kb.handler), escapeJSONStrings(kb.arg));
         }
         trimTrailingComma(ret);
         ret += "]";
@@ -652,15 +658,15 @@ std::string versionRequest(HyprCtl::eHyprCtlOutputFormat format) {
 
         return result;
     } else {
-        std::string result = getFormat(
-            R"#({
-    "branch": "%s",
-    "commit": "%s",
-    "dirty": %s,
-    "commit_message": "%s",
-    "tag": "%s",
+        std::string result = std::format(
+            R"#({{
+    "branch": "{}",
+    "commit": "{}",
+    "dirty": {},
+    "commit_message": "{}",
+    "tag": "{}",
     "flags": [)#",
-            GIT_BRANCH, GIT_COMMIT_HASH, (strcmp(GIT_DIRTY, "dirty") == 0 ? "true" : "false"), escapeJSONStrings(commitMsg).c_str(), GIT_TAG);
+            GIT_BRANCH, GIT_COMMIT_HASH, (strcmp(GIT_DIRTY, "dirty") == 0 ? "true" : "false"), escapeJSONStrings(commitMsg), GIT_TAG);
 
 #ifdef LEGACY_RENDERER
         result += "\"legacyrenderer\",";
@@ -701,7 +707,7 @@ std::string dispatchRequest(std::string in) {
 
     DISPATCHER->second(DISPATCHARG);
 
-    Debug::log(LOG, "Hyprctl: dispatcher %s : %s", DISPATCHSTR.c_str(), DISPATCHARG.c_str());
+    Debug::log(LOG, "Hyprctl: dispatcher {} : {}", DISPATCHSTR, DISPATCHARG);
 
     return "ok";
 }
@@ -746,7 +752,7 @@ std::string dispatchKeyword(std::string in) {
         }
     }
 
-    Debug::log(LOG, "Hyprctl: keyword %s : %s", COMMAND.c_str(), VALUE.c_str());
+    Debug::log(LOG, "Hyprctl: keyword {} : {}", COMMAND, VALUE);
 
     if (retval == "")
         return "ok";
@@ -783,15 +789,15 @@ 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);
+        return std::format("{}, {}", (int)CURSORPOS.x, (int)CURSORPOS.y);
     } else {
-        return getFormat(R"#(
-{
-    "x": %i,
-    "y": %i
-}
+        return std::format(R"#(
+{{
+    "x": {},
+    "y": {}
+}}
 )#",
-                         (int)CURSORPOS.x, (int)CURSORPOS.y);
+                           (int)CURSORPOS.x, (int)CURSORPOS.y);
     }
 
     return "error";
@@ -838,7 +844,8 @@ std::string dispatchSetCursor(std::string request) {
     std::string theme   = "";
     for (size_t i = 1; i < vars.size() - 1; ++i)
         theme += vars[i] + " ";
-    theme.pop_back();
+    if (!theme.empty())
+        theme.pop_back();
 
     int size = 0;
     try {
@@ -954,7 +961,7 @@ std::string dispatchSetProp(std::string request) {
     bool       lock = false;
 
     if (vars.size() > 4) {
-        if (vars[4].find("lock") == 0) {
+        if (vars[4].starts_with("lock")) {
             lock = true;
         }
     }
@@ -1002,6 +1009,10 @@ std::string dispatchSetProp(std::string request) {
             PWINDOW->m_sAdditionalConfigData.forceRGBX.forceSetIgnoreLocked(configStringToInt(VAL), lock);
         } else if (PROP == "bordersize") {
             PWINDOW->m_sSpecialRenderData.borderSize.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "keepaspectratio") {
+            PWINDOW->m_sAdditionalConfigData.keepAspectRatio.forceSetIgnoreLocked(configStringToInt(VAL), lock);
+        } else if (PROP == "immediate") {
+            PWINDOW->m_sAdditionalConfigData.forceTearing.forceSetIgnoreLocked(configStringToInt(VAL), lock);
         } else {
             return "prop not found";
         }
@@ -1041,20 +1052,21 @@ std::string dispatchGetOption(std::string request, HyprCtl::eHyprCtlOutputFormat
         return "no such option";
 
     if (format == HyprCtl::eHyprCtlOutputFormat::FORMAT_NORMAL)
-        return getFormat("option %s\n\tint: %lld\n\tfloat: %f\n\tstr: \"%s\"\n\tdata: %lx", curitem.c_str(), PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue.c_str(),
-                         PCFGOPT->data.get());
+        return std::format("option {}\n\tint: {}\n\tfloat: {:.5f}\n\tstr: \"{}\"\n\tdata: {:x}\n\tset: {}", curitem, PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue,
+                           (uintptr_t)PCFGOPT->data.get(), PCFGOPT->set);
     else {
-        return getFormat(
+        return std::format(
             R"#(
-{
-    "option": "%s",
-    "int": %lld,
-    "float": %f,
-    "str": "%s",
-    "data": "0x%lx"
-}
+{{
+    "option": "{}",
+    "int": {},
+    "float": {:.5f},
+    "str": "{}",
+    "data": "0x{:x}",
+    "set": {}
+}}
 )#",
-            curitem.c_str(), PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue.c_str(), PCFGOPT->data.get());
+            curitem, PCFGOPT->intValue, PCFGOPT->floatValue, PCFGOPT->strValue, (uintptr_t)PCFGOPT->data.get(), PCFGOPT->set);
     }
 }
 
@@ -1170,8 +1182,7 @@ std::string dispatchPlugin(std::string request) {
 
         std::string list = "";
         for (auto& p : PLUGINS) {
-            list += getFormat("\nPlugin %s by %s:\n\tHandle: %lx\n\tVersion: %s\n\tDescription: %s\n", p->name.c_str(), p->author.c_str(), p->m_pHandle, p->version.c_str(),
-                              p->description.c_str());
+            list += std::format("\nPlugin {} by {}:\n\tHandle: {:x}\n\tVersion: {}\n\tDescription: {}\n", p->name, p->author, (uintptr_t)p->m_pHandle, p->version, p->description);
         }
 
         return list;
@@ -1260,7 +1271,7 @@ std::string getReply(std::string request) {
         return layersRequest(format);
     else if (request == "version")
         return versionRequest(format);
-    else if (request.find("reload") == 0)
+    else if (request.starts_with("reload"))
         return reloadRequest(request);
     else if (request == "devices")
         return devicesRequest(format);
@@ -1274,27 +1285,27 @@ std::string getReply(std::string request) {
         return globalShortcutsRequest(format);
     else if (request == "animations")
         return animationsRequest(format);
-    else if (request.find("plugin") == 0)
+    else if (request.starts_with("plugin"))
         return dispatchPlugin(request);
-    else if (request.find("notify") == 0)
+    else if (request.starts_with("notify"))
         return dispatchNotify(request);
-    else if (request.find("setprop") == 0)
+    else if (request.starts_with("setprop"))
         return dispatchSetProp(request);
-    else if (request.find("seterror") == 0)
+    else if (request.starts_with("seterror"))
         return dispatchSeterror(request);
-    else if (request.find("switchxkblayout") == 0)
+    else if (request.starts_with("switchxkblayout"))
         return switchXKBLayoutRequest(request);
-    else if (request.find("output") == 0)
+    else if (request.starts_with("output"))
         return dispatchOutput(request);
-    else if (request.find("dispatch") == 0)
+    else if (request.starts_with("dispatch"))
         return dispatchRequest(request);
-    else if (request.find("keyword") == 0)
+    else if (request.starts_with("keyword"))
         return dispatchKeyword(request);
-    else if (request.find("setcursor") == 0)
+    else if (request.starts_with("setcursor"))
         return dispatchSetCursor(request);
-    else if (request.find("getoption") == 0)
+    else if (request.starts_with("getoption"))
         return dispatchGetOption(request, format);
-    else if (request.find("[[BATCH]]") == 0)
+    else if (request.starts_with("[[BATCH]]"))
         return dispatchBatch(request);
 
     return "unknown request";
@@ -1336,7 +1347,7 @@ int hyprCtlFDTick(int fd, uint32_t mask, void* data) {
     try {
         reply = getReply(request);
     } catch (std::exception& e) {
-        Debug::log(ERR, "Error in request: %s", e.what());
+        Debug::log(ERR, "Error in request: {}", e.what());
         reply = "Err: " + std::string(e.what());
     }
 
@@ -1374,7 +1385,7 @@ void HyprCtl::startHyprCtlSocket() {
     // 10 max queued.
     listen(iSocketFD, 10);
 
-    Debug::log(LOG, "Hypr socket started at %s", socketPath.c_str());
+    Debug::log(LOG, "Hypr socket started at {}", socketPath);
 
     wl_event_loop_add_fd(g_pCompositor->m_sWLEventLoop, iSocketFD, WL_EVENT_READABLE, hyprCtlFDTick, nullptr);
 }

src/debug/HyprDebugOverlay.cpp

@@ -132,7 +132,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     yOffset += 17;
     cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
-    text = std::string(getFormat("%i FPS", (int)FPS));
+    text = std::format("{} FPS", (int)FPS);
     cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
     cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
     if (cairoExtents.width > maxX)
@@ -143,7 +143,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     yOffset += 11;
     cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
-    text = std::string(getFormat("Avg Frametime: %.2fms (var %.2fms)", avgFrametime, varFrametime));
+    text = std::format("Avg Frametime: {:.2f}ms (var {:.2f}ms)", avgFrametime, varFrametime);
     cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
     cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
     if (cairoExtents.width > maxX)
@@ -151,7 +151,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     yOffset += 11;
     cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
-    text = std::string(getFormat("Avg Rendertime: %.2fms (var %.2fms)", avgRenderTime, varRenderTime));
+    text = std::format("Avg Rendertime: {:.2f}ms (var {:.2f}ms)", avgRenderTime, varRenderTime);
     cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
     cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
     if (cairoExtents.width > maxX)
@@ -159,7 +159,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     yOffset += 11;
     cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
-    text = std::string(getFormat("Avg Rendertime (No Overlay): %.2fms (var %.2fms)", avgRenderTimeNoOverlay, varRenderTimeNoOverlay));
+    text = std::format("Avg Rendertime (No Overlay): {:.2f}ms (var {:.2f}ms)", avgRenderTimeNoOverlay, varRenderTimeNoOverlay);
     cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
     cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
     if (cairoExtents.width > maxX)
@@ -167,7 +167,7 @@ int CHyprMonitorDebugOverlay::draw(int offset) {
 
     yOffset += 11;
     cairo_move_to(g_pDebugOverlay->m_pCairo, 0, yOffset);
-    text = std::string(getFormat("Avg Anim Tick: %.2fms (var %.2fms) (%.2f TPS)", avgAnimMgrTick, varAnimMgrTick, 1.0 / (avgAnimMgrTick / 1000.0)));
+    text = std::format("Avg Anim Tick: {:.2f}ms (var {:.2f}ms) ({:.2f} TPS)", avgAnimMgrTick, varAnimMgrTick, 1.0 / (avgAnimMgrTick / 1000.0));
     cairo_show_text(g_pDebugOverlay->m_pCairo, text.c_str());
     cairo_text_extents(g_pDebugOverlay->m_pCairo, text.c_str(), &cairoExtents);
     if (cairoExtents.width > maxX)

src/debug/HyprNotificationOverlay.cpp

@@ -44,6 +44,10 @@ void CHyprNotificationOverlay::addNotification(const std::string& text, const CC
     PNOTIF->started.reset();
     PNOTIF->timeMs = timeMs;
     PNOTIF->icon   = icon;
+
+    for (auto& m : g_pCompositor->m_vMonitors) {
+        g_pCompositor->scheduleFrameForMonitor(m.get());
+    }
 }
 
 wlr_box CHyprNotificationOverlay::drawNotifications(CMonitor* pMonitor) {

src/debug/Log.cpp

@@ -10,6 +10,12 @@ void Debug::init(const std::string& IS) {
 }
 
 void Debug::wlrLog(wlr_log_importance level, const char* fmt, va_list args) {
+    if (disableLogs && *disableLogs)
+        return;
+
+    if (level > wlr_log_get_verbosity())
+        return;
+
     char*         outputStr = nullptr;
 
     std::ofstream ofs;
@@ -27,57 +33,3 @@ void Debug::wlrLog(wlr_log_importance level, const char* fmt, va_list args) {
     if (!disableStdout)
         std::cout << output << "\n";
 }
-
-void Debug::log(LogLevel level, const char* fmt, ...) {
-
-    if (disableLogs && *disableLogs)
-        return;
-
-    // log to a file
-    std::ofstream ofs;
-    ofs.open(logFile, std::ios::out | std::ios::app);
-
-    switch (level) {
-        case LOG: ofs << "[LOG] "; break;
-        case WARN: ofs << "[WARN] "; break;
-        case ERR: ofs << "[ERR] "; break;
-        case CRIT: ofs << "[CRITICAL] "; break;
-        case INFO: ofs << "[INFO] "; break;
-        default: break;
-    }
-
-    // print date and time to the ofs
-    if (disableTime && !*disableTime) {
-        auto       timet  = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
-        const auto MILLIS = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count() % 1000;
-
-        ofs << std::put_time(std::localtime(&timet), "[%H:%M:%S:");
-
-        if (MILLIS > 99)
-            ofs << MILLIS;
-        else if (MILLIS > 9)
-            ofs << "0" << MILLIS;
-        else
-            ofs << "00" << MILLIS;
-
-        ofs << "] ";
-    }
-
-    char*   outputStr = nullptr;
-
-    va_list args;
-    va_start(args, fmt);
-    vasprintf(&outputStr, fmt, args);
-    va_end(args);
-
-    std::string output = std::string(outputStr);
-    free(outputStr);
-
-    ofs << output << "\n";
-
-    ofs.close();
-
-    // log it to the stdout too.
-    if (!disableStdout)
-        std::cout << output << "\n";
-}

src/debug/Log.hpp

@@ -1,26 +1,82 @@
 #pragma once
 #include <string>
 #include <wlr/util/log.h>
+#include <format>
+#include <iostream>
+#include <fstream>
+#include <chrono>
+#include "../helpers/MiscFunctions.hpp"
 
 #define LOGMESSAGESIZE 1024
 
-enum LogLevel
-{
+enum LogLevel {
     NONE = -1,
     LOG  = 0,
     WARN,
     ERR,
     CRIT,
-    INFO
+    INFO,
+    TRACE
 };
 
 namespace Debug {
-    void               init(const std::string& IS);
-    void               log(LogLevel level, const char* fmt, ...);
-    void               wlrLog(wlr_log_importance level, const char* fmt, va_list args);
-
     inline std::string logFile;
     inline int64_t*    disableLogs   = nullptr;
     inline int64_t*    disableTime   = nullptr;
     inline bool        disableStdout = false;
+    inline bool        trace         = false;
+
+    void               init(const std::string& IS);
+    template <typename... Args>
+    void log(LogLevel level, std::format_string<Args...> fmt, Args&&... args) {
+        if (disableLogs && *disableLogs)
+            return;
+
+        if (level == TRACE && !trace)
+            return;
+
+        std::string logMsg = "";
+
+        switch (level) {
+            case LOG: logMsg += "[LOG] "; break;
+            case WARN: logMsg += "[WARN] "; break;
+            case ERR: logMsg += "[ERR] "; break;
+            case CRIT: logMsg += "[CRITICAL] "; break;
+            case INFO: logMsg += "[INFO] "; break;
+            case TRACE: logMsg += "[TRACE] "; break;
+            default: break;
+        }
+
+        // log to a file
+        std::ofstream ofs;
+        ofs.open(logFile, std::ios::out | std::ios::app);
+
+        // print date and time to the ofs
+        if (disableTime && !*disableTime) {
+#ifndef _LIBCPP_VERSION
+            logMsg += std::format("[{:%T}] ", std::chrono::hh_mm_ss{std::chrono::system_clock::now() - std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())});
+#else
+            auto c = std::chrono::hh_mm_ss{std::chrono::system_clock::now() - std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now())};
+            logMsg += std::format("{:%H}:{:%M}:{:%S}", c.hours(), c.minutes(), c.subseconds());
+
+#endif
+        }
+
+        // no need for try {} catch {} because std::format_string<Args...> ensures that vformat never throw std::format_error
+        // because
+        // 1. any faulty format specifier that sucks will cause a compilation error.
+        // 2. and `std::bad_alloc` is catastrophic, (Almost any operation in stdlib could throw this.)
+        // 3. this is actually what std::format in stdlib does
+        logMsg += std::vformat(fmt.get(), std::make_format_args(args...));
+
+        ofs << logMsg << "\n";
+
+        ofs.close();
+
+        // log it to the stdout too.
+        if (!disableStdout)
+            std::cout << logMsg << "\n";
+    }
+
+    void wlrLog(wlr_log_importance level, const char* fmt, va_list args);
 };

src/debug/TracyDefines.hpp

@@ -16,7 +16,7 @@ inline PFNGLGETQUERYOBJECTUI64VEXTPROC glGetQueryObjectui64v;
 inline void loadGLProc(void* pProc, const char* name) {
     void* proc = (void*)eglGetProcAddress(name);
     if (proc == NULL) {
-        Debug::log(CRIT, "[Tracy GPU Profiling] eglGetProcAddress(%s) failed", name);
+        Debug::log(CRIT, "[Tracy GPU Profiling] eglGetProcAddress({}) failed", name);
         abort();
     }
     *(void**)pProc = proc;

src/defines.hpp

@@ -1,86 +1,5 @@
 #include "includes.hpp"
 #include "debug/Log.hpp"
-#include "helpers/MiscFunctions.hpp"
 #include "helpers/WLListener.hpp"
 #include "helpers/Color.hpp"
-
-#include <utility>
-
-#ifndef NDEBUG
-#ifdef HYPRLAND_DEBUG
-#define ISDEBUG true
-#else
-#define ISDEBUG false
-#endif
-#else
-#define ISDEBUG false
-#endif
-
-#define LISTENER(name)                                                                                                                                                             \
-    void               listener_##name(wl_listener*, void*);                                                                                                                       \
-    inline wl_listener listen_##name = {.notify = listener_##name}
-#define DYNLISTENFUNC(name)    void listener_##name(void*, void*)
-#define DYNLISTENER(name)      CHyprWLListener hyprListener_##name
-#define DYNMULTILISTENER(name) wl_listener listen_##name
-
-#define VECINRECT(vec, x1, y1, x2, y2) ((vec).x >= (x1) && (vec).x <= (x2) && (vec).y >= (y1) && (vec).y <= (y2))
-
-#define DELTALESSTHAN(a, b, delta) (abs((a) - (b)) < (delta))
-
-#define interface class
-
-#define STICKS(a, b) abs((a) - (b)) < 2
-
-#define ALPHA(c) ((double)(((c) >> 24) & 0xff) / 255.0)
-#define RED(c)   ((double)(((c) >> 16) & 0xff) / 255.0)
-#define GREEN(c) ((double)(((c) >> 8) & 0xff) / 255.0)
-#define BLUE(c)  ((double)(((c)) & 0xff) / 255.0)
-
-#define HYPRATOM(name)                                                                                                                                                             \
-    { name, 0 }
-
-#ifndef __INTELLISENSE__
-#define RASSERT(expr, reason, ...)                                                                                                                                                 \
-    if (!(expr)) {                                                                                                                                                                 \
-        Debug::log(CRIT, "\n==========================================================================================\nASSERTION FAILED! \n\n%s\n\nat: line %d in %s",            \
-                   getFormat(reason, ##__VA_ARGS__).c_str(), __LINE__,                                                                                                             \
-                   ([]() constexpr->std::string { return std::string(__FILE__).substr(std::string(__FILE__).find_last_of('/') + 1); })().c_str());                                 \
-        printf("Assertion failed! See the log in /tmp/hypr/hyprland.log for more info.");                                                                                          \
-        *((int*)nullptr) = 1; /* so that we crash and get a coredump */                                                                                                            \
-    }
-#else
-#define RASSERT(expr, reason, ...)
-#endif
-
-#define ASSERT(expr) RASSERT(expr, "?")
-
-#if ISDEBUG
-#define UNREACHABLE()                                                                                                                                                              \
-    {                                                                                                                                                                              \
-        Debug::log(CRIT, "\n\nMEMORY CORRUPTED: Unreachable failed! (Reached an unreachable position, memory corruption!!!)");                                                     \
-        *((int*)nullptr) = 1;                                                                                                                                                      \
-    }
-#else
-#define UNREACHABLE() std::unreachable();
-#endif
-
-// git stuff
-#ifndef GIT_COMMIT_HASH
-#define GIT_COMMIT_HASH "?"
-#endif
-#ifndef GIT_BRANCH
-#define GIT_BRANCH "?"
-#endif
-#ifndef GIT_COMMIT_MESSAGE
-#define GIT_COMMIT_MESSAGE "?"
-#endif
-#ifndef GIT_DIRTY
-#define GIT_DIRTY "?"
-#endif
-#ifndef GIT_TAG
-#define GIT_TAG "?"
-#endif
-
-#define SPECIAL_WORKSPACE_START (-99)
-
-#define PI 3.14159265358979
+#include "macros.hpp"

src/events/Devices.cpp

@@ -19,7 +19,7 @@ void Events::listener_keyboardDestroy(void* owner, void* data) {
     SKeyboard* PKEYBOARD = (SKeyboard*)owner;
     g_pInputManager->destroyKeyboard(PKEYBOARD);
 
-    Debug::log(LOG, "Destroyed keyboard %lx", PKEYBOARD);
+    Debug::log(LOG, "Destroyed keyboard {:x}", (uintptr_t)PKEYBOARD);
 }
 
 void Events::listener_keyboardKey(void* owner, void* data) {
@@ -63,30 +63,30 @@ void Events::listener_newInput(wl_listener* listener, void* data) {
 
     switch (DEVICE->type) {
         case WLR_INPUT_DEVICE_KEYBOARD:
-            Debug::log(LOG, "Attached a keyboard with name %s", DEVICE->name);
+            Debug::log(LOG, "Attached a keyboard with name {}", DEVICE->name);
             g_pInputManager->newKeyboard(DEVICE);
             break;
         case WLR_INPUT_DEVICE_POINTER:
-            Debug::log(LOG, "Attached a mouse with name %s", DEVICE->name);
+            Debug::log(LOG, "Attached a mouse with name {}", DEVICE->name);
             g_pInputManager->newMouse(DEVICE);
             break;
         case WLR_INPUT_DEVICE_TOUCH:
-            Debug::log(LOG, "Attached a touch device with name %s", DEVICE->name);
+            Debug::log(LOG, "Attached a touch device with name {}", DEVICE->name);
             g_pInputManager->newTouchDevice(DEVICE);
             break;
         case WLR_INPUT_DEVICE_TABLET_TOOL:
-            Debug::log(LOG, "Attached a tablet tool with name %s", DEVICE->name);
+            Debug::log(LOG, "Attached a tablet tool with name {}", DEVICE->name);
             g_pInputManager->newTabletTool(DEVICE);
             break;
         case WLR_INPUT_DEVICE_TABLET_PAD:
-            Debug::log(LOG, "Attached a tablet pad with name %s", DEVICE->name);
+            Debug::log(LOG, "Attached a tablet pad with name {}", DEVICE->name);
             g_pInputManager->newTabletPad(DEVICE);
             break;
         case WLR_INPUT_DEVICE_SWITCH:
-            Debug::log(LOG, "Attached a switch device with name %s", DEVICE->name);
+            Debug::log(LOG, "Attached a switch device with name {}", DEVICE->name);
             g_pInputManager->newSwitch(DEVICE);
             break;
-        default: Debug::log(WARN, "Unrecognized input device plugged in: %s", DEVICE->name); break;
+        default: Debug::log(WARN, "Unrecognized input device plugged in: {}", DEVICE->name); break;
     }
 
     g_pInputManager->updateCapabilities();
@@ -95,7 +95,7 @@ void Events::listener_newInput(wl_listener* listener, void* data) {
 void Events::listener_newConstraint(wl_listener* listener, void* data) {
     const auto PCONSTRAINT = (wlr_pointer_constraint_v1*)data;
 
-    Debug::log(LOG, "New mouse constraint at %lx", PCONSTRAINT);
+    Debug::log(LOG, "New mouse constraint at {:x}", (uintptr_t)PCONSTRAINT);
 
     g_pInputManager->m_lConstraints.emplace_back();
     const auto CONSTRAINT = &g_pInputManager->m_lConstraints.back();
@@ -122,24 +122,13 @@ void Events::listener_destroyConstraint(void* owner, void* data) {
 
         const auto PWINDOW = g_pCompositor->getConstraintWindow(g_pCompositor->m_sSeat.mouse);
 
-        if (PWINDOW && PCONSTRAINT->positionHint != Vector2D{-1, -1}) {
-            if (PWINDOW->m_bIsX11) {
-                wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, PCONSTRAINT->positionHint.x + PWINDOW->m_uSurface.xwayland->x,
-                                PWINDOW->m_uSurface.xwayland->y + PCONSTRAINT->positionHint.y);
-
-                wlr_seat_pointer_warp(PCONSTRAINT->constraint->seat, PCONSTRAINT->positionHint.x, PCONSTRAINT->positionHint.y);
-            } else {
-                wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, PCONSTRAINT->positionHint.x + PWINDOW->m_vRealPosition.vec().x,
-                                PCONSTRAINT->positionHint.y + PWINDOW->m_vRealPosition.vec().y);
-
-                wlr_seat_pointer_warp(PCONSTRAINT->constraint->seat, PCONSTRAINT->positionHint.x, PCONSTRAINT->positionHint.y);
-            }
-        }
+        if (PWINDOW && PCONSTRAINT->active && PCONSTRAINT->constraint->type == WLR_POINTER_CONSTRAINT_V1_LOCKED)
+            g_pInputManager->warpMouseToConstraintMiddle(PCONSTRAINT);
 
         PCONSTRAINT->pMouse->currentConstraint = nullptr;
     }
 
-    Debug::log(LOG, "Unconstrained mouse from %lx", PCONSTRAINT->constraint);
+    Debug::log(LOG, "Unconstrained mouse from {:x}", (uintptr_t)PCONSTRAINT->constraint);
 
     g_pInputManager->m_lConstraints.remove(*PCONSTRAINT);
 }

src/events/Events.hpp

@@ -39,6 +39,7 @@ namespace Events {
     DYNLISTENFUNC(destroyPopupXDG);
     DYNLISTENFUNC(commitPopupXDG);
     DYNLISTENFUNC(newPopupFromPopupXDG);
+    DYNLISTENFUNC(repositionPopupXDG);
 
     // Surface XDG (window)
     LISTENER(newXDGSurface);
@@ -173,4 +174,7 @@ namespace Events {
 
     // Cursor shape
     LISTENER(setCursorShape);
+
+    // Tearing hints
+    LISTENER(newTearingHint);
 };

src/events/Layers.cpp

@@ -26,7 +26,7 @@ void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
             return;
         }
 
-        Debug::log(LOG, "New LayerSurface has no preferred monitor. Assigning Monitor %s", PMONITOR->szName.c_str());
+        Debug::log(LOG, "New LayerSurface has no preferred monitor. Assigning Monitor {}", PMONITOR->szName);
 
         WLRLAYERSURFACE->output = PMONITOR->output;
     }
@@ -55,14 +55,14 @@ void Events::listener_newLayerSurface(wl_listener* listener, void* data) {
 
     layerSurface->forceBlur = g_pConfigManager->shouldBlurLS(layerSurface->szNamespace);
 
-    Debug::log(LOG, "LayerSurface %lx (namespace %s layer %d) created on monitor %s", layerSurface->layerSurface, layerSurface->layerSurface->_namespace, layerSurface->layer,
-               PMONITOR->szName.c_str());
+    Debug::log(LOG, "LayerSurface {:x} (namespace {} layer {}) created on monitor {}", (uintptr_t)layerSurface->layerSurface, layerSurface->layerSurface->_namespace,
+               (int)layerSurface->layer, PMONITOR->szName);
 }
 
 void Events::listener_destroyLayerSurface(void* owner, void* data) {
     SLayerSurface* layersurface = (SLayerSurface*)owner;
 
-    Debug::log(LOG, "LayerSurface %lx destroyed", layersurface->layerSurface);
+    Debug::log(LOG, "LayerSurface {:x} destroyed", (uintptr_t)layersurface->layerSurface);
 
     const auto PMONITOR = g_pCompositor->getMonitorFromID(layersurface->monitorID);
 
@@ -107,7 +107,7 @@ void Events::listener_destroyLayerSurface(void* owner, void* data) {
 void Events::listener_mapLayerSurface(void* owner, void* data) {
     SLayerSurface* layersurface = (SLayerSurface*)owner;
 
-    Debug::log(LOG, "LayerSurface %lx mapped", layersurface->layerSurface);
+    Debug::log(LOG, "LayerSurface {:x} mapped", (uintptr_t)layersurface->layerSurface);
 
     layersurface->mapped            = true;
     layersurface->keyboardExclusive = layersurface->layerSurface->current.keyboard_interactive;
@@ -142,8 +142,11 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
 
     wlr_surface_send_enter(layersurface->layerSurface->surface, layersurface->layerSurface->output);
 
-    if (layersurface->layerSurface->current.keyboard_interactive &&
-        (!g_pCompositor->m_sSeat.mouse || !g_pCompositor->m_sSeat.mouse->currentConstraint)) { // don't focus if constrained
+    const bool GRABSFOCUS = layersurface->layerSurface->current.keyboard_interactive &&
+        // don't focus if constrained
+        (!g_pCompositor->m_sSeat.mouse || !g_pCompositor->m_sSeat.mouse->currentConstraint);
+
+    if (GRABSFOCUS) {
         g_pCompositor->focusSurface(layersurface->layerSurface->surface);
 
         const auto LOCAL =
@@ -161,7 +164,7 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
     const bool FULLSCREEN = WORKSPACE->m_bHasFullscreenWindow && WORKSPACE->m_efFullscreenMode == FULLSCREEN_FULL;
 
     layersurface->alpha.setValue(0);
-    layersurface->alpha         = ((layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN) ? 0.f : 1.f);
+    layersurface->alpha         = ((layersurface->layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP && FULLSCREEN && !GRABSFOCUS) ? 0.f : 1.f);
     layersurface->readyToDelete = false;
     layersurface->fadingOut     = false;
 
@@ -174,7 +177,7 @@ void Events::listener_mapLayerSurface(void* owner, void* data) {
 void Events::listener_unmapLayerSurface(void* owner, void* data) {
     SLayerSurface* layersurface = (SLayerSurface*)owner;
 
-    Debug::log(LOG, "LayerSurface %lx unmapped", layersurface->layerSurface);
+    Debug::log(LOG, "LayerSurface {:x} unmapped", (uintptr_t)layersurface->layerSurface);
 
     g_pEventManager->postEvent(SHyprIPCEvent{"closelayer", std::string(layersurface->layerSurface->_namespace ? layersurface->layerSurface->_namespace : "")});
     EMIT_HOOK_EVENT("closeLayer", layersurface);

src/events/Misc.cpp

@@ -49,7 +49,7 @@ void Events::listener_readyXWayland(wl_listener* listener, void* data) {
     const auto XCBCONNECTION = xcb_connect(g_pXWaylandManager->m_sWLRXWayland->display_name, NULL);
     const auto ERR           = xcb_connection_has_error(XCBCONNECTION);
     if (ERR) {
-        Debug::log(LogLevel::ERR, "XWayland -> xcb_connection_has_error failed with %i", ERR);
+        Debug::log(LogLevel::ERR, "XWayland -> xcb_connection_has_error failed with {}", ERR);
         return;
     }
 
@@ -58,7 +58,7 @@ void Events::listener_readyXWayland(wl_listener* listener, void* data) {
         xcb_intern_atom_reply_t* reply  = xcb_intern_atom_reply(XCBCONNECTION, cookie, NULL);
 
         if (!reply) {
-            Debug::log(LogLevel::ERR, "XWayland -> Atom failed: %s", ATOM.first.c_str());
+            Debug::log(LogLevel::ERR, "XWayland -> Atom failed: {}", ATOM.first);
             continue;
         }
 
@@ -98,14 +98,14 @@ void Events::listener_startDrag(wl_listener* listener, void* data) {
 
     wlr_drag* wlrDrag = (wlr_drag*)data;
 
-    Debug::log(LOG, "Started drag %lx", wlrDrag);
+    Debug::log(LOG, "Started drag {:x}", (uintptr_t)wlrDrag);
 
     wlrDrag->data = data;
 
     g_pInputManager->m_sDrag.hyprListener_destroy.initCallback(&wlrDrag->events.destroy, &Events::listener_destroyDrag, &g_pInputManager->m_sDrag, "Drag");
 
     if (wlrDrag->icon) {
-        Debug::log(LOG, "Drag started with an icon %lx", wlrDrag->icon);
+        Debug::log(LOG, "Drag started with an icon {:x}", (uintptr_t)wlrDrag->icon);
 
         g_pInputManager->m_sDrag.dragIcon = wlrDrag->icon;
         wlrDrag->icon->data               = g_pInputManager->m_sDrag.dragIcon;
@@ -157,7 +157,7 @@ void Events::listener_commitDragIcon(void* owner, void* data) {
 }
 
 void Events::listener_InhibitActivate(wl_listener* listener, void* data) {
-    Debug::log(LOG, "Activated exclusive for %lx.", g_pCompositor->m_sSeat.exclusiveClient);
+    Debug::log(LOG, "Activated exclusive for {:x}.", (uintptr_t)g_pCompositor->m_sSeat.exclusiveClient);
 
     g_pInputManager->refocus();
     g_pCompositor->m_sSeat.exclusiveClient = g_pCompositor->m_sWLRInhibitMgr->active_client;
@@ -216,14 +216,14 @@ void Events::listener_newSessionLock(wl_listener* listener, void* data) {
 }
 
 void Events::listener_setGamma(wl_listener* listener, void* data) {
-    Debug::log(LOG, "New Gamma event at %lx", data);
+    Debug::log(LOG, "New Gamma event at {:x}", (uintptr_t)data);
 
     const auto E = (wlr_gamma_control_manager_v1_set_gamma_event*)data;
 
     const auto PMONITOR = g_pCompositor->getMonitorFromOutput(E->output);
 
     if (!PMONITOR) {
-        Debug::log(ERR, "Gamma event object references non-existent output %lx ?", E->output);
+        Debug::log(ERR, "Gamma event object references non-existent output {:x} ?", (uintptr_t)E->output);
         return;
     }
 
@@ -237,3 +237,43 @@ void Events::listener_setCursorShape(wl_listener* listener, void* data) {
 
     g_pInputManager->processMouseRequest(E);
 }
+
+void Events::listener_newTearingHint(wl_listener* listener, void* data) {
+    const auto TCTL = (wlr_tearing_control_v1*)data;
+
+    const auto PWINDOW = g_pCompositor->getWindowFromSurface(TCTL->surface);
+
+    if (!PWINDOW) {
+        Debug::log(ERR, "Tearing hint {} was attached to an unknown surface", (uintptr_t)data);
+        return;
+    }
+
+    Debug::log(LOG, "New tearing hint for window {} at {}", PWINDOW, (uintptr_t)data);
+
+    const auto NEWCTRL = g_pHyprRenderer->m_vTearingControllers.emplace_back(std::make_unique<STearingController>()).get();
+    NEWCTRL->pWlrHint  = (wlr_tearing_control_v1*)data;
+
+    NEWCTRL->hyprListener_destroy.initCallback(
+        &NEWCTRL->pWlrHint->events.destroy,
+        [&](void* owner, void* data) {
+            Debug::log(LOG, "Destroyed {} tearing hint", (uintptr_t)((STearingController*)owner)->pWlrHint);
+
+            std::erase_if(g_pHyprRenderer->m_vTearingControllers, [&](const auto& other) { return other.get() == owner; });
+        },
+        NEWCTRL, "TearingController");
+
+    NEWCTRL->hyprListener_set.initCallback(
+        &NEWCTRL->pWlrHint->events.set_hint,
+        [&](void* owner, void* data) {
+            const auto TEARINGHINT = (STearingController*)owner;
+
+            const auto PWINDOW = g_pCompositor->getWindowFromSurface(TEARINGHINT->pWlrHint->surface);
+
+            if (PWINDOW) {
+                PWINDOW->m_bTearingHint = TEARINGHINT->pWlrHint->hint;
+
+                Debug::log(LOG, "Hint {} (window {}) set tearing hint to {}", (uintptr_t)TEARINGHINT->pWlrHint, PWINDOW, (uint32_t)TEARINGHINT->pWlrHint->hint);
+            }
+        },
+        NEWCTRL, "TearingController");
+}

src/events/Monitors.cpp

@@ -38,8 +38,18 @@ void Events::listener_change(wl_listener* listener, void* data) {
 
         CONFIGHEAD->state.enabled = m->output->enabled;
         CONFIGHEAD->state.mode    = m->output->current_mode;
-        CONFIGHEAD->state.x       = m->vecPosition.x;
-        CONFIGHEAD->state.y       = m->vecPosition.y;
+        if (!m->output->current_mode) {
+            CONFIGHEAD->state.custom_mode = {
+                m->output->width,
+                m->output->height,
+                m->output->refresh,
+            };
+        }
+        CONFIGHEAD->state.x                     = m->vecPosition.x;
+        CONFIGHEAD->state.y                     = m->vecPosition.y;
+        CONFIGHEAD->state.transform             = m->transform;
+        CONFIGHEAD->state.scale                 = m->scale;
+        CONFIGHEAD->state.adaptive_sync_enabled = m->vrrActive;
     }
 
     wlr_output_manager_v1_set_configuration(g_pCompositor->m_sWLROutputMgr, CONFIG);
@@ -57,27 +67,15 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
         return;
     }
 
-    if (g_pCompositor->m_bUnsafeState) {
+    if (g_pCompositor->m_bUnsafeState)
         Debug::log(WARN, "Recovering from an unsafe state. May you be lucky.");
-    }
 
     // add it to real
     std::shared_ptr<CMonitor>* PNEWMONITORWRAP = nullptr;
 
-    for (auto& rm : g_pCompositor->m_vRealMonitors) {
-        if (rm->szName == OUTPUT->name) {
-            PNEWMONITORWRAP = &rm;
-            Debug::log(LOG, "Recovering a removed monitor.");
-            break;
-        }
-    }
+    PNEWMONITORWRAP = &g_pCompositor->m_vRealMonitors.emplace_back(std::make_shared<CMonitor>());
 
-    if (!PNEWMONITORWRAP) {
-        Debug::log(LOG, "Adding completely new monitor.");
-        PNEWMONITORWRAP = &g_pCompositor->m_vRealMonitors.emplace_back(std::make_shared<CMonitor>());
-
-        (*PNEWMONITORWRAP)->ID = g_pCompositor->getNextAvailableMonitorID(OUTPUT->name);
-    }
+    (*PNEWMONITORWRAP)->ID = g_pCompositor->getNextAvailableMonitorID(OUTPUT->name);
 
     const auto PNEWMONITOR = PNEWMONITORWRAP->get();
 
@@ -89,10 +87,31 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
     if ((!g_pHyprRenderer->m_pMostHzMonitor || PNEWMONITOR->refreshRate > g_pHyprRenderer->m_pMostHzMonitor->refreshRate) && PNEWMONITOR->m_bEnabled)
         g_pHyprRenderer->m_pMostHzMonitor = PNEWMONITOR;
 
-    // ready to process cuz we have a monitor
-    if (PNEWMONITOR->m_bEnabled) {
+    // wlroots will instantly call this handler before we get a return to the wlr_output* in CCompositor::enterUnsafeState
+    const bool PROBABLYFALLBACK = (g_pCompositor->m_bUnsafeState && !g_pCompositor->m_pUnsafeOutput) || OUTPUT == g_pCompositor->m_pUnsafeOutput;
+
+    // ready to process if we have a real monitor
+    if (PNEWMONITOR->m_bEnabled && !PROBABLYFALLBACK) {
+        // leave unsafe state
+        if (g_pCompositor->m_bUnsafeState) {
+            // recover workspaces
+            std::vector<CWorkspace*> wsp;
+            for (auto& ws : g_pCompositor->m_vWorkspaces) {
+                wsp.push_back(ws.get());
+            }
+            for (auto& ws : wsp) {
+                // because this can realloc the vec
+                g_pCompositor->moveWorkspaceToMonitor(ws, PNEWMONITOR);
+            }
+
+            g_pHyprRenderer->m_pMostHzMonitor = PNEWMONITOR;
+
+            const auto POS = PNEWMONITOR->middle();
+            if (g_pCompositor->m_sSeat.mouse)
+                wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, POS.x, POS.y);
+        }
+
         g_pCompositor->m_bReadyToProcess = true;
-        g_pCompositor->m_bUnsafeState    = false;
     }
 
     g_pConfigManager->m_bWantsMonitorReload = true;
@@ -100,7 +119,7 @@ void Events::listener_newOutput(wl_listener* listener, void* data) {
 
     if (firstLaunch) {
         firstLaunch    = false;
-        const auto POS = PNEWMONITOR->vecPosition + PNEWMONITOR->vecSize / 2.f;
+        const auto POS = PNEWMONITOR->middle();
         if (g_pCompositor->m_sSeat.mouse)
             wlr_cursor_warp(g_pCompositor->m_sWLRCursor, g_pCompositor->m_sSeat.mouse->mouse, POS.x, POS.y);
     } else {
@@ -119,8 +138,10 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     if ((g_pCompositor->m_sWLRSession && !g_pCompositor->m_sWLRSession->active) || !g_pCompositor->m_bSessionActive || g_pCompositor->m_bUnsafeState) {
         Debug::log(WARN, "Attempted to render frame on inactive session!");
 
-        if (g_pCompositor->m_bUnsafeState)
-            g_pConfigManager->performMonitorReload();
+        if (g_pCompositor->m_bUnsafeState && PMONITOR->output != g_pCompositor->m_pUnsafeOutput) {
+            // restore from unsafe state
+            g_pCompositor->leaveUnsafeState();
+        }
 
         return; // cannot draw on session inactive (different tty)
     }
@@ -128,12 +149,25 @@ void Events::listener_monitorFrame(void* owner, void* data) {
     if (!PMONITOR->m_bEnabled)
         return;
 
+    g_pHyprRenderer->recheckSolitaryForMonitor(PMONITOR);
+
+    PMONITOR->tearingState.busy = false;
+
+    if (PMONITOR->tearingState.activelyTearing && PMONITOR->solitaryClient /* can be invalidated by a recheck */) {
+
+        if (!PMONITOR->tearingState.frameScheduledWhileBusy)
+            return; // we did not schedule a frame yet to be displayed, but we are tearing. Why render?
+
+        PMONITOR->tearingState.nextRenderTorn          = true;
+        PMONITOR->tearingState.frameScheduledWhileBusy = false;
+    }
+
     static auto* const PENABLERAT = &g_pConfigManager->getConfigValuePtr("misc:render_ahead_of_time")->intValue;
     static auto* const PRATSAFE   = &g_pConfigManager->getConfigValuePtr("misc:render_ahead_safezone")->intValue;
 
     PMONITOR->lastPresentationTimer.reset();
 
-    if (*PENABLERAT) {
+    if (*PENABLERAT && !PMONITOR->tearingState.nextRenderTorn) {
         if (!PMONITOR->RATScheduled) {
             // render
             g_pHyprRenderer->renderMonitor(PMONITOR);
@@ -177,19 +211,19 @@ void Events::listener_monitorDestroy(void* owner, void* data) {
     if (!pMonitor)
         return;
 
-    Debug::log(LOG, "Destroy called for monitor %s", pMonitor->output->name);
+    Debug::log(LOG, "Destroy called for monitor {}", pMonitor->output->name);
 
     pMonitor->onDisconnect();
 
     pMonitor->output                 = nullptr;
     pMonitor->m_bRenderingInitPassed = false;
 
-    // cleanup if not unsafe
-    if (!g_pCompositor->m_bUnsafeState) {
-        Debug::log(LOG, "Removing monitor %s from realMonitors", pMonitor->szName.c_str());
+    if (g_pCompositor->m_pUnsafeOutput == OUTPUT)
+        g_pCompositor->m_pUnsafeOutput = nullptr;
 
-        std::erase_if(g_pCompositor->m_vRealMonitors, [&](std::shared_ptr<CMonitor>& el) { return el.get() == pMonitor; });
-    }
+    Debug::log(LOG, "Removing monitor {} from realMonitors", pMonitor->szName);
+
+    std::erase_if(g_pCompositor->m_vRealMonitors, [&](std::shared_ptr<CMonitor>& el) { return el.get() == pMonitor; });
 }
 
 void Events::listener_monitorStateRequest(void* owner, void* data) {

src/events/Popups.cpp

@@ -60,6 +60,7 @@ void createNewPopup(wlr_xdg_popup* popup, SXDGPopup* pHyprPopup) {
     pHyprPopup->hyprListener_unmapPopupXDG.initCallback(&popup->base->surface->events.unmap, &Events::listener_unmapPopupXDG, pHyprPopup, "HyprPopup");
     pHyprPopup->hyprListener_newPopupFromPopupXDG.initCallback(&popup->base->events.new_popup, &Events::listener_newPopupFromPopupXDG, pHyprPopup, "HyprPopup");
     pHyprPopup->hyprListener_commitPopupXDG.initCallback(&popup->base->surface->events.commit, &Events::listener_commitPopupXDG, pHyprPopup, "HyprPopup");
+    pHyprPopup->hyprListener_repositionPopupXDG.initCallback(&popup->events.reposition, &Events::listener_repositionPopupXDG, pHyprPopup, "HyprPopup");
 
     const auto PMONITOR = g_pCompositor->m_pLastMonitor;
 
@@ -69,8 +70,7 @@ void createNewPopup(wlr_xdg_popup* popup, SXDGPopup* pHyprPopup) {
 
     pHyprPopup->monitor = PMONITOR;
 
-    Debug::log(LOG, "Popup: Unconstrained from lx ly: %f %f, pHyprPopup lx ly: %f %f", (float)PMONITOR->vecPosition.x, (float)PMONITOR->vecPosition.y, (float)pHyprPopup->lx,
-               (float)pHyprPopup->ly);
+    Debug::log(LOG, "Popup: Unconstrained from lx ly: {:j5}, pHyprPopup lx ly: {:.5f} {:.5f}", PMONITOR->vecPosition, (float)pHyprPopup->lx, (float)pHyprPopup->ly);
 }
 
 void Events::listener_newPopup(void* owner, void* data) {
@@ -78,7 +78,7 @@ void Events::listener_newPopup(void* owner, void* data) {
 
     ASSERT(layersurface);
 
-    Debug::log(LOG, "New layer popup created from surface %lx", layersurface);
+    Debug::log(LOG, "New layer popup created from surface {:x}", (uintptr_t)layersurface);
 
     const auto WLRPOPUP = (wlr_xdg_popup*)data;
 
@@ -102,7 +102,7 @@ void Events::listener_newPopupXDG(void* owner, void* data) {
     if (!PWINDOW->m_bIsMapped)
         return;
 
-    Debug::log(LOG, "New layer popup created from XDG window %lx -> %s", PWINDOW, PWINDOW->m_szTitle.c_str());
+    Debug::log(LOG, "New layer popup created from XDG window {}", PWINDOW);
 
     const auto WLRPOPUP = (wlr_xdg_popup*)data;
 
@@ -124,9 +124,9 @@ void Events::listener_newPopupFromPopupXDG(void* owner, void* data) {
     ASSERT(PPOPUP);
 
     if (PPOPUP->parentWindow)
-        Debug::log(LOG, "New popup created from XDG Window popup %lx -> %s", PPOPUP, PPOPUP->parentWindow->m_szTitle.c_str());
+        Debug::log(LOG, "New popup created from XDG Window popup {:x} -> {}", (uintptr_t)PPOPUP, PPOPUP->parentWindow);
     else
-        Debug::log(LOG, "New popup created from Non-Window popup %lx", PPOPUP);
+        Debug::log(LOG, "New popup created from Non-Window popup {:x}", (uintptr_t)PPOPUP);
 
     const auto WLRPOPUP = (wlr_xdg_popup*)data;
 
@@ -147,7 +147,7 @@ void Events::listener_mapPopupXDG(void* owner, void* data) {
 
     ASSERT(PPOPUP);
 
-    Debug::log(LOG, "New XDG Popup mapped at %d %d", (int)PPOPUP->lx, (int)PPOPUP->ly);
+    Debug::log(LOG, "New XDG Popup mapped at {} {}", (int)PPOPUP->lx, (int)PPOPUP->ly);
 
     if (PPOPUP->parentWindow)
         PPOPUP->parentWindow->m_lPopupSurfaces.emplace_back(PPOPUP->popup->base->surface);
@@ -167,7 +167,22 @@ void Events::listener_mapPopupXDG(void* owner, void* data) {
     if (PPOPUP->monitor)
         g_pProtocolManager->m_pFractionalScaleProtocolManager->setPreferredScaleForSurface(PPOPUP->popup->base->surface, PPOPUP->monitor->scale);
 
-    Debug::log(LOG, "XDG Popup got assigned a surfaceTreeNode %lx", PPOPUP->pSurfaceTree);
+    Debug::log(LOG, "XDG Popup got assigned a surfaceTreeNode {:x}", (uintptr_t)PPOPUP->pSurfaceTree);
+}
+
+void Events::listener_repositionPopupXDG(void* owner, void* data) {
+    SXDGPopup* PPOPUP = (SXDGPopup*)owner;
+
+    Debug::log(LOG, "XDG Popup {:x} asks for a reposition", (uintptr_t)PPOPUP);
+
+    int lx = 0, ly = 0;
+    addPopupGlobalCoords(PPOPUP, &lx, &ly);
+
+    wlr_box extents;
+    wlr_surface_get_extends(PPOPUP->popup->base->surface, &extents);
+
+    PPOPUP->lastPos             = {lx - extents.x, ly - extents.y};
+    PPOPUP->repositionRequested = true;
 }
 
 void Events::listener_unmapPopupXDG(void* owner, void* data) {
@@ -207,9 +222,17 @@ void Events::listener_commitPopupXDG(void* owner, void* data) {
         PPOPUP->ly = PPOPUP->parentWindow->m_vRealPosition.vec().y;
     }
 
-    int        lx = 0, ly = 0;
+    int lx = 0, ly = 0;
     addPopupGlobalCoords(PPOPUP, &lx, &ly);
 
+    wlr_box extents;
+    wlr_surface_get_extends(PPOPUP->popup->base->surface, &extents);
+
+    if (PPOPUP->repositionRequested)
+        g_pHyprRenderer->damageBox(PPOPUP->lastPos.x, PPOPUP->lastPos.y, extents.width + 2, extents.height + 2);
+
+    PPOPUP->repositionRequested = false;
+
     g_pHyprRenderer->damageSurface(PPOPUP->popup->base->surface, lx, ly);
 }
 
@@ -218,7 +241,7 @@ void Events::listener_destroyPopupXDG(void* owner, void* data) {
 
     ASSERT(PPOPUP);
 
-    Debug::log(LOG, "Destroyed popup XDG %lx", PPOPUP);
+    Debug::log(LOG, "Destroyed popup XDG {:x}", (uintptr_t)PPOPUP);
 
     if (PPOPUP->pSurfaceTree) {
         SubsurfaceTree::destroySurfaceTree(PPOPUP->pSurfaceTree);

src/events/Windows.cpp

@@ -46,6 +46,7 @@ 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;
     static auto* const PSWALLOWEXREGEX = &g_pConfigManager->getConfigValuePtr("misc:swallow_exception_regex")->strValue;
+    static auto* const PNEWTAKESOVERFS = &g_pConfigManager->getConfigValuePtr("misc:new_window_takes_over_fullscreen")->intValue;
 
     auto               PMONITOR = g_pCompositor->m_pLastMonitor;
     const auto         PWORKSPACE =
@@ -111,14 +112,12 @@ void Events::listener_mapWindow(void* owner, void* data) {
     bool requestsMaximize       = false;
     bool overridingNoFullscreen = false;
     bool overridingNoMaximize   = false;
-    bool shouldFocus            = true;
-    bool workspaceSpecial       = false;
 
     PWINDOW->m_szInitialTitle = g_pXWaylandManager->getTitle(PWINDOW);
     PWINDOW->m_szInitialClass = g_pXWaylandManager->getAppIDClass(PWINDOW);
 
     for (auto& r : WINDOWRULES) {
-        if (r.szRule.find("monitor") == 0) {
+        if (r.szRule.starts_with("monitor")) {
             try {
                 const auto MONITORSTR = removeBeginEndSpacesTabs(r.szRule.substr(r.szRule.find(' ')));
 
@@ -136,21 +135,23 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         if (PMONITOR)
                             PWINDOW->m_iMonitorID = PMONITOR->ID;
                         else {
-                            Debug::log(ERR, "No monitor in monitor %s rule", MONITORSTR.c_str());
+                            Debug::log(ERR, "No monitor in monitor {} rule", MONITORSTR);
                             continue;
                         }
                     }
                 }
 
-                PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID)->activeWorkspace;
+                const auto PMONITORFROMID = g_pCompositor->getMonitorFromID(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);
+                    PMONITOR = PMONITORFROMID;
                 }
+                PWINDOW->m_iWorkspaceID = PMONITOR->specialWorkspaceID ? PMONITOR->specialWorkspaceID : PMONITOR->activeWorkspace;
 
-                Debug::log(ERR, "Rule monitor, applying to window %lx -> mon: %i, workspace: %i", PWINDOW, PWINDOW->m_iMonitorID, PWINDOW->m_iWorkspaceID);
-            } catch (std::exception& e) { Debug::log(ERR, "Rule monitor failed, rule: %s -> %s | err: %s", r.szRule.c_str(), r.szValue.c_str(), e.what()); }
-        } else if (r.szRule.find("workspace") == 0) {
+                Debug::log(LOG, "Rule monitor, applying to {:mw}", PWINDOW);
+            } catch (std::exception& e) { Debug::log(ERR, "Rule monitor failed, rule: {} -> {} | err: {}", r.szRule, r.szValue, e.what()); }
+        } else if (r.szRule.starts_with("workspace")) {
             // check if it isnt unset
             const auto WORKSPACERQ = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
 
@@ -165,20 +166,20 @@ void Events::listener_mapWindow(void* owner, void* data) {
             if (JUSTWORKSPACE == PWORKSPACE->m_szName || JUSTWORKSPACE == "name:" + PWORKSPACE->m_szName)
                 requestedWorkspace = "";
 
-            Debug::log(LOG, "Rule workspace matched by window %lx, %s applied.", PWINDOW, r.szValue.c_str());
-        } else if (r.szRule.find("float") == 0) {
+            Debug::log(LOG, "Rule workspace matched by {}, {} applied.", PWINDOW, r.szValue);
+        } else if (r.szRule.starts_with("float")) {
             PWINDOW->m_bIsFloating = true;
-        } else if (r.szRule.find("tile") == 0) {
+        } else if (r.szRule.starts_with("tile")) {
             PWINDOW->m_bIsFloating = false;
-        } else if (r.szRule.find("pseudo") == 0) {
+        } else if (r.szRule.starts_with("pseudo")) {
             PWINDOW->m_bIsPseudotiled = true;
-        } else if (r.szRule.find("nofocus") == 0) {
+        } else if (r.szRule.starts_with("nofocus")) {
             PWINDOW->m_bNoFocus = true;
-        } else if (r.szRule.find("noinitialfocus") == 0) {
+        } else if (r.szRule.starts_with("noinitialfocus")) {
             PWINDOW->m_bNoInitialFocus = true;
-        } else if (r.szRule.find("nofullscreenrequest") == 0) {
+        } else if (r.szRule.starts_with("nofullscreenrequest")) {
             PWINDOW->m_bNoFullscreenRequest = true;
-        } else if (r.szRule.find("nomaximizerequest") == 0) {
+        } else if (r.szRule.starts_with("nomaximizerequest")) {
             PWINDOW->m_bNoMaximizeRequest = true;
         } else if (r.szRule == "fullscreen") {
             requestsFullscreen     = true;
@@ -198,7 +199,54 @@ void Events::listener_mapWindow(void* owner, void* data) {
             overridingNoMaximize = true;
         } else if (r.szRule == "stayfocused") {
             PWINDOW->m_bStayFocused = true;
-        } else if (r.szRule.find("idleinhibit") == 0) {
+        } else if (r.szRule.starts_with("group")) {
+            if (PWINDOW->m_eGroupRules & GROUP_OVERRIDE)
+                continue;
+
+            // `group` is a shorthand of `group set`
+            if (removeBeginEndSpacesTabs(r.szRule) == "group") {
+                PWINDOW->m_eGroupRules |= GROUP_SET;
+                continue;
+            }
+
+            CVarList    vars(r.szRule, 0, 's');
+            std::string vPrev = "";
+
+            for (auto const& v : vars) {
+                if (v == "group")
+                    continue;
+
+                if (v == "set") {
+                    PWINDOW->m_eGroupRules |= GROUP_SET;
+                } else if (v == "new") {
+                    // shorthand for `group barred set`
+                    PWINDOW->m_eGroupRules |= (GROUP_SET | GROUP_BARRED);
+                } else if (v == "lock") {
+                    PWINDOW->m_eGroupRules |= GROUP_LOCK;
+                } else if (v == "invade") {
+                    PWINDOW->m_eGroupRules |= GROUP_INVADE;
+                } else if (v == "barred") {
+                    PWINDOW->m_eGroupRules |= GROUP_BARRED;
+                } else if (v == "deny") {
+                    PWINDOW->m_sGroupData.deny = true;
+                } else if (v == "override") {
+                    // Clear existing rules
+                    PWINDOW->m_eGroupRules = GROUP_OVERRIDE;
+                } else if (v == "unset") {
+                    // Clear existing rules and stop processing
+                    PWINDOW->m_eGroupRules = GROUP_OVERRIDE;
+                    break;
+                } else if (v == "always") {
+                    if (vPrev == "set" || vPrev == "group")
+                        PWINDOW->m_eGroupRules |= GROUP_SET_ALWAYS;
+                    else if (vPrev == "lock")
+                        PWINDOW->m_eGroupRules |= GROUP_LOCK_ALWAYS;
+                    else
+                        Debug::log(ERR, "windowrule `group` does not support `{} always`", vPrev);
+                }
+                vPrev = v;
+            }
+        } else if (r.szRule.starts_with("idleinhibit")) {
             auto IDLERULE = r.szRule.substr(r.szRule.find_first_of(' ') + 1);
 
             if (IDLERULE == "none") {
@@ -210,89 +258,49 @@ void Events::listener_mapWindow(void* owner, void* data) {
             } else if (IDLERULE == "fullscreen") {
                 PWINDOW->m_eIdleInhibitMode = IDLEINHIBIT_FULLSCREEN;
             } else {
-                Debug::log(ERR, "Rule idleinhibit: unknown mode %s", IDLERULE.c_str());
+                Debug::log(ERR, "Rule idleinhibit: unknown mode {}", IDLERULE);
             }
         }
         PWINDOW->applyDynamicRule(r);
     }
 
-    CWindow* pFullscreenWindow = nullptr;
-    if (PWORKSPACE->m_bHasFullscreenWindow && !PWINDOW->m_bIsFloating) {
-        const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
-        pFullscreenWindow      = PFULLWINDOW;
-        g_pCompositor->setWindowFullscreen(PFULLWINDOW, false, PWORKSPACE->m_efFullscreenMode);
-    }
+    PWINDOW->updateSpecialRenderData();
 
     // disallow tiled pinned
     if (PWINDOW->m_bPinned && !PWINDOW->m_bIsFloating)
         PWINDOW->m_bPinned = false;
 
-    if (requestedWorkspace != "") {
-        // process requested workspace
-        if (requestedWorkspace.contains(' ')) {
-            // check for silent
-            if (requestedWorkspace.contains("silent")) {
+    const CVarList WORKSPACEARGS = CVarList(requestedWorkspace, 0, ' ');
+
+    if (!WORKSPACEARGS[0].empty()) {
+        if (WORKSPACEARGS[WORKSPACEARGS.size() - 1].starts_with("silent"))
+            workspaceSilent = true;
+
+        std::string requestedWorkspaceName;
+        const int   REQUESTEDWORKSPACEID = getWorkspaceIDFromString(WORKSPACEARGS.join(" ", 0, workspaceSilent ? WORKSPACEARGS.size() - 1 : 0), requestedWorkspaceName);
+
+        if (REQUESTEDWORKSPACEID != INT_MAX) {
+            auto pWorkspace = g_pCompositor->getWorkspaceByID(REQUESTEDWORKSPACEID);
+
+            if (!pWorkspace)
+                pWorkspace = g_pCompositor->createNewWorkspace(REQUESTEDWORKSPACEID, PWINDOW->m_iMonitorID, requestedWorkspaceName);
+
+            PWINDOW->m_iWorkspaceID = pWorkspace->m_iID;
+            PWINDOW->m_iMonitorID   = pWorkspace->m_iMonitorID;
+
+            if (g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID)->specialWorkspaceID && !pWorkspace->m_bIsSpecialWorkspace)
                 workspaceSilent = true;
-                shouldFocus     = false;
 
-                requestedWorkspace = requestedWorkspace.substr(0, requestedWorkspace.find_first_of(' '));
+            if (!workspaceSilent) {
+                if (pWorkspace->m_bIsSpecialWorkspace)
+                    g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID)->setSpecialWorkspace(pWorkspace);
+                else
+                    g_pKeybindManager->m_mDispatchers["workspace"](requestedWorkspaceName);
+
+                PMONITOR = g_pCompositor->m_pLastMonitor;
             }
-
-            if (!shouldFocus && requestedWorkspace == std::to_string(PMONITOR->activeWorkspace))
-                shouldFocus = true;
-        }
-
-        if (requestedWorkspace.find("special") == 0) {
-            workspaceSpecial = true;
-            workspaceSilent  = true;
-        }
-
-        if (!workspaceSilent) {
-            g_pKeybindManager->m_mDispatchers["workspace"](requestedWorkspace);
-
-            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;
-        }
+        } else
+            workspaceSilent = false;
     }
 
     if (PWINDOW->m_bIsFloating) {
@@ -301,7 +309,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
         // size and move rules
         for (auto& r : WINDOWRULES) {
-            if (r.szRule.find("size") == 0) {
+            if (r.szRule.starts_with("size")) {
                 try {
                     const auto VALUE    = r.szRule.substr(r.szRule.find(' ') + 1);
                     const auto SIZEXSTR = VALUE.substr(0, VALUE.find(' '));
@@ -316,14 +324,14 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         std::clamp(MAXSIZE.y, 20.0, PMONITOR->vecSize.y) :
                         (!SIZEYSTR.contains('%') ? std::stoi(SIZEYSTR) : std::stof(SIZEYSTR.substr(0, SIZEYSTR.length() - 1)) * 0.01 * PMONITOR->vecSize.y);
 
-                    Debug::log(LOG, "Rule size, applying to window %lx", PWINDOW);
+                    Debug::log(LOG, "Rule size, applying to {}", PWINDOW);
 
                     PWINDOW->m_vRealSize = Vector2D(SIZEX, SIZEY);
                     g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
 
                     PWINDOW->setHidden(false);
-                } catch (...) { Debug::log(LOG, "Rule size failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str()); }
-            } else if (r.szRule.find("minsize") == 0) {
+                } catch (...) { Debug::log(LOG, "Rule size failed, rule: {} -> {}", r.szRule, r.szValue); }
+            } else if (r.szRule.starts_with("minsize")) {
                 try {
                     const auto VALUE    = r.szRule.substr(r.szRule.find(' ') + 1);
                     const auto SIZEXSTR = VALUE.substr(0, VALUE.find(' '));
@@ -336,8 +344,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     g_pXWaylandManager->setWindowSize(PWINDOW, PWINDOW->m_vRealSize.goalv());
 
                     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("maxsize") == 0) {
+                } catch (...) { Debug::log(LOG, "Rule minsize failed, rule: {} -> {}", r.szRule, r.szValue); }
+            } else if (r.szRule.starts_with("maxsize")) {
                 try {
                     const auto VALUE    = r.szRule.substr(r.szRule.find(' ') + 1);
                     const auto SIZEXSTR = VALUE.substr(0, VALUE.find(' '));
@@ -350,12 +358,17 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     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) {
+                } catch (...) { Debug::log(LOG, "Rule maxsize failed, rule: {} -> {}", r.szRule, r.szValue); }
+            } else if (r.szRule.starts_with("move")) {
                 try {
                     auto       value = r.szRule.substr(r.szRule.find(' ') + 1);
 
-                    const bool CURSOR = value.find("cursor") == 0;
+                    const bool ONSCREEN = value.starts_with("onscreen");
+
+                    if (ONSCREEN)
+                        value = value.substr(value.find_first_of(' ') + 1);
+
+                    const bool CURSOR = value.starts_with("cursor");
 
                     if (CURSOR)
                         value = value.substr(value.find_first_of(' ') + 1);
@@ -366,9 +379,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
                     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);
+                    if (POSXSTR.starts_with("100%-")) {
+                        const auto POSXRAW = POSXSTR.substr(5);
                         posX =
                             PMONITOR->vecSize.x - (!POSXRAW.contains('%') ? std::stoi(POSXRAW) : std::stof(POSXRAW.substr(0, POSXRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.x);
 
@@ -386,9 +398,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         }
                     }
 
-                    if (POSYSTR.find("100%-") == 0) {
-                        const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
-                        const auto POSYRAW  = POSYSTR.substr(5);
+                    if (POSYSTR.starts_with("100%-")) {
+                        const auto POSYRAW = POSYSTR.substr(5);
                         posY =
                             PMONITOR->vecSize.y - (!POSYRAW.contains('%') ? std::stoi(POSYRAW) : std::stof(POSYRAW.substr(0, POSYRAW.length() - 1)) * 0.01 * PMONITOR->vecSize.y);
 
@@ -406,14 +417,29 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         }
                     }
 
-                    Debug::log(LOG, "Rule move, applying to window %lx", PWINDOW);
+                    if (ONSCREEN) {
+                        int borderSize = PWINDOW->getRealBorderSize();
+
+                        posX = std::clamp(posX, (int)(PMONITOR->vecReservedTopLeft.x + borderSize),
+                                          (int)(PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PWINDOW->m_vRealSize.goalv().x - borderSize));
+
+                        posY = std::clamp(posY, (int)(PMONITOR->vecReservedTopLeft.y + borderSize),
+                                          (int)(PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PWINDOW->m_vRealSize.goalv().y - borderSize));
+                    }
+
+                    Debug::log(LOG, "Rule move, applying to {}", PWINDOW);
 
                     PWINDOW->m_vRealPosition = Vector2D(posX, posY) + PMONITOR->vecPosition;
 
                     PWINDOW->setHidden(false);
-                } catch (...) { Debug::log(LOG, "Rule move failed, rule: %s -> %s", r.szRule.c_str(), r.szValue.c_str()); }
-            } else if (r.szRule == "center") {
-                PWINDOW->m_vRealPosition = PMONITOR->vecPosition + PMONITOR->vecSize / 2.f - PWINDOW->m_vRealSize.goalv() / 2.f;
+                } catch (...) { Debug::log(LOG, "Rule move failed, rule: {} -> {}", r.szRule, r.szValue); }
+            } else if (r.szRule.starts_with("center")) {
+                auto       RESERVEDOFFSET = Vector2D();
+                const auto ARGS           = CVarList(r.szRule, 2, ' ');
+                if (ARGS[1] == "1")
+                    RESERVEDOFFSET = (PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight) / 2.f;
+
+                PWINDOW->m_vRealPosition = PMONITOR->middle() - PWINDOW->m_vRealSize.goalv() / 2.f + RESERVEDOFFSET;
             }
         }
 
@@ -421,7 +447,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
         // because the windows are animated on RealSize
         PWINDOW->m_vPseudoSize = PWINDOW->m_vRealSize.goalv();
 
-        g_pCompositor->moveWindowToTop(PWINDOW);
+        g_pCompositor->changeWindowZOrder(PWINDOW, true);
     } else {
         g_pLayoutManager->getCurrentLayout()->onWindowCreated(PWINDOW);
 
@@ -442,6 +468,14 @@ void Events::listener_mapWindow(void* owner, void* data) {
     const auto PLSFROMFOCUS = g_pCompositor->getLayerSurfaceFromSurface(g_pCompositor->m_pLastFocus);
     if (PLSFROMFOCUS && PLSFROMFOCUS->layerSurface->current.keyboard_interactive)
         PWINDOW->m_bNoInitialFocus = true;
+    if (PWORKSPACE->m_bHasFullscreenWindow && !requestsFullscreen) {
+        if (*PNEWTAKESOVERFS == 0)
+            PWINDOW->m_bNoInitialFocus = true;
+        else if (*PNEWTAKESOVERFS == 2)
+            g_pCompositor->setWindowFullscreen(g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID), false, FULLSCREEN_INVALID);
+        else
+            requestsFullscreen = true;
+    }
 
     if (!PWINDOW->m_bNoFocus && !PWINDOW->m_bNoInitialFocus &&
         (PWINDOW->m_iX11Type != 2 || (PWINDOW->m_bIsX11 && wlr_xwayland_or_surface_wants_focus(PWINDOW->m_uSurface.xwayland))) && !workspaceSilent &&
@@ -454,7 +488,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
         PWINDOW->m_fDimPercent.setValueAndWarp(0);
     }
 
-    Debug::log(LOG, "Window got assigned a surfaceTreeNode %lx", PWINDOW->m_pSurfaceTree);
+    Debug::log(LOG, "Window got assigned a surfaceTreeNode {:x}", (uintptr_t)PWINDOW->m_pSurfaceTree);
 
     if (!PWINDOW->m_bIsX11) {
         PWINDOW->hyprListener_commitWindow.initCallback(&PWINDOW->m_uSurface.xdg->surface->events.commit, &Events::listener_commitWindow, PWINDOW, "XDG Window Late");
@@ -511,10 +545,6 @@ void Events::listener_mapWindow(void* owner, void* data) {
         }
     }
 
-    if (pFullscreenWindow && workspaceSilent) {
-        g_pCompositor->setWindowFullscreen(pFullscreenWindow, true, PWORKSPACE->m_efFullscreenMode);
-    }
-
     // recheck idle inhibitors
     g_pInputManager->recheckIdleInhibitorStatus();
 
@@ -522,7 +552,7 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
     PWINDOW->updateToplevel();
 
-    if (!shouldFocus) {
+    if (workspaceSilent) {
         if (g_pCompositor->windowValidMapped(PFOCUSEDWINDOWPREV)) {
             g_pCompositor->focusWindow(PFOCUSEDWINDOWPREV);
             PFOCUSEDWINDOWPREV->updateWindowDecos(); // need to for some reason i cba to find out why
@@ -592,6 +622,8 @@ void Events::listener_mapWindow(void* owner, void* data) {
                         g_pLayoutManager->getCurrentLayout()->onWindowRemoved(finalFound);
 
                         finalFound->setHidden(true);
+
+                        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PWINDOW->m_iMonitorID);
                     }
                 }
             }
@@ -600,16 +632,17 @@ void Events::listener_mapWindow(void* owner, void* data) {
 
     PWINDOW->m_bFirstMap = false;
 
-    Debug::log(LOG, "Map request dispatched, monitor %s, xywh: %f %f %f %f", PMONITOR->szName.c_str(), PWINDOW->m_vRealPosition.goalv().x, PWINDOW->m_vRealPosition.goalv().y,
-               PWINDOW->m_vRealSize.goalv().x, PWINDOW->m_vRealSize.goalv().y);
+    Debug::log(LOG, "Map request dispatched, monitor {}, window pos: {:5j}, window size: {:5j}", PMONITOR->szName, PWINDOW->m_vRealPosition.goalv(), PWINDOW->m_vRealSize.goalv());
 
     auto workspaceID = requestedWorkspace != "" ? requestedWorkspace : PWORKSPACE->m_szName;
-    g_pEventManager->postEvent(
-        SHyprIPCEvent{"openwindow", getFormat("%lx,%s,%s,%s", PWINDOW, workspaceID.c_str(), g_pXWaylandManager->getAppIDClass(PWINDOW).c_str(), PWINDOW->m_szTitle.c_str())});
+    g_pEventManager->postEvent(SHyprIPCEvent{"openwindow", std::format("{:x},{},{},{}", PWINDOW, workspaceID, g_pXWaylandManager->getAppIDClass(PWINDOW), PWINDOW->m_szTitle)});
     EMIT_HOOK_EVENT("openWindow", PWINDOW);
 
     // recalc the values for this window
     g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
+    // avoid this window being visible
+    if (PWORKSPACE->m_bHasFullscreenWindow && !PWINDOW->m_bIsFullscreen && !PWINDOW->m_bIsFloating)
+        PWINDOW->m_fAlpha.setValueAndWarp(0.f);
 
     g_pProtocolManager->m_pFractionalScaleProtocolManager->setPreferredScaleForSurface(PWINDOW->m_pWLSurface.wlr(), PMONITOR->scale);
 }
@@ -617,15 +650,15 @@ void Events::listener_mapWindow(void* owner, void* data) {
 void Events::listener_unmapWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
-    Debug::log(LOG, "Window %lx unmapped (class %s)", PWINDOW, g_pXWaylandManager->getAppIDClass(PWINDOW).c_str());
+    Debug::log(LOG, "{:c} unmapped", PWINDOW);
 
     if (!PWINDOW->m_pWLSurface.exists() || !PWINDOW->m_bIsMapped) {
-        Debug::log(WARN, "Window %lx unmapped without being mapped??", PWINDOW);
+        Debug::log(WARN, "{} unmapped without being mapped??", PWINDOW);
         PWINDOW->m_bFadingOut = false;
         return;
     }
 
-    g_pEventManager->postEvent(SHyprIPCEvent{"closewindow", getFormat("%lx", PWINDOW)});
+    g_pEventManager->postEvent(SHyprIPCEvent{"closewindow", std::format("{:x}", PWINDOW)});
     EMIT_HOOK_EVENT("closeWindow", PWINDOW);
 
     g_pProtocolManager->m_pToplevelExportProtocolManager->onWindowUnmap(PWINDOW);
@@ -650,8 +683,14 @@ void Events::listener_unmapWindow(void* owner, void* data) {
         PWINDOW->hyprListener_requestMinimize.removeCallback();
     }
 
-    if (PWINDOW->m_bIsFullscreen) {
+    if (PWINDOW->m_bIsFullscreen)
         g_pCompositor->setWindowFullscreen(PWINDOW, false, FULLSCREEN_FULL);
+
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+    if (PMONITOR) {
+        PWINDOW->m_vOriginalClosedPos     = PWINDOW->m_vRealPosition.vec() - PMONITOR->vecPosition;
+        PWINDOW->m_vOriginalClosedSize    = PWINDOW->m_vRealSize.vec();
+        PWINDOW->m_eOriginalClosedExtents = PWINDOW->getFullWindowExtents();
     }
 
     // Allow the renderer to catch the last frame.
@@ -691,21 +730,27 @@ void Events::listener_unmapWindow(void* owner, void* data) {
     if (wasLastWindow) {
         const auto PWINDOWCANDIDATE = g_pLayoutManager->getCurrentLayout()->getNextWindowCandidate(PWINDOW);
 
-        Debug::log(LOG, "On closed window, new focused candidate is %lx", PWINDOWCANDIDATE);
+        Debug::log(LOG, "On closed window, new focused candidate is {}", PWINDOWCANDIDATE);
 
         if (PWINDOWCANDIDATE != g_pCompositor->m_pLastWindow) {
             if (!PWINDOWCANDIDATE)
                 g_pInputManager->simulateMouseMovement();
             else
                 g_pCompositor->focusWindow(PWINDOWCANDIDATE);
-        } else {
+        } else
             g_pInputManager->simulateMouseMovement();
+
+        // CWindow::onUnmap will remove this window's active status, but we can't really do it above.
+        if (PWINDOW == g_pCompositor->m_pLastWindow || !g_pCompositor->m_pLastWindow) {
+            g_pEventManager->postEvent(SHyprIPCEvent{"activewindow", ","});
+            g_pEventManager->postEvent(SHyprIPCEvent{"activewindowv2", ","});
+            EMIT_HOOK_EVENT("activeWindow", (CWindow*)nullptr);
         }
     } else {
         Debug::log(LOG, "Unmapped was not focused, ignoring a refocus.");
     }
 
-    Debug::log(LOG, "Destroying the SubSurface tree of unmapped window %lx", PWINDOW);
+    Debug::log(LOG, "Destroying the SubSurface tree of unmapped window {}", PWINDOW);
     SubsurfaceTree::destroySurfaceTree(PWINDOW->m_pSurfaceTree);
 
     PWINDOW->m_pSurfaceTree = nullptr;
@@ -716,14 +761,6 @@ void Events::listener_unmapWindow(void* owner, void* data) {
 
     g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID));
 
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
-
-    // do the animation thing
-    if (PMONITOR) {
-        PWINDOW->m_vOriginalClosedPos  = PWINDOW->m_vRealPosition.vec() - PMONITOR->vecPosition;
-        PWINDOW->m_vOriginalClosedSize = PWINDOW->m_vRealSize.vec();
-    }
-
     if (!PWINDOW->m_bX11DoesntWantBorders)                                                  // don't animate out if they weren't animated in.
         PWINDOW->m_vRealPosition = PWINDOW->m_vRealPosition.vec() + Vector2D(0.01f, 0.01f); // it has to be animated, otherwise onWindowPostCreateClose will ignore it
 
@@ -780,10 +817,10 @@ void Events::listener_commitWindow(void* owner, void* data) {
 void Events::listener_destroyWindow(void* owner, void* data) {
     CWindow* PWINDOW = (CWindow*)owner;
 
-    Debug::log(LOG, "Window %lx destroyed, queueing. (class %s)", PWINDOW, g_pXWaylandManager->getAppIDClass(PWINDOW).c_str());
+    Debug::log(LOG, "{:c} destroyed, queueing.", PWINDOW);
 
     if (PWINDOW->m_bIsX11)
-        Debug::log(LOG, "XWayland class raw: %s", PWINDOW->m_uSurface.xwayland->_class);
+        Debug::log(LOG, "XWayland class raw: {}", PWINDOW->m_uSurface.xwayland->_class ? PWINDOW->m_uSurface.xwayland->_class : "null");
 
     if (PWINDOW == g_pCompositor->m_pLastWindow) {
         g_pCompositor->m_pLastWindow = nullptr;
@@ -801,7 +838,7 @@ void Events::listener_destroyWindow(void* owner, void* data) {
     g_pLayoutManager->getCurrentLayout()->onWindowRemoved(PWINDOW);
 
     if (PWINDOW->m_pSurfaceTree) {
-        Debug::log(LOG, "Destroying Subsurface tree of %lx in destroyWindow", PWINDOW);
+        Debug::log(LOG, "Destroying Subsurface tree of {} in destroyWindow", PWINDOW);
         SubsurfaceTree::destroySurfaceTree(PWINDOW->m_pSurfaceTree);
         PWINDOW->m_pSurfaceTree = nullptr;
     }
@@ -810,7 +847,7 @@ void Events::listener_destroyWindow(void* owner, void* data) {
 
     if (!PWINDOW->m_bFadingOut) {
         g_pCompositor->removeWindowFromVectorSafe(PWINDOW); // most likely X11 unmanaged or sumn
-        Debug::log(LOG, "Unmapped window %lx removed instantly", PWINDOW);
+        Debug::log(LOG, "Unmapped {} removed instantly", PWINDOW);
     }
 }
 
@@ -821,12 +858,12 @@ void Events::listener_setTitleWindow(void* owner, void* data) {
         return;
 
     PWINDOW->m_szTitle = g_pXWaylandManager->getTitle(PWINDOW);
-    g_pEventManager->postEvent(SHyprIPCEvent{"windowtitle", getFormat("%lx", PWINDOW)});
+    g_pEventManager->postEvent(SHyprIPCEvent{"windowtitle", std::format("{:x}", (uintptr_t)PWINDOW)});
     EMIT_HOOK_EVENT("windowTitle", PWINDOW);
 
     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});
-        g_pEventManager->postEvent(SHyprIPCEvent{"activewindowv2", getFormat("%lx", PWINDOW)});
+        g_pEventManager->postEvent(SHyprIPCEvent{"activewindowv2", std::format("{:x}", (uintptr_t)PWINDOW)});
         EMIT_HOOK_EVENT("activeWindow", PWINDOW);
     }
 
@@ -834,7 +871,7 @@ void Events::listener_setTitleWindow(void* owner, void* data) {
     g_pCompositor->updateWindowAnimatedDecorationValues(PWINDOW);
     PWINDOW->updateToplevel();
 
-    Debug::log(LOG, "Window %lx set title to %s", PWINDOW, PWINDOW->m_szTitle.c_str());
+    Debug::log(LOG, "Window {:x} set title to {}", PWINDOW, PWINDOW->m_szTitle);
 }
 
 void Events::listener_fullscreenWindow(void* owner, void* data) {
@@ -893,7 +930,7 @@ void Events::listener_fullscreenWindow(void* owner, void* data) {
 
     PWINDOW->updateToplevel();
 
-    Debug::log(LOG, "Window %lx fullscreen to %i", PWINDOW, PWINDOW->m_bIsFullscreen);
+    Debug::log(LOG, "{} fullscreen to {}", PWINDOW, PWINDOW->m_bIsFullscreen);
 }
 
 void Events::listener_activateXDG(wl_listener* listener, void* data) {
@@ -901,7 +938,7 @@ void Events::listener_activateXDG(wl_listener* listener, void* data) {
 
     static auto* const PFOCUSONACTIVATE = &g_pConfigManager->getConfigValuePtr("misc:focus_on_activate")->intValue;
 
-    Debug::log(LOG, "Activate request for surface at %lx", E->surface);
+    Debug::log(LOG, "Activate request for surface at {:x}", (uintptr_t)E->surface);
 
     if (!wlr_xdg_surface_try_from_wlr_surface(E->surface))
         return;
@@ -911,25 +948,19 @@ void Events::listener_activateXDG(wl_listener* listener, void* data) {
     if (!PWINDOW || PWINDOW == g_pCompositor->m_pLastWindow)
         return;
 
-    g_pEventManager->postEvent(SHyprIPCEvent{"urgent", getFormat("%lx", PWINDOW)});
+    g_pEventManager->postEvent(SHyprIPCEvent{"urgent", std::format("{:x}", (uintptr_t)PWINDOW)});
     EMIT_HOOK_EVENT("urgent", PWINDOW);
 
     PWINDOW->m_bIsUrgent = true;
 
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID);
-    if (PWORKSPACE->m_pWlrHandle) {
-        wlr_ext_workspace_handle_v1_set_urgent(PWORKSPACE->m_pWlrHandle, 1);
-    }
-
     if (!*PFOCUSONACTIVATE)
         return;
 
     if (PWINDOW->m_bIsFloating)
-        g_pCompositor->moveWindowToTop(PWINDOW);
+        g_pCompositor->changeWindowZOrder(PWINDOW, true);
 
     g_pCompositor->focusWindow(PWINDOW);
-    Vector2D middle = PWINDOW->m_vRealPosition.goalv() + PWINDOW->m_vRealSize.goalv() / 2.f;
-    g_pCompositor->warpCursorTo(middle);
+    g_pCompositor->warpCursorTo(PWINDOW->middle());
 }
 
 void Events::listener_activateX11(void* owner, void* data) {
@@ -937,11 +968,11 @@ void Events::listener_activateX11(void* owner, void* data) {
 
     static auto* const PFOCUSONACTIVATE = &g_pConfigManager->getConfigValuePtr("misc:focus_on_activate")->intValue;
 
-    Debug::log(LOG, "X11 Activate request for window %lx", PWINDOW);
+    Debug::log(LOG, "X11 Activate request for window {}", PWINDOW);
 
     if (PWINDOW->m_iX11Type == 2) {
 
-        Debug::log(LOG, "Unmanaged X11 %lx requests activate", PWINDOW);
+        Debug::log(LOG, "Unmanaged X11 {} requests activate", PWINDOW);
 
         if (g_pCompositor->m_pLastWindow && g_pCompositor->m_pLastWindow->getPID() != PWINDOW->getPID())
             return;
@@ -953,18 +984,17 @@ void Events::listener_activateX11(void* owner, void* data) {
     if (PWINDOW == g_pCompositor->m_pLastWindow)
         return;
 
-    g_pEventManager->postEvent(SHyprIPCEvent{"urgent", getFormat("%lx", PWINDOW)});
+    g_pEventManager->postEvent(SHyprIPCEvent{"urgent", std::format("{:x}", (uintptr_t)PWINDOW)});
     EMIT_HOOK_EVENT("urgent", PWINDOW);
 
     if (!*PFOCUSONACTIVATE)
         return;
 
     if (PWINDOW->m_bIsFloating)
-        g_pCompositor->moveWindowToTop(PWINDOW);
+        g_pCompositor->changeWindowZOrder(PWINDOW, true);
 
     g_pCompositor->focusWindow(PWINDOW);
-    Vector2D middle = PWINDOW->m_vRealPosition.goalv() + PWINDOW->m_vRealSize.goalv() / 2.f;
-    g_pCompositor->warpCursorTo(middle);
+    g_pCompositor->warpCursorTo(PWINDOW->middle());
 }
 
 void Events::listener_configureX11(void* owner, void* data) {
@@ -991,7 +1021,9 @@ void Events::listener_configureX11(void* owner, void* data) {
     else
         PWINDOW->setHidden(true);
 
-    PWINDOW->m_vRealPosition.setValueAndWarp(Vector2D(E->x, E->y));
+    const auto LOGICALPOS = g_pXWaylandManager->xwaylandToWaylandCoords({E->x, E->y});
+
+    PWINDOW->m_vRealPosition.setValueAndWarp(LOGICALPOS);
     PWINDOW->m_vRealSize.setValueAndWarp(Vector2D(E->width, E->height));
 
     static auto* const PXWLFORCESCALEZERO = &g_pConfigManager->getConfigValuePtr("xwayland:force_zero_scaling")->intValue;
@@ -1007,7 +1039,7 @@ void Events::listener_configureX11(void* owner, void* data) {
 
     PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromVector(PWINDOW->m_vRealPosition.vec() + PWINDOW->m_vRealSize.vec() / 2.f)->activeWorkspace;
 
-    g_pCompositor->moveWindowToTop(PWINDOW);
+    g_pCompositor->changeWindowZOrder(PWINDOW, true);
 
     PWINDOW->m_bCreatedOverFullscreen = true;
 
@@ -1041,13 +1073,15 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
 
     static auto* const PXWLFORCESCALEZERO = &g_pConfigManager->getConfigValuePtr("xwayland:force_zero_scaling")->intValue;
 
-    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 %lx 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);
+    const auto         LOGICALPOS = g_pXWaylandManager->xwaylandToWaylandCoords({PWINDOW->m_uSurface.xwayland->x, PWINDOW->m_uSurface.xwayland->y});
+
+    if (abs(std::floor(POS.x) - LOGICALPOS.x) > 2 || abs(std::floor(POS.y) - LOGICALPOS.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 {} requests geometry update to {:j} {} {}", PWINDOW, LOGICALPOS, (int)PWINDOW->m_uSurface.xwayland->width,
+                   (int)PWINDOW->m_uSurface.xwayland->height);
 
         g_pHyprRenderer->damageWindow(PWINDOW);
-        PWINDOW->m_vRealPosition.setValueAndWarp(Vector2D(PWINDOW->m_uSurface.xwayland->x, PWINDOW->m_uSurface.xwayland->y));
+        PWINDOW->m_vRealPosition.setValueAndWarp(Vector2D(LOGICALPOS.x, LOGICALPOS.y));
 
         if (abs(std::floor(SIZ.x) - PWINDOW->m_uSurface.xwayland->width) > 2 || abs(std::floor(SIZ.y) - PWINDOW->m_uSurface.xwayland->height) > 2)
             PWINDOW->m_vRealSize.setValueAndWarp(Vector2D(PWINDOW->m_uSurface.xwayland->width, PWINDOW->m_uSurface.xwayland->height));
@@ -1062,7 +1096,7 @@ void Events::listener_unmanagedSetGeometry(void* owner, void* data) {
 
         PWINDOW->m_iWorkspaceID = g_pCompositor->getMonitorFromVector(PWINDOW->m_vRealPosition.vec() + PWINDOW->m_vRealSize.vec() / 2.f)->activeWorkspace;
 
-        g_pCompositor->moveWindowToTop(PWINDOW);
+        g_pCompositor->changeWindowZOrder(PWINDOW, true);
         PWINDOW->updateWindowDecos();
         g_pHyprRenderer->damageWindow(PWINDOW);
     }
@@ -1091,9 +1125,9 @@ void Events::listener_dissociateX11(void* owner, void* data) {
 void Events::listener_surfaceXWayland(wl_listener* listener, void* data) {
     const auto XWSURFACE = (wlr_xwayland_surface*)data;
 
-    Debug::log(LOG, "New XWayland Surface created (class %s).", XWSURFACE->_class);
+    Debug::log(LOG, "New XWayland Surface created (class {}).", XWSURFACE->_class ? XWSURFACE->_class : "null");
     if (XWSURFACE->parent)
-        Debug::log(LOG, "Window parent data: %s at %lx", XWSURFACE->parent->_class, XWSURFACE->parent);
+        Debug::log(LOG, "Window parent data: {} at {:x}", XWSURFACE->parent->_class ? XWSURFACE->parent->_class : "null", (uintptr_t)XWSURFACE->parent);
 
     const auto PNEWWINDOW = (CWindow*)g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
 
@@ -1117,7 +1151,7 @@ void Events::listener_newXDGSurface(wl_listener* listener, void* data) {
     if (XDGSURFACE->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL)
         return;
 
-    Debug::log(LOG, "New XDG Surface created. (class: %s)", XDGSURFACE->toplevel->app_id);
+    Debug::log(LOG, "New XDG Surface created. (class: {})", XDGSURFACE->toplevel->app_id ? XDGSURFACE->toplevel->app_id : "null");
 
     const auto PNEWWINDOW      = g_pCompositor->m_vWindows.emplace_back(std::make_unique<CWindow>()).get();
     PNEWWINDOW->m_uSurface.xdg = XDGSURFACE;
@@ -1137,7 +1171,7 @@ void Events::listener_requestMaximize(void* owner, void* data) {
     if (PWINDOW->m_bNoMaximizeRequest)
         return;
 
-    Debug::log(LOG, "Maximize request for %lx", PWINDOW);
+    Debug::log(LOG, "Maximize request for {}", PWINDOW);
     if (!PWINDOW->m_bIsX11) {
         const auto EV = (wlr_foreign_toplevel_handle_v1_maximized_event*)data;
 
@@ -1156,7 +1190,7 @@ void Events::listener_requestMaximize(void* owner, void* data) {
 void Events::listener_requestMinimize(void* owner, void* data) {
     const auto PWINDOW = (CWindow*)owner;
 
-    Debug::log(LOG, "Minimize request for %lx", PWINDOW);
+    Debug::log(LOG, "Minimize request for {}", PWINDOW);
 
     if (PWINDOW->m_bIsX11) {
         if (!PWINDOW->m_bMappedX11 || PWINDOW->m_iX11Type != 1)
@@ -1164,13 +1198,13 @@ void Events::listener_requestMinimize(void* owner, void* data) {
 
         const auto E = (wlr_xwayland_minimize_event*)data;
 
-        g_pEventManager->postEvent({"minimize", getFormat("%lx,%i", PWINDOW, (int)E->minimize)});
+        g_pEventManager->postEvent({"minimize", std::format("{:x},{}", (uintptr_t)PWINDOW, (int)E->minimize)});
         EMIT_HOOK_EVENT("minimize", (std::vector<void*>{PWINDOW, (void*)E->minimize}));
 
         wlr_xwayland_surface_set_minimized(PWINDOW->m_uSurface.xwayland, E->minimize && g_pCompositor->m_pLastWindow != PWINDOW); // fucking DXVK
     } else {
         const auto E = (wlr_foreign_toplevel_handle_v1_minimized_event*)data;
-        g_pEventManager->postEvent({"minimize", getFormat("%lx,%i", PWINDOW, E ? (int)E->minimized : 1)});
+        g_pEventManager->postEvent({"minimize", std::format("{:x},{}", (uintptr_t)PWINDOW, E ? (int)E->minimized : 1)});
         EMIT_HOOK_EVENT("minimize", (std::vector<void*>{PWINDOW, (void*)(E ? (uint64_t)E->minimized : 1)}));
     }
 }

src/helpers/AnimatedVariable.cpp

@@ -41,8 +41,8 @@ void CAnimatedVariable::create(ANIMATEDVARTYPE type, std::any val, SAnimationPro
             default: ASSERT(false); break;
         }
     } catch (std::exception& e) {
-        Debug::log(ERR, "CAnimatedVariable create error: %s", e.what());
-        RASSERT(false, "CAnimatedVariable create error: %s", e.what());
+        Debug::log(ERR, "CAnimatedVariable create error: {}", e.what());
+        RASSERT(false, "CAnimatedVariable create error: {}", e.what());
     }
 }
 
@@ -51,6 +51,8 @@ CAnimatedVariable::~CAnimatedVariable() {
 }
 
 void CAnimatedVariable::unregister() {
+    if (!g_pAnimationManager)
+        return;
     std::erase_if(g_pAnimationManager->m_vAnimatedVariables, [&](const auto& other) { return other == this; });
     m_bIsRegistered = false;
     disconnectFromActive();
@@ -82,8 +84,11 @@ float CAnimatedVariable::getCurveValue() {
 }
 
 void CAnimatedVariable::connectToActive() {
+    g_pAnimationManager->scheduleTick(); // otherwise the animation manager will never pick this up
+
     if (!m_bIsConnectedToActive)
         g_pAnimationManager->m_vActiveAnimatedVariables.push_back(this);
+
     m_bIsConnectedToActive = true;
 }
 

src/helpers/AnimatedVariable.hpp

@@ -1,7 +1,12 @@
 #pragma once
 
-#include "../defines.hpp"
+#include <functional>
 #include <any>
+#include <chrono>
+#include "Vector2D.hpp"
+#include "Color.hpp"
+#include "../macros.hpp"
+#include "../debug/Log.hpp"
 
 enum ANIMATEDVARTYPE
 {
@@ -73,6 +78,9 @@ class CAnimatedVariable {
     }
 
     CAnimatedVariable& operator=(const Vector2D& v) {
+        if (v == m_vGoal)
+            return *this;
+
         m_vGoal        = v;
         animationBegin = std::chrono::system_clock::now();
         m_vBegun       = m_vValue;
@@ -83,6 +91,9 @@ class CAnimatedVariable {
     }
 
     CAnimatedVariable& operator=(const float& v) {
+        if (v == m_fGoal)
+            return *this;
+
         m_fGoal        = v;
         animationBegin = std::chrono::system_clock::now();
         m_fBegun       = m_fValue;
@@ -93,6 +104,9 @@ class CAnimatedVariable {
     }
 
     CAnimatedVariable& operator=(const CColor& v) {
+        if (v == m_cGoal)
+            return *this;
+
         m_cGoal        = v;
         animationBegin = std::chrono::system_clock::now();
         m_cBegun       = m_cValue;
@@ -104,6 +118,9 @@ class CAnimatedVariable {
 
     // Sets the actual stored value, without affecting the goal, but resets the timer
     void setValue(const Vector2D& v) {
+        if (v == m_vValue)
+            return;
+
         m_vValue       = v;
         animationBegin = std::chrono::system_clock::now();
         m_vBegun       = m_vValue;
@@ -113,6 +130,9 @@ class CAnimatedVariable {
 
     // Sets the actual stored value, without affecting the goal, but resets the timer
     void setValue(const float& v) {
+        if (v == m_fValue)
+            return;
+
         m_fValue       = v;
         animationBegin = std::chrono::system_clock::now();
         m_vBegun       = m_vValue;
@@ -122,6 +142,9 @@ class CAnimatedVariable {
 
     // Sets the actual stored value, without affecting the goal, but resets the timer
     void setValue(const CColor& v) {
+        if (v == m_cValue)
+            return;
+
         m_cValue       = v;
         animationBegin = std::chrono::system_clock::now();
         m_vBegun       = m_vValue;

src/helpers/BezierCurve.cpp

@@ -1,5 +1,8 @@
 #include "BezierCurve.hpp"
+#include "../debug/Log.hpp"
+#include "../macros.hpp"
 
+#include <chrono>
 #include <algorithm>
 
 void CBezierCurve::setup(std::vector<Vector2D>* pVec) {
@@ -15,7 +18,7 @@ void CBezierCurve::setup(std::vector<Vector2D>* pVec) {
 
     m_dPoints.emplace_back(Vector2D(1, 1));
 
-    RASSERT(m_dPoints.size() == 4, "CBezierCurve only supports cubic beziers! (points num: %i)", m_dPoints.size());
+    RASSERT(m_dPoints.size() == 4, "CBezierCurve only supports cubic beziers! (points num: {})", m_dPoints.size());
 
     // bake BAKEDPOINTS points for faster lookups
     // T -> X ( / BAKEDPOINTS )
@@ -31,8 +34,8 @@ void CBezierCurve::setup(std::vector<Vector2D>* pVec) {
         getYForPoint(i);
     const auto ELAPSEDCALCAVG = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - BEGINCALC).count() / 1000.f / 10.f;
 
-    Debug::log(LOG, "Created a bezier curve, baked %i points, mem usage: %.2fkB, time to bake: %.2fµs. Estimated average calc time: %.2fµs.", BAKEDPOINTS, POINTSSIZE, ELAPSEDUS,
-               ELAPSEDCALCAVG);
+    Debug::log(LOG, "Created a bezier curve, baked {} points, mem usage: {:.2f}kB, time to bake: {:.2f}µs. Estimated average calc time: {:.2f}µs.", BAKEDPOINTS, POINTSSIZE,
+               ELAPSEDUS, ELAPSEDCALCAVG);
 }
 
 float CBezierCurve::getYForT(float t) {
@@ -45,27 +48,25 @@ float CBezierCurve::getXForT(float t) {
 
 // Todo: this probably can be done better and faster
 float CBezierCurve::getYForPoint(float x) {
-    if (x >= 1.0)
-        return 1.0;
+    if (x >= 1.f)
+        return 1.f;
 
-    // binary search for the range UPDOWN X
-    int upperT = BAKEDPOINTS - 1;
-    int lowerT = 0;
-    int mid    = upperT / 2;
+    int  index = 0;
+    bool below = true;
+    for (int step = (BAKEDPOINTS + 1) / 2; step > 0; step /= 2) {
+        if (below)
+            index += step;
+        else
+            index -= step;
 
-    while (std::abs(upperT - lowerT) > 1) {
-        if (m_aPointsBaked[mid].x > x) {
-            upperT = mid;
-        } else {
-            lowerT = mid;
-        }
-
-        mid = (upperT + lowerT) / 2;
+        below = m_aPointsBaked[index].x < x;
     }
 
+    int lowerIndex = index - (!below || index == BAKEDPOINTS - 1);
+
     // in the name of performance i shall make a hack
-    const auto LOWERPOINT = &m_aPointsBaked[std::clamp(lowerT, 0, BAKEDPOINTS - 1)];
-    const auto UPPERPOINT = &m_aPointsBaked[std::clamp(upperT, 0, BAKEDPOINTS - 1)];
+    const auto LOWERPOINT = &m_aPointsBaked[lowerIndex];
+    const auto UPPERPOINT = &m_aPointsBaked[lowerIndex + 1];
 
     const auto PERCINDELTA = (x - LOWERPOINT->x) / (UPPERPOINT->x - LOWERPOINT->x);
 
@@ -73,4 +74,4 @@ float CBezierCurve::getYForPoint(float x) {
         return 0.f;
 
     return LOWERPOINT->y + (UPPERPOINT->y - LOWERPOINT->y) * PERCINDELTA;
-}
+}

src/helpers/BezierCurve.hpp

@@ -1,14 +1,15 @@
 #pragma once
 
-#include "../defines.hpp"
 #include <deque>
+#include <array>
+#include <vector>
+#include "Vector2D.hpp"
 
 constexpr int   BAKEDPOINTS    = 255;
 constexpr float INVBAKEDPOINTS = 1.f / BAKEDPOINTS;
 
 // an implementation of a cubic bezier curve
 // might do better later
-// TODO: n-point curves
 class CBezierCurve {
   public:
     // sets up the bezier curve.
@@ -24,4 +25,4 @@ class CBezierCurve {
     std::deque<Vector2D>              m_dPoints;
 
     std::array<Vector2D, BAKEDPOINTS> m_aPointsBaked;
-};
+};

src/helpers/Color.cpp

@@ -1,5 +1,9 @@
 #include "Color.hpp"
-#include "../defines.hpp"
+
+#define ALPHA(c) ((double)(((c) >> 24) & 0xff) / 255.0)
+#define RED(c)   ((double)(((c) >> 16) & 0xff) / 255.0)
+#define GREEN(c) ((double)(((c) >> 8) & 0xff) / 255.0)
+#define BLUE(c)  ((double)(((c)) & 0xff) / 255.0)
 
 CColor::CColor() {}
 

src/helpers/MiscFunctions.cpp

@@ -6,6 +6,9 @@
 #include <sys/utsname.h>
 #include <iomanip>
 #include <sstream>
+#ifdef HAS_EXECINFO
+#include <execinfo.h>
+#endif
 
 #if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
 #include <sys/sysctl.h>
@@ -125,20 +128,22 @@ static const float transforms[][9] = {
 std::string absolutePath(const std::string& rawpath, const std::string& currentPath) {
     auto value = rawpath;
 
-    if (value[0] == '.') {
-        auto currentDir = currentPath.substr(0, currentPath.find_last_of('/'));
-
-        if (value[1] == '.') {
-            auto parentDir = currentDir.substr(0, currentDir.find_last_of('/'));
-            value.replace(0, 2 + currentPath.empty(), parentDir);
-        } else {
-            value.replace(0, 1 + currentPath.empty(), currentDir);
-        }
-    }
-
     if (value[0] == '~') {
         static const char* const ENVHOME = getenv("HOME");
         value.replace(0, 1, std::string(ENVHOME));
+    } else if (value[0] != '/') {
+        auto currentDir = currentPath.substr(0, currentPath.find_last_of('/'));
+
+        if (value[0] == '.') {
+            if (value[1] == '.' && value[2] == '/') {
+                auto parentDir = currentDir.substr(0, currentDir.find_last_of('/'));
+                value.replace(0, 2 + currentPath.empty(), parentDir);
+            } else if (value[1] == '/')
+                value.replace(0, 1 + currentPath.empty(), currentDir);
+            else
+                value = currentDir + '/' + value;
+        } else
+            value = currentDir + '/' + value;
     }
 
     return value;
@@ -150,27 +155,13 @@ void addWLSignal(wl_signal* pSignal, wl_listener* pListener, void* pOwner, const
 
     wl_signal_add(pSignal, pListener);
 
-    Debug::log(LOG, "Registered signal for owner %lx: %lx -> %lx (owner: %s)", pOwner, pSignal, pListener, ownerString.c_str());
+    Debug::log(LOG, "Registered signal for owner {:x}: {:x} -> {:x} (owner: {})", (uintptr_t)pOwner, (uintptr_t)pSignal, (uintptr_t)pListener, ownerString);
 }
 
 void handleNoop(struct wl_listener* listener, void* data) {
     // Do nothing
 }
 
-std::string getFormat(const char* fmt, ...) {
-    char*   outputStr = nullptr;
-
-    va_list args;
-    va_start(args, fmt);
-    vasprintf(&outputStr, fmt, args);
-    va_end(args);
-
-    std::string output = std::string(outputStr);
-    free(outputStr);
-
-    return output;
-}
-
 std::string escapeJSONStrings(const std::string& str) {
     std::ostringstream oss;
     for (auto& c : str) {
@@ -223,7 +214,7 @@ float getPlusMinusKeywordResult(std::string source, float relative) {
     try {
         return relative + stof(source);
     } catch (...) {
-        Debug::log(ERR, "Invalid arg \"%s\" in getPlusMinusKeywordResult!", source.c_str());
+        Debug::log(ERR, "Invalid arg \"{}\" in getPlusMinusKeywordResult!", source);
         return INT_MAX;
     }
 }
@@ -259,7 +250,7 @@ bool isDirection(const std::string& arg) {
 
 int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
     int result = INT_MAX;
-    if (in.find("special") == 0) {
+    if (in.starts_with("special")) {
         outName = "special";
 
         if (in.length() > 8) {
@@ -273,7 +264,7 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
         }
 
         return SPECIAL_WORKSPACE_START;
-    } else if (in.find("name:") == 0) {
+    } else if (in.starts_with("name:")) {
         const auto WORKSPACENAME = in.substr(in.find_first_of(':') + 1);
         const auto WORKSPACE     = g_pCompositor->getWorkspaceByName(WORKSPACENAME);
         if (!WORKSPACE) {
@@ -282,14 +273,14 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             result = WORKSPACE->m_iID;
         }
         outName = WORKSPACENAME;
-    } else if (in.find("empty") == 0) {
+    } else if (in.starts_with("empty")) {
         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.find("prev") == 0) {
+    } else if (in.starts_with("prev")) {
         if (!g_pCompositor->m_pLastMonitor)
             return INT_MAX;
 
@@ -400,12 +391,12 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
                 int beginID = finalWSID;
                 int curID   = finalWSID;
                 while (--curID > 0 && remainingWSes > 0) {
-                    if (invalidWSes.find(curID) == invalidWSes.end()) {
+                    if (!invalidWSes.contains(curID)) {
                         remainingWSes--;
                     }
                     finalWSID = curID;
                 }
-                if (finalWSID <= 0 || invalidWSes.find(finalWSID) != invalidWSes.end()) {
+                if (finalWSID <= 0 || invalidWSes.contains(finalWSID)) {
                     if (namedWSes.size()) {
                         // Go to the named workspaces
                         // Need remainingWSes more
@@ -425,7 +416,7 @@ int getWorkspaceIDFromString(const std::string& in, std::string& outName) {
             if (walkDir == '+') {
                 int curID = finalWSID;
                 while (++curID < INT32_MAX && remainingWSes > 0) {
-                    if (invalidWSes.find(curID) == invalidWSes.end()) {
+                    if (!invalidWSes.contains(curID)) {
                         remainingWSes--;
                     }
                     finalWSID = curID;
@@ -538,10 +529,10 @@ void logSystemInfo() {
 
     uname(&unameInfo);
 
-    Debug::log(LOG, "System name: %s", unameInfo.sysname);
-    Debug::log(LOG, "Node name: %s", unameInfo.nodename);
-    Debug::log(LOG, "Release: %s", unameInfo.release);
-    Debug::log(LOG, "Version: %s", unameInfo.version);
+    Debug::log(LOG, "System name: {}", unameInfo.sysname);
+    Debug::log(LOG, "Node name: {}", unameInfo.nodename);
+    Debug::log(LOG, "Release: {}", unameInfo.release);
+    Debug::log(LOG, "Version: {}", unameInfo.version);
 
     Debug::log(NONE, "\n");
 
@@ -550,7 +541,7 @@ void logSystemInfo() {
 #else
     const std::string GPUINFO = execAndGet("lspci -vnn | grep VGA");
 #endif
-    Debug::log(LOG, "GPU information:\n%s\n", GPUINFO.c_str());
+    Debug::log(LOG, "GPU information:\n{}\n", GPUINFO);
 
     if (GPUINFO.contains("NVIDIA")) {
         Debug::log(WARN, "Warning: you're using an NVIDIA GPU. Make sure you follow the instructions on the wiki if anything is amiss.\n");
@@ -559,7 +550,7 @@ void logSystemInfo() {
     // log etc
     Debug::log(LOG, "os-release:");
 
-    Debug::log(NONE, "%s", execAndGet("cat /etc/os-release").c_str());
+    Debug::log(NONE, "{}", execAndGet("cat /etc/os-release"));
 }
 
 void matrixProjection(float mat[9], int w, int h, wl_output_transform tr) {
@@ -603,8 +594,8 @@ int64_t getPPIDof(int64_t pid) {
 
     return 0;
 #else
-    std::string       dir     = "/proc/" + std::to_string(pid) + "/status";
-    FILE*             infile;
+    std::string dir = "/proc/" + std::to_string(pid) + "/status";
+    FILE*       infile;
 
     infile = fopen(dir.c_str(), "r");
     if (!infile)
@@ -637,15 +628,15 @@ int64_t getPPIDof(int64_t pid) {
 }
 
 int64_t configStringToInt(const std::string& VALUE) {
-    if (VALUE.find("0x") == 0) {
+    if (VALUE.starts_with("0x")) {
         // 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) {
+    } else if (VALUE.starts_with("rgba(") && VALUE.ends_with(')')) {
         const auto VALUEWITHOUTFUNC = VALUE.substr(5, VALUE.length() - 6);
 
         if (removeBeginEndSpacesTabs(VALUEWITHOUTFUNC).length() != 8) {
-            Debug::log(WARN, "invalid length %i for rgba", VALUEWITHOUTFUNC.length());
+            Debug::log(WARN, "invalid length {} for rgba", VALUEWITHOUTFUNC.length());
             throw std::invalid_argument("rgba() expects length of 8 characters (4 bytes)");
         }
 
@@ -653,20 +644,20 @@ int64_t configStringToInt(const std::string& VALUE) {
 
         // 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) {
+    } else if (VALUE.starts_with("rgb(") && VALUE.ends_with(')')) {
         const auto VALUEWITHOUTFUNC = VALUE.substr(4, VALUE.length() - 5);
 
         if (removeBeginEndSpacesTabs(VALUEWITHOUTFUNC).length() != 6) {
-            Debug::log(WARN, "invalid length %i for rgb", VALUEWITHOUTFUNC.length());
+            Debug::log(WARN, "invalid length {} 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) {
+    } else if (VALUE.starts_with("true") || VALUE.starts_with("on") || VALUE.starts_with("yes")) {
         return 1;
-    } else if (VALUE.find("false") == 0 || VALUE.find("off") == 0 || VALUE.find("no") == 0) {
+    } else if (VALUE.starts_with("false") || VALUE.starts_with("off") || VALUE.starts_with("no")) {
         return 0;
     }
     return std::stoll(VALUE);
@@ -696,3 +687,29 @@ std::string replaceInString(std::string subject, const std::string& search, cons
     }
     return subject;
 }
+
+std::vector<SCallstackFrameInfo> getBacktrace() {
+    std::vector<SCallstackFrameInfo> callstack;
+
+#ifdef HAS_EXECINFO
+    void*  bt[1024];
+    size_t btSize;
+    char** btSymbols;
+
+    btSize    = backtrace(bt, 1024);
+    btSymbols = backtrace_symbols(bt, btSize);
+
+    for (size_t i = 0; i < btSize; ++i) {
+        callstack.emplace_back(SCallstackFrameInfo{bt[i], std::string{btSymbols[i]}});
+    }
+#else
+    callstack.emplace_back(SCallstackFrameInfo{nullptr, "configuration does not support execinfo.h"});
+#endif
+
+    return callstack;
+}
+
+void throwError(const std::string& err) {
+    Debug::log(CRIT, "Critical error thrown: {}", err);
+    throw std::runtime_error(err);
+}

src/helpers/MiscFunctions.hpp

@@ -1,22 +1,41 @@
 #pragma once
 
-#include "../includes.hpp"
+#include <string>
+#include <wayland-server.h>
+#include <wlr/util/box.h>
+#include "Vector2D.hpp"
+#include <vector>
+#include <format>
 
-std::string absolutePath(const std::string&, const std::string&);
-void        addWLSignal(wl_signal*, wl_listener*, void* pOwner, const std::string& ownerString);
-std::string getFormat(const char* fmt, ...); // Basically Debug::log to a string
-std::string escapeJSONStrings(const std::string& str);
-void        scaleBox(wlr_box*, float);
-std::string removeBeginEndSpacesTabs(std::string);
-bool        isNumber(const std::string&, bool allowfloat = false);
-bool        isDirection(const std::string&);
-int         getWorkspaceIDFromString(const std::string&, std::string&);
-float       vecToRectDistanceSquared(const Vector2D& vec, const Vector2D& p1, const Vector2D& p2);
-void        logSystemInfo();
-std::string execAndGet(const char*);
-int64_t     getPPIDof(int64_t pid);
-int64_t     configStringToInt(const std::string&);
-float       getPlusMinusKeywordResult(std::string in, float relative);
-void        matrixProjection(float mat[9], int w, int h, wl_output_transform tr);
-double      normalizeAngleRad(double ang);
-std::string replaceInString(std::string subject, const std::string& search, const std::string& replace);
+struct SCallstackFrameInfo {
+    void*       adr = nullptr;
+    std::string desc;
+};
+
+std::string                      absolutePath(const std::string&, const std::string&);
+void                             addWLSignal(wl_signal*, wl_listener*, void* pOwner, const std::string& ownerString);
+std::string                      escapeJSONStrings(const std::string& str);
+void                             scaleBox(wlr_box*, float);
+std::string                      removeBeginEndSpacesTabs(std::string);
+bool                             isNumber(const std::string&, bool allowfloat = false);
+bool                             isDirection(const std::string&);
+int                              getWorkspaceIDFromString(const std::string&, std::string&);
+float                            vecToRectDistanceSquared(const Vector2D& vec, const Vector2D& p1, const Vector2D& p2);
+void                             logSystemInfo();
+std::string                      execAndGet(const char*);
+int64_t                          getPPIDof(int64_t pid);
+int64_t                          configStringToInt(const std::string&);
+float                            getPlusMinusKeywordResult(std::string in, float relative);
+void                             matrixProjection(float mat[9], int w, int h, wl_output_transform tr);
+double                           normalizeAngleRad(double ang);
+std::string                      replaceInString(std::string subject, const std::string& search, const std::string& replace);
+std::vector<SCallstackFrameInfo> getBacktrace();
+void                             throwError(const std::string& err);
+
+template <typename... Args>
+[[deprecated("use std::format instead")]] std::string getFormat(std::format_string<Args...> fmt, Args&&... args) {
+    // no need for try {} catch {} because std::format_string<Args...> ensures that vformat never throw std::format_error
+    // because any suck format specifier will cause a compilation error
+    // this is actually what std::format in stdlib does
+    return std::vformat(fmt.get(), std::make_format_args(args...));
+}

src/helpers/Monitor.cpp

@@ -40,6 +40,8 @@ void CMonitor::onConnect(bool noRule) {
     hyprListener_monitorCommit.initCallback(&output->events.commit, &Events::listener_monitorCommit, this);
     hyprListener_monitorBind.initCallback(&output->events.bind, &Events::listener_monitorBind, this);
 
+    tearingState.canTear = wlr_backend_is_drm(output->backend); // tearing only works on drm
+
     if (m_bEnabled) {
         wlr_output_enable(output, 1);
         wlr_output_commit(output);
@@ -79,15 +81,12 @@ void CMonitor::onConnect(bool noRule) {
         if (PREFSTATE)
             wlr_output_set_mode(output, PREFSTATE);
         else
-            Debug::log(WARN, "No mode found for disabled output %s", output->name);
+            Debug::log(WARN, "No mode found for disabled output {}", output->name);
 
         wlr_output_enable(output, 0);
 
-        if (!wlr_output_commit(output)) {
-            Debug::log(ERR, "Couldn't commit disabled state on output %s", output->name);
-        }
-
-        Events::listener_change(nullptr, nullptr);
+        if (!wlr_output_commit(output))
+            Debug::log(ERR, "Couldn't commit disabled state on output {}", output->name);
 
         m_bEnabled = false;
 
@@ -127,11 +126,6 @@ void CMonitor::onConnect(bool noRule) {
 
     m_bEnabled = true;
 
-    // create it in the arr
-    vecPosition = monitorRule.offset;
-    vecSize     = monitorRule.resolution;
-    refreshRate = monitorRule.refreshRate;
-
     wlr_output_enable(output, 1);
 
     // set mode, also applies
@@ -142,15 +136,7 @@ void CMonitor::onConnect(bool noRule) {
 
     wlr_xcursor_manager_load(g_pCompositor->m_sWLRXCursorMgr, scale);
 
-    Debug::log(LOG, "Added new monitor with name %s at %i,%i with size %ix%i, pointer %lx", output->name, (int)vecPosition.x, (int)vecPosition.y, (int)vecPixelSize.x,
-               (int)vecPixelSize.y, output);
-
-    // add a WLR workspace group
-    if (!pWLRWorkspaceGroupHandle) {
-        pWLRWorkspaceGroupHandle = wlr_ext_workspace_group_handle_v1_create(g_pCompositor->m_sWLREXTWorkspaceMgr);
-    }
-
-    wlr_ext_workspace_group_handle_v1_output_enter(pWLRWorkspaceGroupHandle, output);
+    Debug::log(LOG, "Added new monitor with name {} at {:j0} with size {:j0}, pointer {:x}", output->name, vecPosition, vecPixelSize, (uintptr_t)output);
 
     setupDefaultWS(monitorRule);
 
@@ -210,7 +196,7 @@ void CMonitor::onDisconnect() {
     if (!m_bEnabled || g_pCompositor->m_bIsShuttingDown)
         return;
 
-    Debug::log(LOG, "onDisconnect called for %s", output->name);
+    Debug::log(LOG, "onDisconnect called for {}", output->name);
 
     // Cleanup everything. Move windows back, snap cursor, shit.
     CMonitor* BACKUPMON = nullptr;
@@ -252,40 +238,38 @@ void CMonitor::onDisconnect() {
         m_aLayerSurfaceLayers[i].clear();
     }
 
-    Debug::log(LOG, "Removed monitor %s!", szName.c_str());
+    Debug::log(LOG, "Removed monitor {}!", szName);
 
     g_pEventManager->postEvent(SHyprIPCEvent{"monitorremoved", szName});
     EMIT_HOOK_EVENT("monitorRemoved", this);
 
     if (!BACKUPMON) {
         Debug::log(WARN, "Unplugged last monitor, entering an unsafe state. Good luck my friend.");
-
-        hyprListener_monitorStateRequest.removeCallback();
-        hyprListener_monitorDestroy.removeCallback();
-
-        g_pCompositor->m_bUnsafeState = true;
-
-        std::erase_if(g_pCompositor->m_vMonitors, [&](std::shared_ptr<CMonitor>& el) { return el.get() == this; });
-
-        return;
+        g_pCompositor->enterUnsafeState();
     }
 
-    // snap cursor
-    wlr_cursor_warp(g_pCompositor->m_sWLRCursor, nullptr, BACKUPMON->vecPosition.x + BACKUPMON->vecTransformedSize.x / 2.f,
-                    BACKUPMON->vecPosition.y + BACKUPMON->vecTransformedSize.y / 2.f);
+    if (BACKUPMON) {
+        // snap cursor
+        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;
-    for (auto& w : g_pCompositor->m_vWorkspaces) {
-        if (w->m_iMonitorID == ID) {
-            wspToMove.push_back(w.get());
+        // move workspaces
+        std::deque<CWorkspace*> wspToMove;
+        for (auto& w : g_pCompositor->m_vWorkspaces) {
+            if (w->m_iMonitorID == ID) {
+                wspToMove.push_back(w.get());
+            }
         }
-    }
 
-    for (auto& w : wspToMove) {
-        w->m_szLastMonitor = szName;
-        g_pCompositor->moveWorkspaceToMonitor(w, BACKUPMON);
-        w->startAnim(true, true, true);
+        for (auto& w : wspToMove) {
+            w->m_szLastMonitor = szName;
+            g_pCompositor->moveWorkspaceToMonitor(w, BACKUPMON);
+            w->startAnim(true, true, true);
+        }
+    } else {
+        g_pCompositor->m_pLastFocus   = nullptr;
+        g_pCompositor->m_pLastWindow  = nullptr;
+        g_pCompositor->m_pLastMonitor = nullptr;
     }
 
     activeWorkspace = -1;
@@ -296,8 +280,6 @@ void CMonitor::onDisconnect() {
 
     wlr_output_commit(output);
 
-    std::erase_if(g_pCompositor->m_vWorkspaces, [&](std::unique_ptr<CWorkspace>& el) { return el->m_iMonitorID == ID; });
-
     if (g_pCompositor->m_pLastMonitor == this)
         g_pCompositor->setActiveMonitor(BACKUPMON);
 
@@ -373,12 +355,12 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
         WORKSPACEID             = g_pCompositor->m_vWorkspaces.size() + 1;
         newDefaultWorkspaceName = std::to_string(WORKSPACEID);
 
-        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"%s\" is invalid.", g_pConfigManager->getDefaultWorkspaceFor(szName).c_str());
+        Debug::log(LOG, "Invalid workspace= directive name in monitor parsing, workspace name \"{}\" is invalid.", g_pConfigManager->getDefaultWorkspaceFor(szName));
     }
 
     auto PNEWWORKSPACE = g_pCompositor->getWorkspaceByID(WORKSPACEID);
 
-    Debug::log(LOG, "New monitor: WORKSPACEID %d, exists: %d", WORKSPACEID, (int)(PNEWWORKSPACE != nullptr));
+    Debug::log(LOG, "New monitor: WORKSPACEID {}, exists: {}", WORKSPACEID, (int)(PNEWWORKSPACE != nullptr));
 
     if (PNEWWORKSPACE) {
         // workspace exists, move it to the newly connected monitor
@@ -392,15 +374,11 @@ void CMonitor::setupDefaultWS(const SMonitorRule& monitorRule) {
 
         PNEWWORKSPACE = g_pCompositor->m_vWorkspaces.emplace_back(std::make_unique<CWorkspace>(ID, newDefaultWorkspaceName)).get();
 
-        // We are required to set the name here immediately
-        wlr_ext_workspace_handle_v1_set_name(PNEWWORKSPACE->m_pWlrHandle, newDefaultWorkspaceName.c_str());
-
         PNEWWORKSPACE->m_iID = WORKSPACEID;
     }
 
     activeWorkspace = PNEWWORKSPACE->m_iID;
 
-    g_pCompositor->deactivateAllWLRWorkspaces(PNEWWORKSPACE->m_pWlrHandle);
     PNEWWORKSPACE->setActive(true);
     PNEWWORKSPACE->m_szLastMonitor = "";
 }
@@ -489,6 +467,8 @@ void CMonitor::setMirror(const std::string& mirrorOf) {
         // remove from mvmonitors
         std::erase_if(g_pCompositor->m_vMonitors, [&](const auto& other) { return other.get() == this; });
 
+        g_pCompositor->arrangeMonitors();
+
         g_pCompositor->setActiveMonitor(g_pCompositor->m_vMonitors.front().get());
 
         g_pCompositor->sanityCheckWorkspaces();
@@ -513,25 +493,20 @@ float CMonitor::getDefaultScale() {
     return 1;
 }
 
-void CMonitor::changeWorkspace(CWorkspace* const pWorkspace, bool internal) {
+void CMonitor::changeWorkspace(CWorkspace* const pWorkspace, bool internal, bool noMouseMove) {
     if (!pWorkspace)
         return;
 
     if (pWorkspace->m_bIsSpecialWorkspace) {
         if (specialWorkspaceID != pWorkspace->m_iID) {
-            Debug::log(LOG, "changeworkspace on special, togglespecialworkspace to id %i", pWorkspace->m_iID);
+            Debug::log(LOG, "changeworkspace on special, togglespecialworkspace to id {}", pWorkspace->m_iID);
             g_pKeybindManager->m_mDispatchers["togglespecialworkspace"](pWorkspace->m_szName == "special" ? "" : pWorkspace->m_szName);
         }
         return;
     }
 
-    if (pWorkspace->m_iID == activeWorkspace) {
-        // in some cases (e.g. workspace from one monitor to another)
-        // we need to send this
-        g_pCompositor->deactivateAllWLRWorkspaces(pWorkspace->m_pWlrHandle);
-        pWorkspace->setActive(true);
+    if (pWorkspace->m_iID == activeWorkspace)
         return;
-    }
 
     const auto POLDWORKSPACE = g_pCompositor->getWorkspaceByID(activeWorkspace);
 
@@ -549,18 +524,29 @@ void CMonitor::changeWorkspace(CWorkspace* const pWorkspace, bool internal) {
             }
         }
 
+        static auto* const PFOLLOWMOUSE = &g_pConfigManager->getConfigValuePtr("input:follow_mouse")->intValue;
+
         if (const auto PLASTWINDOW = pWorkspace->getLastFocusedWindow(); PLASTWINDOW)
             g_pCompositor->focusWindow(PLASTWINDOW);
         else {
-            g_pCompositor->focusWindow(nullptr);
-            g_pInputManager->simulateMouseMovement();
+            CWindow* pWindow = nullptr;
+
+            if (*PFOLLOWMOUSE == 1)
+                pWindow = g_pCompositor->vectorToWindowIdeal(g_pInputManager->getMouseCoordsInternal());
+
+            if (!pWindow)
+                pWindow = g_pCompositor->getTopLeftWindowOnWorkspace(pWorkspace->m_iID);
+
+            if (!pWindow)
+                pWindow = g_pCompositor->getFirstWindowOnWorkspace(pWorkspace->m_iID);
+
+            g_pCompositor->focusWindow(pWindow);
         }
+        if (!noMouseMove)
+            g_pInputManager->simulateMouseMovement();
 
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
 
-        // set some flags and fire event
-        g_pCompositor->deactivateAllWLRWorkspaces(pWorkspace->m_pWlrHandle);
-        pWorkspace->setActive(true);
         g_pEventManager->postEvent(SHyprIPCEvent{"workspace", pWorkspace->m_szName});
         EMIT_HOOK_EVENT("workspace", pWorkspace);
     }
@@ -568,6 +554,8 @@ void CMonitor::changeWorkspace(CWorkspace* const pWorkspace, bool internal) {
     g_pHyprRenderer->damageMonitor(this);
 
     g_pCompositor->updateFullscreenFadeOnWorkspace(pWorkspace);
+
+    g_pConfigManager->ensureVRR(this);
 }
 
 void CMonitor::changeWorkspace(const int& id, bool internal) {
@@ -579,8 +567,10 @@ void CMonitor::setSpecialWorkspace(CWorkspace* const pWorkspace) {
 
     if (!pWorkspace) {
         // remove special if exists
-        if (const auto EXISTINGSPECIAL = g_pCompositor->getWorkspaceByID(specialWorkspaceID); EXISTINGSPECIAL)
+        if (const auto EXISTINGSPECIAL = g_pCompositor->getWorkspaceByID(specialWorkspaceID); EXISTINGSPECIAL) {
             EXISTINGSPECIAL->startAnim(false, false);
+            g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + szName});
+        }
         specialWorkspaceID = 0;
 
         g_pLayoutManager->getCurrentLayout()->recalculateMonitor(ID);
@@ -599,10 +589,21 @@ void CMonitor::setSpecialWorkspace(CWorkspace* const pWorkspace) {
             EXISTINGSPECIAL->startAnim(false, false);
     }
 
+    bool animate = true;
+    //close if open elsewhere
+    const auto PMONITORWORKSPACEOWNER = g_pCompositor->getMonitorFromID(pWorkspace->m_iMonitorID);
+    if (PMONITORWORKSPACEOWNER->specialWorkspaceID == pWorkspace->m_iID) {
+        PMONITORWORKSPACEOWNER->specialWorkspaceID = 0;
+        g_pLayoutManager->getCurrentLayout()->recalculateMonitor(PMONITORWORKSPACEOWNER->ID);
+        g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", "," + PMONITORWORKSPACEOWNER->szName});
+        animate = false;
+    }
+
     // open special
     pWorkspace->m_iMonitorID = ID;
     specialWorkspaceID       = pWorkspace->m_iID;
-    pWorkspace->startAnim(true, true);
+    if (animate)
+        pWorkspace->startAnim(true, true);
 
     for (auto& w : g_pCompositor->m_vWindows) {
         if (w->m_iWorkspaceID == pWorkspace->m_iID) {
@@ -617,8 +618,23 @@ void CMonitor::setSpecialWorkspace(CWorkspace* const pWorkspace) {
         g_pCompositor->focusWindow(PLAST);
     else
         g_pInputManager->refocus();
+
+    g_pEventManager->postEvent(SHyprIPCEvent{"activespecial", pWorkspace->m_szName + "," + szName});
+
+    g_pHyprRenderer->damageMonitor(this);
 }
 
 void CMonitor::setSpecialWorkspace(const int& id) {
     setSpecialWorkspace(g_pCompositor->getWorkspaceByID(id));
 }
+
+void CMonitor::moveTo(const Vector2D& pos) {
+    vecPosition = pos;
+
+    if (!isMirror())
+        wlr_output_layout_add(g_pCompositor->m_sWLROutputLayout, output, (int)vecPosition.x, (int)vecPosition.y);
+}
+
+Vector2D CMonitor::middle() {
+    return vecPosition + vecSize / 2.f;
+}

src/helpers/Monitor.hpp

@@ -9,18 +9,32 @@
 #include <xf86drmMode.h>
 #include "Timer.hpp"
 #include "Region.hpp"
+#include <optional>
 
-struct SMonitorRule;
+struct SMonitorRule {
+    std::string         name        = "";
+    Vector2D            resolution  = Vector2D(1280, 720);
+    Vector2D            offset      = Vector2D(0, 0);
+    float               scale       = 1;
+    float               refreshRate = 60;
+    bool                disabled    = false;
+    wl_output_transform transform   = WL_OUTPUT_TRANSFORM_NORMAL;
+    std::string         mirrorOf    = "";
+    bool                enable10bit = false;
+    drmModeModeInfo     drmMode     = {};
+    std::optional<int>  vrr;
+};
 
 class CMonitor {
   public:
     CMonitor();
     ~CMonitor();
 
-    Vector2D        vecPosition        = Vector2D(-1, -1); // means unset
-    Vector2D        vecSize            = Vector2D(0, 0);
-    Vector2D        vecPixelSize       = Vector2D(0, 0);
-    Vector2D        vecTransformedSize = Vector2D(0, 0);
+    Vector2D        vecPosition         = Vector2D(-1, -1); // means unset
+    Vector2D        vecXWaylandPosition = Vector2D(-1, -1); // means unset
+    Vector2D        vecSize             = Vector2D(0, 0);
+    Vector2D        vecPixelSize        = Vector2D(0, 0);
+    Vector2D        vecTransformedSize  = Vector2D(0, 0);
 
     bool            primary = false;
 
@@ -45,6 +59,7 @@ class CMonitor {
     bool                scheduledRecalc = false;
     wl_output_transform transform       = WL_OUTPUT_TRANSFORM_NORMAL;
     bool                gammaChanged    = false;
+    float               xwaylandScale   = 1.f;
 
     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.
@@ -58,12 +73,26 @@ class CMonitor {
     bool                RATScheduled = false;
     CTimer              lastPresentationTimer;
 
+    SMonitorRule        activeMonitorRule;
+
     // mirroring
     CMonitor*              pMirrorOf = nullptr;
     std::vector<CMonitor*> mirrors;
 
     CRegion                lastFrameDamage; // stores last frame damage
 
+    // for tearing
+    CWindow* solitaryClient = nullptr;
+
+    struct {
+        bool canTear         = false;
+        bool nextRenderTorn  = false;
+        bool activelyTearing = false;
+
+        bool busy                    = false;
+        bool frameScheduledWhileBusy = false;
+    } tearingState;
+
     // for the special workspace. 0 means not open.
     int                                                        specialWorkspaceID = 0;
 
@@ -77,10 +106,6 @@ class CMonitor {
     DYNLISTENER(monitorCommit);
     DYNLISTENER(monitorBind);
 
-    // hack: a group = workspaces on a monitor.
-    // I don't really care lol :P
-    wlr_ext_workspace_group_handle_v1* pWLRWorkspaceGroupHandle = nullptr;
-
     // methods
     void                       onConnect(bool noRule);
     void                       onDisconnect();
@@ -90,10 +115,12 @@ class CMonitor {
     void                       setMirror(const std::string&);
     bool                       isMirror();
     float                      getDefaultScale();
-    void                       changeWorkspace(CWorkspace* const pWorkspace, bool internal = false);
+    void                       changeWorkspace(CWorkspace* const pWorkspace, bool internal = false, bool noMouseMove = false);
     void                       changeWorkspace(const int& id, bool internal = false);
     void                       setSpecialWorkspace(CWorkspace* const pWorkspace);
     void                       setSpecialWorkspace(const int& id);
+    void                       moveTo(const Vector2D& pos);
+    Vector2D                   middle();
 
     std::shared_ptr<CMonitor>* m_pThisWrap            = nullptr;
     bool                       m_bEnabled             = false;

src/helpers/Region.cpp

@@ -1,5 +1,8 @@
 #include "Region.hpp"
+extern "C" {
 #include <wlr/util/box.h>
+#include <wlr/util/region.h>
+}
 
 CRegion::CRegion() {
     pixman_region32_init(&m_rRegion);
@@ -81,6 +84,11 @@ CRegion& CRegion::translate(const Vector2D& vec) {
     return *this;
 }
 
+CRegion& CRegion::scale(float scale) {
+    wlr_region_scale(&m_rRegion, &m_rRegion, scale);
+    return *this;
+}
+
 std::vector<pixman_box32_t> CRegion::getRects() const {
     std::vector<pixman_box32_t> result;
 
@@ -92,6 +100,46 @@ std::vector<pixman_box32_t> CRegion::getRects() const {
     return result;
 }
 
-bool CRegion::empty() {
+wlr_box CRegion::getExtents() {
+    pixman_box32_t* box = pixman_region32_extents(&m_rRegion);
+    return {box->x1, box->y1, box->x2 - box->x1, box->y2 - box->y1};
+}
+
+bool CRegion::containsPoint(const Vector2D& vec) const {
+    return pixman_region32_contains_point(&m_rRegion, vec.x, vec.y, nullptr);
+}
+
+bool CRegion::empty() const {
     return !pixman_region32_not_empty(&m_rRegion);
 }
+
+Vector2D CRegion::closestPoint(const Vector2D& vec) const {
+    double   bestDist = __FLT_MAX__;
+    Vector2D leader   = vec;
+
+    for (auto& box : getRects()) {
+        double x = 0, y = 0;
+
+        if (vec.x >= box.x2)
+            x = box.x2 - 1;
+        else if (vec.x < box.x1)
+            x = box.x1;
+        else
+            x = vec.x;
+
+        if (vec.y >= box.y2)
+            y = box.y2 - 1;
+        else if (vec.y < box.y1)
+            y = box.y1;
+        else
+            y = vec.y;
+
+        double distance = sqrt(pow(x, 2) + pow(y, 2));
+        if (distance < bestDist) {
+            bestDist = distance;
+            leader   = {x, y};
+        }
+    }
+
+    return leader;
+}

src/helpers/Region.hpp

@@ -42,14 +42,18 @@ class CRegion {
     CRegion&                    intersect(double x, double y, double w, double h);
     CRegion&                    translate(const Vector2D& vec);
     CRegion&                    invert(pixman_box32_t* box);
-    bool                        empty();
+    CRegion&                    scale(float scale);
+    wlr_box                     getExtents();
+    bool                        containsPoint(const Vector2D& vec) const;
+    bool                        empty() const;
+    Vector2D                    closestPoint(const Vector2D& vec) const;
 
     std::vector<pixman_box32_t> getRects() const;
 
     pixman_region32_t*          pixman() {
-        return &m_rRegion;
+                 return &m_rRegion;
     }
 
   private:
     pixman_region32_t m_rRegion;
-};
+};

src/helpers/Splashes.hpp

@@ -1,9 +1,10 @@
 #pragma once
 
-#include <array>
+#include <vector>
 #include <string>
 
 inline const std::vector<std::string> SPLASHES = {
+    // clang-format off
     "Woo, animations!",
     "It's like Hypr, but better.",
     "Release 1.0 when?",
@@ -60,4 +61,5 @@ inline const std::vector<std::string> SPLASHES = {
     "Thanks ThatOneCalculator!",
     "The AUR packages always work, except for the times they don't.",
     "Funny animation compositor woo"
+    // clang-format on
 };

src/helpers/SubsurfaceTree.cpp

@@ -55,7 +55,7 @@ SSurfaceTreeNode* createSubsurfaceNode(SSurfaceTreeNode* pParent, SSubsurface* p
     PNODE->pParent     = pParent;
     PNODE->pSubsurface = pSubsurface;
 
-    Debug::log(LOG, "Creating a subsurface Node! (pWindow: %lx)", pWindow);
+    Debug::log(LOG, "Creating a subsurface Node! {}", pWindow);
 
     return PNODE;
 }
@@ -63,7 +63,7 @@ SSurfaceTreeNode* createSubsurfaceNode(SSurfaceTreeNode* pParent, SSubsurface* p
 SSurfaceTreeNode* SubsurfaceTree::createTreeRoot(wlr_surface* pSurface, applyGlobalOffsetFn fn, void* data, CWindow* pWindow) {
     const auto PNODE = createTree(pSurface, pWindow);
 
-    Debug::log(LOG, "Creating a surfaceTree Root! (pWindow: %lx)", pWindow);
+    Debug::log(LOG, "Creating a surfaceTree Root! {}", pWindow);
 
     PNODE->offsetfn         = fn;
     PNODE->globalOffsetData = data;
@@ -83,7 +83,7 @@ void SubsurfaceTree::destroySurfaceTree(SSurfaceTreeNode* pNode) {
     }
 
     if (!exists) {
-        Debug::log(ERR, "Tried to remove a SurfaceTreeNode that doesn't exist?? (Node %lx)", pNode);
+        Debug::log(ERR, "Tried to remove a SurfaceTreeNode that doesn't exist?? (Node {:x})", (uintptr_t)pNode);
         return;
     }
 
@@ -145,7 +145,7 @@ void Events::listener_newSubsurfaceNode(void* owner, void* data) {
 
     const auto        PNEWSUBSURFACE = &pNode->childSubsurfaces.emplace_back();
 
-    Debug::log(LOG, "Added a new subsurface %lx", PSUBSURFACE);
+    Debug::log(LOG, "Added a new subsurface {:x}", (uintptr_t)PSUBSURFACE);
 
     PNEWSUBSURFACE->pSubsurface = PSUBSURFACE;
     PNEWSUBSURFACE->pParent     = pNode;
@@ -174,7 +174,7 @@ void Events::listener_mapSubsurface(void* owner, void* data) {
     if (subsurface->pChild)
         return;
 
-    Debug::log(LOG, "Subsurface %lx mapped", subsurface->pSubsurface);
+    Debug::log(LOG, "Subsurface {:x} mapped", (uintptr_t)subsurface->pSubsurface);
 
     subsurface->pChild = createSubsurfaceNode(subsurface->pParent, subsurface, subsurface->pSubsurface->surface, subsurface->pWindowOwner);
 }
@@ -182,7 +182,7 @@ void Events::listener_mapSubsurface(void* owner, void* data) {
 void Events::listener_unmapSubsurface(void* owner, void* data) {
     SSubsurface* subsurface = (SSubsurface*)owner;
 
-    Debug::log(LOG, "Subsurface %lx unmapped", subsurface);
+    Debug::log(LOG, "Subsurface {:x} unmapped", (uintptr_t)subsurface);
 
     if (subsurface->pSubsurface->surface == g_pCompositor->m_pLastFocus)
         g_pInputManager->releaseAllMouseButtons();
@@ -221,7 +221,7 @@ void Events::listener_commitSubsurface(void* owner, void* data) {
     if (!g_pHyprRenderer->shouldRenderWindow(pNode->pWindowOwner)) {
         static auto* const PLOGDAMAGE = &g_pConfigManager->getConfigValuePtr("debug:log_damage")->intValue;
         if (*PLOGDAMAGE)
-            Debug::log(LOG, "Refusing to commit damage from %lx because it's invisible.", pNode->pWindowOwner);
+            Debug::log(LOG, "Refusing to commit damage from {} because it's invisible.", pNode->pWindowOwner);
         return;
     }
 
@@ -245,6 +245,27 @@ void Events::listener_commitSubsurface(void* owner, void* data) {
 
     if (pNode->pSurface && pNode->pSurface->exists())
         g_pHyprRenderer->damageSurface(pNode->pSurface->wlr(), lx, ly, SCALE);
+
+    if (pNode->pWindowOwner) {
+        // tearing: if solitary, redraw it. This still might be a single surface window
+        const auto PMONITOR = g_pCompositor->getMonitorFromID(pNode->pWindowOwner->m_iMonitorID);
+        if (PMONITOR->solitaryClient == pNode->pWindowOwner && pNode->pWindowOwner->canBeTorn() && PMONITOR->tearingState.canTear &&
+            pNode->pSurface->wlr()->current.committed & WLR_SURFACE_STATE_BUFFER) {
+
+            CRegion damageBox;
+            wlr_surface_get_effective_damage(pNode->pSurface->wlr(), damageBox.pixman());
+
+            if (!damageBox.empty()) {
+
+                if (PMONITOR->tearingState.busy) {
+                    PMONITOR->tearingState.frameScheduledWhileBusy = true;
+                } else {
+                    PMONITOR->tearingState.nextRenderTorn = true;
+                    g_pHyprRenderer->renderMonitor(PMONITOR);
+                }
+            }
+        }
+    }
 }
 
 void Events::listener_destroySubsurface(void* owner, void* data) {
@@ -254,7 +275,7 @@ void Events::listener_destroySubsurface(void* owner, void* data) {
         SubsurfaceTree::destroySurfaceTree(subsurface->pChild);
     }
 
-    Debug::log(LOG, "Subsurface %lx destroyed", subsurface);
+    Debug::log(LOG, "Subsurface {:x} destroyed", (uintptr_t)subsurface);
 
     subsurface->hyprListener_destroy.removeCallback();
     subsurface->hyprListener_map.removeCallback();
@@ -266,7 +287,7 @@ void Events::listener_destroySubsurface(void* owner, void* data) {
 void Events::listener_destroySubsurfaceNode(void* owner, void* data) {
     SSurfaceTreeNode* pNode = (SSurfaceTreeNode*)owner;
 
-    Debug::log(LOG, "Subsurface Node %lx destroyed", pNode);
+    Debug::log(LOG, "Subsurface Node {:x} destroyed", (uintptr_t)pNode);
 
     for (auto& c : pNode->childSubsurfaces)
         destroySubsurface(&c);

src/helpers/SubsurfaceTree.hpp

@@ -26,7 +26,8 @@ struct SSurfaceTreeNode {
     void*                  globalOffsetData;
     CWindow*               pWindowOwner = nullptr;
 
-    bool                   operator==(const SSurfaceTreeNode& rhs) const {
+    //
+    bool operator==(const SSurfaceTreeNode& rhs) const {
         return pSurface == rhs.pSurface;
     }
 };
@@ -43,7 +44,8 @@ struct SSubsurface {
 
     CWindow* pWindowOwner = nullptr;
 
-    bool     operator==(const SSubsurface& rhs) const {
+    //
+    bool operator==(const SSubsurface& rhs) const {
         return pSubsurface == rhs.pSubsurface;
     }
 };

src/helpers/Timer.cpp

@@ -14,4 +14,8 @@ int CTimer::getMillis() {
 
 float CTimer::getSeconds() {
     return std::chrono::duration_cast<std::chrono::milliseconds>(getDuration()).count() / 1000.f;
+}
+
+const std::chrono::system_clock::time_point& CTimer::chrono() const {
+    return m_tpLastReset;
 }

src/helpers/Timer.hpp

@@ -1,12 +1,13 @@
 #pragma once
 
-#include "../defines.hpp"
+#include <chrono>
 
 class CTimer {
   public:
-    void  reset();
-    float getSeconds();
-    int   getMillis();
+    void                                         reset();
+    float                                        getSeconds();
+    int                                          getMillis();
+    const std::chrono::system_clock::time_point& chrono() const;
 
   private:
     std::chrono::system_clock::time_point m_tpLastReset;

src/helpers/VarList.cpp

@@ -0,0 +1,37 @@
+#include "MiscFunctions.hpp"
+#include "VarList.hpp"
+#include <ranges>
+#include <algorithm>
+
+CVarList::CVarList(const std::string& in, const size_t lastArgNo, const char delim, const bool removeEmpty) {
+    if (in.empty())
+        m_vArgs.emplace_back("");
+
+    std::string args{in};
+    size_t      idx = 0;
+    size_t      pos = 0;
+    std::ranges::replace_if(
+        args, [&](const char& c) { return delim == 's' ? std::isspace(c) : c == delim; }, 0);
+
+    for (const auto& s : args | std::views::split(0)) {
+        if (removeEmpty && s.empty())
+            continue;
+        if (++idx == lastArgNo) {
+            m_vArgs.emplace_back(removeBeginEndSpacesTabs(in.substr(pos)));
+            break;
+        }
+        pos += s.size() + 1;
+        m_vArgs.emplace_back(removeBeginEndSpacesTabs(std::string_view{s}.data()));
+    }
+}
+
+std::string CVarList::join(const std::string& joiner, size_t from, size_t to) const {
+    size_t      last = to == 0 ? size() : to;
+
+    std::string rolling;
+    for (size_t i = from; i < last; ++i) {
+        rolling += m_vArgs[i] + (i + 1 < last ? joiner : "");
+    }
+
+    return rolling;
+}

src/helpers/VarList.hpp

@@ -0,0 +1,45 @@
+#pragma once
+#include <vector>
+#include <string>
+#include "../macros.hpp"
+
+class CVarList {
+  public:
+    /** Split string into arg list
+        @param lastArgNo stop splitting after argv reaches maximum size, last arg will contain rest of unsplit args
+        @param delim if delimiter is 's', use std::isspace
+        @param removeEmpty remove empty args from argv
+    */
+    CVarList(const std::string& in, const size_t maxSize = 0, const char delim = ',', const bool removeEmpty = false);
+
+    ~CVarList() = default;
+
+    size_t size() const {
+        return m_vArgs.size();
+    }
+
+    std::string join(const std::string& joiner, size_t from = 0, size_t to = 0) const;
+
+    std::string operator[](const size_t& idx) const {
+        if (idx >= m_vArgs.size())
+            return "";
+        return m_vArgs[idx];
+    }
+
+    // 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;
+};

src/helpers/Vector2D.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
-#include <math.h>
+#include <cmath>
+#include <format>
+#include "../macros.hpp"
 
 class Vector2D {
   public:
@@ -43,6 +45,14 @@ class Vector2D {
         return Vector2D(this->x / a.x, this->y / a.y);
     }
 
+    bool operator>(const Vector2D& a) const {
+        return this->x > a.x && this->y > a.y;
+    }
+
+    bool operator<(const Vector2D& a) const {
+        return this->x < a.x && this->y < a.y;
+    }
+
     double   distance(const Vector2D& other) const;
 
     Vector2D clamp(const Vector2D& min, const Vector2D& max = Vector2D()) const;
@@ -51,3 +61,36 @@ class Vector2D {
 
     bool     inTriangle(const Vector2D& p1, const Vector2D& p2, const Vector2D& p3) const;
 };
+
+/**
+    format specification
+    - 'j', as json array
+    - 'X', same as std::format("{}x{}", vec.x, vec.y)
+    - number, floating point precision, use `0` to format as integer
+*/
+template <typename CharT>
+struct std::formatter<Vector2D, CharT> : std::formatter<CharT> {
+    bool        formatJson = false;
+    bool        formatX    = false;
+    std::string precision  = "";
+    FORMAT_PARSE(FORMAT_FLAG('j', formatJson) //
+                 FORMAT_FLAG('X', formatX)    //
+                 FORMAT_NUMBER(precision),
+                 Vector2D)
+
+    template <typename FormatContext>
+    auto format(const Vector2D& vec, FormatContext& ctx) const {
+        std::string formatString = precision.empty() ? "{}" : std::format("{{:.{}f}}", precision);
+
+        if (formatJson)
+            formatString = std::format("[{0}, {0}]", formatString);
+        else if (formatX)
+            formatString = std::format("{0}x{0}", formatString);
+        else
+            formatString = std::format("[Vector2D: x: {0}, y: {0}]", formatString);
+        try {
+            string buf = std::vformat(formatString, std::make_format_args(vec.x, vec.y));
+            return std::format_to(ctx.out(), "{}", buf);
+        } catch (std::format_error& e) { return std::format_to(ctx.out(), "[{}, {}]", vec.x, vec.y); }
+    }
+};

src/helpers/WLClasses.cpp

@@ -1,5 +1,6 @@
 #include "WLClasses.hpp"
 #include "../config/ConfigManager.hpp"
+#include "../Compositor.hpp"
 
 SLayerSurface::SLayerSurface() {
     alpha.create(AVARTYPE_FLOAT, g_pConfigManager->getAnimationPropertyConfig("fadeIn"), nullptr, AVARDAMAGE_ENTIRE);
@@ -12,13 +13,14 @@ void SLayerSurface::applyRules() {
     forceBlur        = false;
     ignoreAlpha      = false;
     ignoreAlphaValue = 0.f;
+    xray             = -1;
 
     for (auto& rule : g_pConfigManager->getMatchingRules(this)) {
         if (rule.rule == "noanim")
             noAnimations = true;
         else if (rule.rule == "blur")
             forceBlur = true;
-        else if (rule.rule.find("ignorealpha") == 0 || rule.rule.find("ignorezero") == 0) {
+        else if (rule.rule.starts_with("ignorealpha") || rule.rule.starts_with("ignorezero")) {
             const auto  FIRST_SPACE_POS = rule.rule.find_first_of(' ');
             std::string alphaValue      = "";
             if (FIRST_SPACE_POS != std::string::npos)
@@ -29,6 +31,87 @@ void SLayerSurface::applyRules() {
                 if (!alphaValue.empty())
                     ignoreAlphaValue = std::stof(alphaValue);
             } catch (...) { Debug::log(ERR, "Invalid value passed to ignoreAlpha"); }
+        } else if (rule.rule.starts_with("xray")) {
+            CVarList vars{rule.rule, 0, ' '};
+            try {
+                xray = configStringToInt(vars[1]);
+            } catch (...) {}
         }
     }
+}
+
+CRegion SConstraint::getLogicCoordsRegion() {
+    CRegion result;
+
+    if (!constraint)
+        return result;
+
+    const auto PWINDOWOWNER = g_pCompositor->getWindowFromSurface(constraint->surface);
+
+    if (!PWINDOWOWNER)
+        return result;
+
+    result.add(&constraint->region); // surface-local coords
+
+    if (!PWINDOWOWNER->m_bIsX11) {
+        result.translate(PWINDOWOWNER->m_vRealPosition.goalv());
+        return result;
+    }
+
+    const auto COORDS = PWINDOWOWNER->m_bIsMapped ? PWINDOWOWNER->m_vRealPosition.goalv() :
+                                                    g_pXWaylandManager->xwaylandToWaylandCoords({PWINDOWOWNER->m_uSurface.xwayland->x, PWINDOWOWNER->m_uSurface.xwayland->y});
+
+    const auto PMONITOR = PWINDOWOWNER->m_bIsMapped ? g_pCompositor->getMonitorFromID(PWINDOWOWNER->m_iMonitorID) : g_pCompositor->getMonitorFromVector(COORDS);
+
+    if (!PMONITOR)
+        return CRegion{};
+
+    result.scale(PMONITOR->xwaylandScale);
+
+    result.translate(COORDS);
+
+    return result;
+}
+
+Vector2D SConstraint::getLogicConstraintPos() {
+    if (!constraint)
+        return {};
+
+    const auto PWINDOWOWNER = g_pCompositor->getWindowFromSurface(constraint->surface);
+
+    if (!PWINDOWOWNER)
+        return {};
+
+    if (!PWINDOWOWNER->m_bIsX11)
+        return PWINDOWOWNER->m_vRealPosition.goalv();
+
+    const auto COORDS = PWINDOWOWNER->m_bIsMapped ? PWINDOWOWNER->m_vRealPosition.goalv() :
+                                                    g_pXWaylandManager->xwaylandToWaylandCoords({PWINDOWOWNER->m_uSurface.xwayland->x, PWINDOWOWNER->m_uSurface.xwayland->y});
+
+    return COORDS;
+}
+
+Vector2D SConstraint::getLogicConstraintSize() {
+    if (!constraint)
+        return {};
+
+    const auto PWINDOWOWNER = g_pCompositor->getWindowFromSurface(constraint->surface);
+
+    if (!PWINDOWOWNER)
+        return {};
+
+    if (!PWINDOWOWNER->m_bIsX11)
+        return PWINDOWOWNER->m_vRealSize.goalv();
+
+    const auto PMONITOR = PWINDOWOWNER->m_bIsMapped ?
+        g_pCompositor->getMonitorFromID(PWINDOWOWNER->m_iMonitorID) :
+        g_pCompositor->getMonitorFromVector(g_pXWaylandManager->xwaylandToWaylandCoords({PWINDOWOWNER->m_uSurface.xwayland->x, PWINDOWOWNER->m_uSurface.xwayland->y}));
+
+    if (!PMONITOR)
+        return {};
+
+    const auto SIZE = PWINDOWOWNER->m_bIsMapped ? PWINDOWOWNER->m_vRealSize.goalv() :
+                                                  Vector2D{PWINDOWOWNER->m_uSurface.xwayland->width, PWINDOWOWNER->m_uSurface.xwayland->height} * PMONITOR->xwaylandScale;
+
+    return SIZE;
 }

src/helpers/WLClasses.hpp

@@ -50,6 +50,7 @@ struct SLayerSurface {
     bool                      noAnimations  = false;
 
     bool                      forceBlur        = false;
+    int                       xray             = -1;
     bool                      ignoreAlpha      = false;
     float                     ignoreAlphaValue = 0.f;
 
@@ -165,13 +166,20 @@ struct SConstraint {
     SMouse*                    pMouse     = nullptr;
     wlr_pointer_constraint_v1* constraint = nullptr;
 
-    bool                       hintSet = false;
-    Vector2D                   positionHint; // the position hint, but will be set to the current cursor pos if not set.
+    bool                       active = false;
+
+    bool                       hintSet             = false;
+    Vector2D                   positionHint        = {-1, -1}; // the position hint, but will use cursorPosOnActivate if unset
+    Vector2D                   cursorPosOnActivate = {-1, -1};
 
     DYNLISTENER(setConstraintRegion);
     DYNLISTENER(destroyConstraint);
 
-    bool operator==(const SConstraint& b) const {
+    CRegion  getLogicCoordsRegion();
+    Vector2D getLogicConstraintPos();
+    Vector2D getLogicConstraintSize();
+
+    bool     operator==(const SConstraint& b) const {
         return constraint == b.constraint;
     }
 };
@@ -190,10 +198,14 @@ struct SXDGPopup {
     DYNLISTENER(mapPopupXDG);
     DYNLISTENER(unmapPopupXDG);
     DYNLISTENER(commitPopupXDG);
+    DYNLISTENER(repositionPopupXDG);
 
     double            lx;
     double            ly;
 
+    Vector2D          lastPos             = {};
+    bool              repositionRequested = false;
+
     SSurfaceTreeNode* pSurfaceTree = nullptr;
 
     // For the list lookup
@@ -241,7 +253,8 @@ struct STablet {
 
     std::string           name = "";
 
-    bool                  operator==(const STablet& b) const {
+    //
+    bool operator==(const STablet& b) const {
         return wlrDevice == b.wlrDevice;
     }
 };
@@ -303,8 +316,9 @@ struct SSwipeGesture {
 
     double      delta = 0;
 
-    float       avgSpeed    = 0;
-    int         speedPoints = 0;
+    int         initialDirection = 0;
+    float       avgSpeed         = 0;
+    int         speedPoints      = 0;
 
     CMonitor*   pMonitor = nullptr;
 };
@@ -379,3 +393,14 @@ struct SSwitchDevice {
         return pWlrDevice == other.pWlrDevice;
     }
 };
+
+struct STearingController {
+    wlr_tearing_control_v1* pWlrHint = nullptr;
+
+    DYNLISTENER(set);
+    DYNLISTENER(destroy);
+
+    bool operator==(const STearingController& other) {
+        return pWlrHint == other.pWlrHint;
+    }
+};

src/helpers/WLListener.cpp

@@ -2,11 +2,18 @@
 #include "MiscFunctions.hpp"
 #include <string>
 #include "../debug/Log.hpp"
+#include "Watchdog.hpp"
 
 void handleWrapped(wl_listener* listener, void* data) {
     CHyprWLListener::SWrapper* pWrap = wl_container_of(listener, pWrap, m_sListener);
 
-    pWrap->m_pSelf->emit(data);
+    g_pWatchdog->startWatching();
+
+    try {
+        pWrap->m_pSelf->emit(data);
+    } catch (std::exception& e) { Debug::log(ERR, "Listener {} timed out and was killed by Watchdog!!!", (uintptr_t)listener); }
+
+    g_pWatchdog->endWatching();
 }
 
 CHyprWLListener::CHyprWLListener(wl_signal* pSignal, std::function<void(void*, void*)> callback, void* pOwner) {
@@ -25,7 +32,7 @@ CHyprWLListener::~CHyprWLListener() {
 
 void CHyprWLListener::removeCallback() {
     if (isConnected()) {
-        Debug::log(LOG, "Callback %lx -> %lx, %s removed.", &m_pCallback, &m_pOwner, m_szAuthor.c_str());
+        Debug::log(LOG, "Callback {:x} -> {:x}, {} removed.", (uintptr_t)&m_pCallback, (uintptr_t)&m_pOwner, m_szAuthor);
         wl_list_remove(&m_swWrapper.m_sListener.link);
         wl_list_init(&m_swWrapper.m_sListener.link);
     }
@@ -50,4 +57,4 @@ void CHyprWLListener::initCallback(wl_signal* pSignal, std::function<void(void*,
 
 void CHyprWLListener::emit(void* data) {
     m_pCallback(m_pOwner, data);
-}
+}

src/helpers/WLListener.hpp

@@ -1,7 +1,8 @@
 #pragma once
 
-#include "../includes.hpp"
+#include <string>
 #include <functional>
+#include <wayland-server.h>
 
 class CHyprWLListener {
   public:
@@ -9,10 +10,10 @@ class CHyprWLListener {
     CHyprWLListener();
     ~CHyprWLListener();
 
-    CHyprWLListener(const CHyprWLListener&) = delete;
-    CHyprWLListener(CHyprWLListener&&)      = delete;
+    CHyprWLListener(const CHyprWLListener&)            = delete;
+    CHyprWLListener(CHyprWLListener&&)                 = delete;
     CHyprWLListener& operator=(const CHyprWLListener&) = delete;
-    CHyprWLListener& operator=(CHyprWLListener&&) = delete;
+    CHyprWLListener& operator=(CHyprWLListener&&)      = delete;
 
     void             initCallback(wl_signal*, std::function<void(void*, void*)>, void* owner, std::string author = "");
 

src/helpers/WLSurface.cpp

@@ -36,10 +36,12 @@ void CWLSurface::destroy() {
 
     if (g_pCompositor->m_pLastFocus == m_pWLRSurface)
         g_pCompositor->m_pLastFocus = nullptr;
+    if (g_pInputManager->m_pLastMouseSurface == m_pWLRSurface)
+        g_pInputManager->m_pLastMouseSurface = nullptr;
 
     m_pWLRSurface = nullptr;
 
-    Debug::log(LOG, "CWLSurface %lx called destroy()", this);
+    Debug::log(LOG, "CWLSurface {:x} called destroy()", (uintptr_t)this);
 }
 
 void CWLSurface::init() {
@@ -53,5 +55,5 @@ void CWLSurface::init() {
     hyprListener_destroy.initCallback(
         &m_pWLRSurface->events.destroy, [&](void* owner, void* data) { destroy(); }, this, "CWLSurface");
 
-    Debug::log(LOG, "CWLSurface %lx called init()", this);
+    Debug::log(LOG, "CWLSurface {:x} called init()", (uintptr_t)this);
 }

src/helpers/WLSurface.hpp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "../defines.hpp"
-
 class CWLSurface {
   public:
     CWLSurface() = default;
@@ -11,20 +10,20 @@ class CWLSurface {
     void assign(wlr_surface* pSurface);
     void unassign();
 
-    CWLSurface(const CWLSurface&) = delete;
-    CWLSurface(CWLSurface&&)      = delete;
+    CWLSurface(const CWLSurface&)             = delete;
+    CWLSurface(CWLSurface&&)                  = delete;
     CWLSurface&  operator=(const CWLSurface&) = delete;
-    CWLSurface&  operator=(CWLSurface&&) = delete;
+    CWLSurface&  operator=(CWLSurface&&)      = delete;
 
     wlr_surface* wlr() const;
     bool         exists() const;
 
     CWLSurface&  operator=(wlr_surface* pSurface) {
-        destroy();
-        m_pWLRSurface = pSurface;
-        init();
+         destroy();
+         m_pWLRSurface = pSurface;
+         init();
 
-        return *this;
+         return *this;
     }
 
     bool operator==(const CWLSurface& other) const {

src/helpers/Watchdog.cpp

@@ -0,0 +1,59 @@
+#include "Watchdog.hpp"
+#include <signal.h>
+#include "config/ConfigManager.hpp"
+
+CWatchdog::~CWatchdog() {
+    m_bExitThread = true;
+    m_bNotified   = true;
+    m_cvWatchdogCondition.notify_all();
+    m_pWatchdog.reset();
+}
+
+CWatchdog::CWatchdog() {
+    m_iMainThreadPID = pthread_self();
+
+    m_pWatchdog = std::make_unique<std::thread>([this] {
+        static auto* const PTIMEOUT = &g_pConfigManager->getConfigValuePtr("debug:watchdog_timeout")->intValue;
+
+        while (1337) {
+            std::unique_lock lk(m_mWatchdogMutex);
+
+            if (!m_bWillWatch)
+                m_cvWatchdogCondition.wait(lk, [this] { return m_bNotified; });
+            else {
+                if (m_cvWatchdogCondition.wait_for(lk, std::chrono::milliseconds((int)(*PTIMEOUT * 1000.0)), [this] { return m_bNotified; }) == false)
+                    pthread_kill(m_iMainThreadPID, SIGUSR1);
+            }
+
+            if (m_bExitThread)
+                break;
+
+            m_bWatching = false;
+            m_bNotified = false;
+        }
+    });
+
+    m_pWatchdog->detach();
+}
+
+void CWatchdog::startWatching() {
+    static auto* const PTIMEOUT = &g_pConfigManager->getConfigValuePtr("debug:watchdog_timeout")->intValue;
+
+    if (*PTIMEOUT == 0)
+        return;
+
+    m_tTriggered = std::chrono::high_resolution_clock::now();
+    m_bWillWatch = true;
+    m_bWatching  = true;
+
+    m_bNotified = true;
+    m_cvWatchdogCondition.notify_all();
+}
+
+void CWatchdog::endWatching() {
+    m_bWatching  = false;
+    m_bWillWatch = false;
+
+    m_bNotified = true;
+    m_cvWatchdogCondition.notify_all();
+}

src/helpers/Watchdog.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <memory>
+#include <chrono>
+#include <thread>
+#include <condition_variable>
+
+class CWatchdog {
+  public:
+    // must be called from the main thread
+    CWatchdog();
+    ~CWatchdog();
+
+    void startWatching();
+    void endWatching();
+
+  private:
+    std::chrono::high_resolution_clock::time_point m_tTriggered;
+
+    pthread_t                                      m_iMainThreadPID = 0;
+
+    bool                                           m_bWatching  = false;
+    bool                                           m_bWillWatch = false;
+
+    std::unique_ptr<std::thread>                   m_pWatchdog;
+    std::mutex                                     m_mWatchdogMutex;
+    bool                                           m_bNotified   = false;
+    bool                                           m_bExitThread = false;
+    std::condition_variable                        m_cvWatchdogCondition;
+};
+
+inline std::unique_ptr<CWatchdog> g_pWatchdog;

src/helpers/Workspace.cpp

@@ -13,18 +13,6 @@ CWorkspace::CWorkspace(int monitorID, std::string name, bool special) {
     m_szName              = name;
     m_bIsSpecialWorkspace = special;
 
-    if (!special) {
-        m_pWlrHandle = wlr_ext_workspace_handle_v1_create(PMONITOR->pWLRWorkspaceGroupHandle);
-
-        // set geometry here cuz we can
-        wl_array_init(&m_wlrCoordinateArr);
-        *reinterpret_cast<int*>(wl_array_add(&m_wlrCoordinateArr, sizeof(int))) = (int)PMONITOR->vecPosition.x;
-        *reinterpret_cast<int*>(wl_array_add(&m_wlrCoordinateArr, sizeof(int))) = (int)PMONITOR->vecPosition.y;
-        wlr_ext_workspace_handle_v1_set_coordinates(m_pWlrHandle, &m_wlrCoordinateArr);
-        wlr_ext_workspace_handle_v1_set_hidden(m_pWlrHandle, false);
-        wlr_ext_workspace_handle_v1_set_urgent(m_pWlrHandle, false);
-    }
-
     m_vRenderOffset.m_pWorkspace = this;
     m_vRenderOffset.create(AVARTYPE_VECTOR, special ? g_pConfigManager->getAnimationPropertyConfig("specialWorkspace") : g_pConfigManager->getAnimationPropertyConfig("workspaces"),
                            nullptr, AVARDAMAGE_ENTIRE);
@@ -43,13 +31,7 @@ CWorkspace::CWorkspace(int monitorID, std::string name, bool special) {
 CWorkspace::~CWorkspace() {
     m_vRenderOffset.unregister();
 
-    Debug::log(LOG, "Destroying workspace ID %d", m_iID);
-
-    if (m_pWlrHandle) {
-        wlr_ext_workspace_handle_v1_set_active(m_pWlrHandle, false);
-        wlr_ext_workspace_handle_v1_destroy(m_pWlrHandle);
-        m_pWlrHandle = nullptr;
-    }
+    Debug::log(LOG, "Destroying workspace ID {}", m_iID);
 
     g_pEventManager->postEvent({"destroyworkspace", m_szName});
     EMIT_HOOK_EVENT("destroyWorkspace", this);
@@ -58,7 +40,44 @@ CWorkspace::~CWorkspace() {
 void CWorkspace::startAnim(bool in, bool left, bool instant) {
     const auto ANIMSTYLE = m_fAlpha.m_pConfig->pValues->internalStyle;
 
-    if (ANIMSTYLE == "fade") {
+    if (ANIMSTYLE.starts_with("slidefade")) {
+        const auto PMONITOR = g_pCompositor->getMonitorFromID(m_iMonitorID);
+        float      movePerc = 100.f;
+
+        if (ANIMSTYLE.find("%") != std::string::npos) {
+            try {
+                auto percstr = ANIMSTYLE.substr(ANIMSTYLE.find_last_of(' ') + 1);
+                movePerc     = std::stoi(percstr.substr(0, percstr.length() - 1));
+            } catch (std::exception& e) { Debug::log(ERR, "Error in startAnim: invalid percentage"); }
+        }
+
+        m_fAlpha.setValueAndWarp(1.f);
+        m_vRenderOffset.setValueAndWarp(Vector2D(0, 0));
+
+        if (ANIMSTYLE.starts_with("slidefadevert")) {
+            if (in) {
+                m_fAlpha.setValueAndWarp(0.f);
+                m_vRenderOffset.setValueAndWarp(Vector2D(0, (left ? PMONITOR->vecSize.y : -PMONITOR->vecSize.y) * (movePerc / 100.f)));
+                m_fAlpha        = 1.f;
+                m_vRenderOffset = Vector2D(0, 0);
+            } else {
+                m_fAlpha.setValueAndWarp(1.f);
+                m_fAlpha        = 0.f;
+                m_vRenderOffset = Vector2D(0, (left ? -PMONITOR->vecSize.y : PMONITOR->vecSize.y) * (movePerc / 100.f));
+            }
+        } else {
+            if (in) {
+                m_fAlpha.setValueAndWarp(0.f);
+                m_vRenderOffset.setValueAndWarp(Vector2D((left ? PMONITOR->vecSize.x : -PMONITOR->vecSize.x) * (movePerc / 100.f), 0));
+                m_fAlpha        = 1.f;
+                m_vRenderOffset = Vector2D(0, 0);
+            } else {
+                m_fAlpha.setValueAndWarp(1.f);
+                m_fAlpha        = 0.f;
+                m_vRenderOffset = Vector2D((left ? -PMONITOR->vecSize.x : PMONITOR->vecSize.x) * (movePerc / 100.f), 0);
+            }
+        }
+    } else if (ANIMSTYLE == "fade") {
         m_vRenderOffset.setValueAndWarp(Vector2D(0, 0)); // fix a bug, if switching from slide -> fade.
 
         if (in) {
@@ -94,6 +113,17 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
         }
     }
 
+    if (m_bIsSpecialWorkspace) {
+        // required for open/close animations
+        if (in) {
+            m_fAlpha.setValueAndWarp(0.f);
+            m_fAlpha = 1.f;
+        } else {
+            m_fAlpha.setValueAndWarp(1.f);
+            m_fAlpha = 0.f;
+        }
+    }
+
     if (instant) {
         m_vRenderOffset.warp();
         m_fAlpha.warp();
@@ -101,31 +131,11 @@ void CWorkspace::startAnim(bool in, bool left, bool instant) {
 }
 
 void CWorkspace::setActive(bool on) {
-    if (m_pWlrHandle) {
-        wlr_ext_workspace_handle_v1_set_active(m_pWlrHandle, on);
-    }
+    ; // empty until https://gitlab.freedesktop.org/wayland/wayland-protocols/-/merge_requests/40
 }
 
 void CWorkspace::moveToMonitor(const int& id) {
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(id);
-
-    if (!PMONITOR || m_bIsSpecialWorkspace)
-        return;
-
-    wlr_ext_workspace_handle_v1_set_active(m_pWlrHandle, false);
-    wlr_ext_workspace_handle_v1_destroy(m_pWlrHandle);
-
-    m_pWlrHandle = wlr_ext_workspace_handle_v1_create(PMONITOR->pWLRWorkspaceGroupHandle);
-
-    // set geometry here cuz we can
-    wl_array_init(&m_wlrCoordinateArr);
-    *reinterpret_cast<int*>(wl_array_add(&m_wlrCoordinateArr, sizeof(int))) = (int)PMONITOR->vecPosition.x;
-    *reinterpret_cast<int*>(wl_array_add(&m_wlrCoordinateArr, sizeof(int))) = (int)PMONITOR->vecPosition.y;
-    wlr_ext_workspace_handle_v1_set_coordinates(m_pWlrHandle, &m_wlrCoordinateArr);
-    wlr_ext_workspace_handle_v1_set_hidden(m_pWlrHandle, false);
-    wlr_ext_workspace_handle_v1_set_urgent(m_pWlrHandle, false);
-
-    wlr_ext_workspace_handle_v1_set_name(m_pWlrHandle, m_szName.c_str());
+    ; // empty until https://gitlab.freedesktop.org/wayland/wayland-protocols/-/merge_requests/40
 }
 
 CWindow* CWorkspace::getLastFocusedWindow() {
@@ -142,7 +152,7 @@ void CWorkspace::rememberPrevWorkspace(const CWorkspace* prev) {
         return;
     }
 
-    if (prev->m_sPrevWorkspace.iID == m_sPrevWorkspace.iID) {
+    if (prev->m_iID == m_iID) {
         Debug::log(LOG, "Tried to set prev workspace to the same as current one");
         return;
     }

src/helpers/Workspace.hpp

@@ -1,11 +1,13 @@
 #pragma once
 
-#include "../defines.hpp"
 #include "AnimatedVariable.hpp"
+#include <string>
+#include "../defines.hpp"
 
-enum eFullscreenMode : uint8_t
+enum eFullscreenMode : int8_t
 {
-    FULLSCREEN_FULL = 0,
+    FULLSCREEN_INVALID = -1,
+    FULLSCREEN_FULL    = 0,
     FULLSCREEN_MAXIMIZED
 };
 
@@ -28,12 +30,10 @@ class CWorkspace {
         std::string name = "";
     } m_sPrevWorkspace;
 
-    bool                         m_bHasFullscreenWindow = false;
-    eFullscreenMode              m_efFullscreenMode     = FULLSCREEN_FULL;
+    bool            m_bHasFullscreenWindow = false;
+    eFullscreenMode m_efFullscreenMode     = FULLSCREEN_FULL;
 
-    wlr_ext_workspace_handle_v1* m_pWlrHandle = nullptr;
-
-    wl_array                     m_wlrCoordinateArr;
+    wl_array        m_wlrCoordinateArr;
 
     // for animations
     CAnimatedVariable m_vRenderOffset;
@@ -50,9 +50,6 @@ class CWorkspace {
     bool m_bDefaultFloating = false;
     bool m_bDefaultPseudo   = false;
 
-    // don't destroy in sanity check
-    bool m_bIndestructible = false;
-
     // last monitor (used on reconnect)
     std::string m_szLastMonitor = "";
 

src/helpers/XWaylandStubs.hpp

@@ -118,7 +118,6 @@ struct wlr_xwayland_surface {
         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;

src/includes.hpp

@@ -70,7 +70,7 @@ extern "C" {
 #include <wlr/types/wlr_xdg_output_v1.h>
 #include <wlr/types/wlr_xdg_shell.h>
 #include <wlr/types/wlr_subcompositor.h>
-#include <wlr/types/wlr_scene.h>
+#include <wlr/types/wlr_damage_ring.h>
 #include <wlr/types/wlr_input_inhibitor.h>
 #include <wlr/types/wlr_keyboard_shortcuts_inhibit_v1.h>
 #include <wlr/types/wlr_virtual_pointer_v1.h>
@@ -105,6 +105,7 @@ extern "C" {
 #include <wlr/types/wlr_single_pixel_buffer_v1.h>
 #include <wlr/types/wlr_idle_notify_v1.h>
 #include <wlr/types/wlr_cursor_shape_v1.h>
+#include <wlr/types/wlr_tearing_control_v1.h>
 
 #include <libdrm/drm_fourcc.h>
 
@@ -145,6 +146,3 @@ extern "C" {
 #endif
 
 #include "helpers/Vector2D.hpp"
-
-#include "ext-workspace-unstable-v1-protocol.h"
-#include "wlrunstable/wlr_ext_workspace_v1.hpp"

src/layout/DwindleLayout.cpp

@@ -1,11 +1,9 @@
 #include "DwindleLayout.hpp"
+#include "../render/decorations/CHyprGroupBarDecoration.hpp"
 #include "../Compositor.hpp"
 
 void SDwindleNodeData::recalcSizePosRecursive(bool force, bool horizontalOverride, bool verticalOverride) {
     if (children[0]) {
-
-        const auto         REVERSESPLITRATIO = 2.f - splitRatio;
-
         static auto* const PSMARTSPLIT    = &g_pConfigManager->getConfigValuePtr("dwindle:smart_split")->intValue;
         static auto* const PPRESERVESPLIT = &g_pConfigManager->getConfigValuePtr("dwindle:preserve_split")->intValue;
         static auto* const PFLMULT        = &g_pConfigManager->getConfigValuePtr("dwindle:split_width_multiplier")->floatValue;
@@ -23,16 +21,18 @@ void SDwindleNodeData::recalcSizePosRecursive(bool force, bool horizontalOverrid
 
         if (SPLITSIDE) {
             // split left/right
+            int const FIRSTSIZE   = std::round(size.x / 2 * splitRatio);
             children[0]->position = position;
-            children[0]->size     = Vector2D(size.x / 2.f * splitRatio, size.y);
-            children[1]->position = Vector2D(position.x + size.x / 2.f * splitRatio, position.y);
-            children[1]->size     = Vector2D(size.x / 2.f * REVERSESPLITRATIO, size.y);
+            children[0]->size     = Vector2D(FIRSTSIZE, size.y);
+            children[1]->position = Vector2D(position.x + FIRSTSIZE, position.y);
+            children[1]->size     = Vector2D(size.x - FIRSTSIZE, size.y);
         } else {
             // split top/bottom
+            int const FIRSTSIZE   = std::round(size.y / 2 * splitRatio);
             children[0]->position = position;
-            children[0]->size     = Vector2D(size.x, size.y / 2.f * splitRatio);
-            children[1]->position = Vector2D(position.x, position.y + size.y / 2.f * splitRatio);
-            children[1]->size     = Vector2D(size.x, size.y / 2.f * REVERSESPLITRATIO);
+            children[0]->size     = Vector2D(size.x, FIRSTSIZE);
+            children[1]->position = Vector2D(position.x, position.y + FIRSTSIZE);
+            children[1]->size     = Vector2D(size.x, size.y - FIRSTSIZE);
         }
 
         children[0]->recalcSizePosRecursive(force);
@@ -104,7 +104,7 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
     }
 
     if (!PMONITOR) {
-        Debug::log(ERR, "Orphaned Node %lx (workspace ID: %i)!!", pNode, pNode->workspaceID);
+        Debug::log(ERR, "Orphaned Node {}!!", pNode);
         return;
     }
 
@@ -117,24 +117,19 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
     const auto PWINDOW = pNode->pWindow;
     // get specific gaps and rules for this workspace,
     // if user specified them in config
-    const auto         WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID));
+    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID));
 
-    static auto* const PGAPSIN     = &g_pConfigManager->getConfigValuePtr("general:gaps_in")->intValue;
-    static auto* const PGAPSOUT    = &g_pConfigManager->getConfigValuePtr("general:gaps_out")->intValue;
-    static auto* const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+    PWINDOW->updateSpecialRenderData();
+
+    static auto* const PGAPSIN         = &g_pConfigManager->getConfigValuePtr("general:gaps_in")->intValue;
+    static auto* const PGAPSOUT        = &g_pConfigManager->getConfigValuePtr("general:gaps_out")->intValue;
+    static auto* const PNOGAPSWHENONLY = &g_pConfigManager->getConfigValuePtr("dwindle:no_gaps_when_only")->intValue;
 
     auto               gapsIn  = WORKSPACERULE.gapsIn.value_or(*PGAPSIN);
     auto               gapsOut = WORKSPACERULE.gapsOut.value_or(*PGAPSOUT);
-    auto               borderSize =
-        PWINDOW->m_sSpecialRenderData.borderSize.toUnderlying() != -1 ? PWINDOW->m_sSpecialRenderData.borderSize.toUnderlying() : WORKSPACERULE.borderSize.value_or(*PBORDERSIZE);
-
-    if (PWINDOW->m_sAdditionalConfigData.borderSize.toUnderlying() != -1)
-        borderSize = PWINDOW->m_sAdditionalConfigData.borderSize.toUnderlying();
-
-    borderSize *= PWINDOW->m_sSpecialRenderData.border && !PWINDOW->m_sAdditionalConfigData.forceNoBorder;
 
     if (!g_pCompositor->windowExists(PWINDOW) || !PWINDOW->m_bIsMapped) {
-        Debug::log(ERR, "Node %lx holding invalid window %lx!!", pNode, PWINDOW);
+        Debug::log(ERR, "Node {} holding invalid {}!!", pNode, PWINDOW);
         onWindowRemovedTiling(PWINDOW);
         return;
     }
@@ -142,36 +137,32 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
     PWINDOW->m_vSize     = pNode->size;
     PWINDOW->m_vPosition = pNode->position;
 
-    static auto* const PNOGAPSWHENONLY = &g_pConfigManager->getConfigValuePtr("dwindle:no_gaps_when_only")->intValue;
-
-    const auto         NODESONWORKSPACE = getNodesOnWorkspace(PWINDOW->m_iWorkspaceID);
+    const auto NODESONWORKSPACE = getNodesOnWorkspace(PWINDOW->m_iWorkspaceID);
 
     if (*PNOGAPSWHENONLY && !g_pCompositor->isWorkspaceSpecial(PWINDOW->m_iWorkspaceID) &&
         (NODESONWORKSPACE == 1 || (PWINDOW->m_bIsFullscreen && g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_efFullscreenMode == FULLSCREEN_MAXIMIZED))) {
 
-        PWINDOW->m_sSpecialRenderData.rounding = false;
-        PWINDOW->m_sSpecialRenderData.decorate = WORKSPACERULE.decorate.value_or(true);
         PWINDOW->m_sSpecialRenderData.border   = WORKSPACERULE.border.value_or(*PNOGAPSWHENONLY == 2);
+        PWINDOW->m_sSpecialRenderData.decorate = WORKSPACERULE.decorate.value_or(true);
+        PWINDOW->m_sSpecialRenderData.rounding = false;
+        PWINDOW->m_sSpecialRenderData.shadow   = false;
 
         const auto RESERVED = PWINDOW->getFullWindowReservedArea();
 
-        borderSize *= PWINDOW->m_sSpecialRenderData.border;
+        const int  BORDERSIZE = PWINDOW->getRealBorderSize();
 
-        PWINDOW->m_vRealPosition = PWINDOW->m_vPosition + Vector2D(borderSize, borderSize) + RESERVED.topLeft;
-        PWINDOW->m_vRealSize     = PWINDOW->m_vSize - Vector2D(2 * borderSize, 2 * borderSize) - (RESERVED.topLeft + RESERVED.bottomRight);
+        PWINDOW->m_vRealPosition = PWINDOW->m_vPosition + Vector2D(BORDERSIZE, BORDERSIZE) + RESERVED.topLeft;
+        PWINDOW->m_vRealSize     = PWINDOW->m_vSize - Vector2D(2 * BORDERSIZE, 2 * BORDERSIZE) - (RESERVED.topLeft + RESERVED.bottomRight);
 
         PWINDOW->updateWindowDecos();
 
         return;
     }
 
-    PWINDOW->m_sSpecialRenderData.rounding   = WORKSPACERULE.rounding.value_or(true);
-    PWINDOW->m_sSpecialRenderData.decorate   = WORKSPACERULE.decorate.value_or(true);
-    PWINDOW->m_sSpecialRenderData.border     = WORKSPACERULE.border.value_or(true);
-    PWINDOW->m_sSpecialRenderData.borderSize = WORKSPACERULE.borderSize.value_or(-1);
+    const int  BORDERSIZE = PWINDOW->getRealBorderSize();
 
-    auto       calcPos  = PWINDOW->m_vPosition + Vector2D(borderSize, borderSize);
-    auto       calcSize = PWINDOW->m_vSize - Vector2D(2 * borderSize, 2 * borderSize);
+    auto       calcPos  = PWINDOW->m_vPosition + Vector2D(BORDERSIZE, BORDERSIZE);
+    auto       calcSize = PWINDOW->m_vSize - Vector2D(2 * BORDERSIZE, 2 * BORDERSIZE);
 
     const auto OFFSETTOPLEFT = Vector2D(DISPLAYLEFT ? gapsOut : gapsIn, DISPLAYTOP ? gapsOut : gapsIn);
 
@@ -235,7 +226,7 @@ void CHyprDwindleLayout::applyNodeDataToWindow(SDwindleNodeData* pNode, bool for
     PWINDOW->updateWindowDecos();
 }
 
-void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
+void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow, eDirection direction) {
     if (pWindow->m_bIsFloating)
         return;
 
@@ -247,6 +238,9 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     static auto* const PUSEACTIVE    = &g_pConfigManager->getConfigValuePtr("dwindle:use_active_for_splits")->intValue;
     static auto* const PDEFAULTSPLIT = &g_pConfigManager->getConfigValuePtr("dwindle:default_split_ratio")->floatValue;
 
+    if (direction != DIRECTION_DEFAULT && overrideDirection == DIRECTION_DEFAULT)
+        overrideDirection = direction;
+
     // Populate the node with our window's data
     PNODE->workspaceID = pWindow->m_iWorkspaceID;
     PNODE->pWindow     = pWindow;
@@ -254,11 +248,13 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     PNODE->layout      = this;
 
     SDwindleNodeData* OPENINGON;
-    const auto        MONFROMCURSOR = g_pCompositor->getMonitorFromCursor();
+
+    const auto        MOUSECOORDS   = m_vOverrideFocalPoint.value_or(g_pInputManager->getMouseCoordsInternal());
+    const auto        MONFROMCURSOR = g_pCompositor->getMonitorFromVector(MOUSECOORDS);
 
     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()));
+        OPENINGON = getNodeFromWindow(g_pCompositor->vectorToWindowTiled(MOUSECOORDS));
 
         // happens on reserved area
         if (!OPENINGON && g_pCompositor->getWindowsOnWorkspace(PNODE->workspaceID) > 0)
@@ -269,7 +265,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* 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()));
+            OPENINGON = getNodeFromWindow(g_pCompositor->vectorToWindowTiled(MOUSECOORDS));
         }
 
         if (!OPENINGON && g_pCompositor->getWindowsOnWorkspace(PNODE->workspaceID) > 0)
@@ -277,7 +273,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     } else
         OPENINGON = getFirstNodeOnWorkspace(pWindow->m_iWorkspaceID);
 
-    Debug::log(LOG, "OPENINGON: %lx, Workspace: %i, Monitor: %i", OPENINGON, PNODE->workspaceID, PMONITOR->ID);
+    Debug::log(LOG, "OPENINGON: {}, Monitor: {}", OPENINGON, PMONITOR->ID);
 
     if (OPENINGON && OPENINGON->workspaceID != PNODE->workspaceID) {
         // special workspace handling
@@ -294,17 +290,10 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
         return;
     }
 
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
-
-    if (PWORKSPACE->m_bHasFullscreenWindow) {
-        const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
-        g_pCompositor->setWindowFullscreen(PFULLWINDOW, false, FULLSCREEN_FULL);
-    }
-
     // last fail-safe to avoid duplicate fullscreens
     if ((!OPENINGON || OPENINGON->pWindow == pWindow) && getNodesOnWorkspace(PNODE->workspaceID) > 1) {
         for (auto& node : m_lDwindleNodesData) {
-            if (node.workspaceID == PNODE->workspaceID && node.pWindow != pWindow) {
+            if (node.workspaceID == PNODE->workspaceID && node.pWindow != nullptr && node.pWindow != pWindow) {
                 OPENINGON = &node;
                 break;
             }
@@ -318,37 +307,45 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
 
         applyNodeDataToWindow(PNODE);
 
+        pWindow->applyGroupRules();
+
         return;
     }
 
     // if it's a group, add the window
-    if (OPENINGON->pWindow->m_sGroupData.pNextWindow && !OPENINGON->pWindow->getGroupHead()->m_sGroupData.locked &&
-        !g_pKeybindManager->m_bGroupsLocked) { // target is an unlocked group
-
-        if (!pWindow->m_sGroupData.pNextWindow) { // source is not a group
-            m_lDwindleNodesData.remove(*PNODE);
-            OPENINGON->pWindow->insertWindowToGroup(pWindow);
-            OPENINGON->pWindow->setGroupCurrent(pWindow);
-
+    if (OPENINGON->pWindow->m_sGroupData.pNextWindow                                                      // target is group
+        && !g_pKeybindManager->m_bGroupsLocked                                                            // global group lock disengaged
+        && ((pWindow->m_eGroupRules & GROUP_INVADE && pWindow->m_bFirstMap)                               // window ignore local group locks, or
+            || (!OPENINGON->pWindow->getGroupHead()->m_sGroupData.locked                                  //    target unlocked
+                && !(pWindow->m_sGroupData.pNextWindow && pWindow->getGroupHead()->m_sGroupData.locked))) //    source unlocked or isn't group
+        && !pWindow->m_sGroupData.deny                                                                    // source is not denied entry
+        && !(pWindow->m_eGroupRules & GROUP_BARRED && pWindow->m_bFirstMap)                               // group rule doesn't prevent adding window
+        && !m_vOverrideFocalPoint                                                                         // we are not moving window
+    ) {
+        if (!pWindow->m_sGroupData.pNextWindow)
             pWindow->m_dWindowDecorations.emplace_back(std::make_unique<CHyprGroupBarDecoration>(pWindow));
-            pWindow->updateWindowDecos();
-            recalculateWindow(pWindow);
 
-            g_pCompositor->focusWindow(pWindow);
-            return;
+        m_lDwindleNodesData.remove(*PNODE);
+
+        const wlr_box box = OPENINGON->pWindow->getDecorationByType(DECORATION_GROUPBAR)->getWindowDecorationRegion().getExtents();
+        if (wlr_box_contains_point(&box, MOUSECOORDS.x, MOUSECOORDS.y)) { // TODO: Deny when not using mouse
+            const int SIZE               = OPENINGON->pWindow->getGroupSize();
+            const int INDEX              = (int)((MOUSECOORDS.x - box.x) * 2 * SIZE / box.width + 1) / 2 - 1;
+            CWindow*  pWindowInsertAfter = OPENINGON->pWindow->getGroupWindowByIndex(INDEX);
+            pWindowInsertAfter->insertWindowToGroup(pWindow);
+            if (INDEX == -1)
+                std::swap(pWindow->m_sGroupData.pNextWindow->m_sGroupData.head, pWindow->m_sGroupData.head);
+        } else {
+            static const auto* USECURRPOS = &g_pConfigManager->getConfigValuePtr("group:insert_after_current")->intValue;
+            (*USECURRPOS ? OPENINGON->pWindow : OPENINGON->pWindow->getGroupTail())->insertWindowToGroup(pWindow);
         }
 
-        if (!pWindow->getGroupHead()->m_sGroupData.locked) { // source is an unlocked group
-            m_lDwindleNodesData.remove(*PNODE);
-            OPENINGON->pWindow->insertWindowToGroup(pWindow);
-            OPENINGON->pWindow->setGroupCurrent(pWindow);
+        OPENINGON->pWindow->setGroupCurrent(pWindow);
+        pWindow->applyGroupRules();
+        pWindow->updateWindowDecos();
+        recalculateWindow(pWindow);
 
-            pWindow->updateWindowDecos();
-            recalculateWindow(pWindow);
-
-            g_pCompositor->focusWindow(pWindow);
-            return;
-        }
+        return;
     }
 
     // If it's not, get the node under our cursor
@@ -370,8 +367,6 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     const auto SIDEBYSIDE = NEWPARENT->size.x > NEWPARENT->size.y * *PWIDTHMULTIPLIER;
     NEWPARENT->splitTop   = !SIDEBYSIDE;
 
-    const auto         MOUSECOORDS = g_pInputManager->getMouseCoordsInternal();
-
     static auto* const PFORCESPLIT                = &g_pConfigManager->getConfigValuePtr("dwindle:force_split")->intValue;
     static auto* const PERMANENTDIRECTIONOVERRIDE = &g_pConfigManager->getConfigValuePtr("dwindle:permanent_direction_override")->intValue;
     static auto* const PSMARTSPLIT                = &g_pConfigManager->getConfigValuePtr("dwindle:smart_split")->intValue;
@@ -380,7 +375,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
     bool               verticalOverride   = false;
 
     // let user select position -> top, right, bottom, left
-    if (overrideDirection != OneTimeFocus::NOFOCUS) {
+    if (overrideDirection != DIRECTION_DEFAULT) {
 
         // this is horizontal
         if (overrideDirection % 2 == 0)
@@ -399,7 +394,7 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
 
         // whether or not the override persists after opening one window
         if (*PERMANENTDIRECTIONOVERRIDE == 0)
-            overrideDirection = OneTimeFocus::NOFOCUS;
+            overrideDirection = DIRECTION_DEFAULT;
     } else if (*PSMARTSPLIT == 1) {
         const auto tl = NEWPARENT->position;
         const auto tr = NEWPARENT->position + Vector2D(NEWPARENT->size.x, 0);
@@ -478,8 +473,9 @@ void CHyprDwindleLayout::onWindowCreatedTiling(CWindow* pWindow) {
 
     NEWPARENT->recalcSizePosRecursive(false, horizontalOverride, verticalOverride);
 
-    applyNodeDataToWindow(PNODE);
-    applyNodeDataToWindow(OPENINGON);
+    recalculateMonitor(pWindow->m_iMonitorID);
+
+    pWindow->applyGroupRules();
 }
 
 void CHyprDwindleLayout::onWindowRemovedTiling(CWindow* pWindow) {
@@ -491,9 +487,7 @@ void CHyprDwindleLayout::onWindowRemovedTiling(CWindow* pWindow) {
         return;
     }
 
-    pWindow->m_sSpecialRenderData.rounding = true;
-    pWindow->m_sSpecialRenderData.border   = true;
-    pWindow->m_sSpecialRenderData.decorate = true;
+    pWindow->updateSpecialRenderData();
 
     if (pWindow->m_bIsFullscreen)
         g_pCompositor->setWindowFullscreen(pWindow, false, FULLSCREEN_FULL);
@@ -674,10 +668,10 @@ void CHyprDwindleLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorn
         SDwindleNodeData* PHOUTER = nullptr;
         SDwindleNodeData* PHINNER = nullptr;
 
-        const auto        LEFT   = corner == CORNER_TOPLEFT || corner == CORNER_BOTTOMLEFT;
-        const auto        TOP    = corner == CORNER_TOPLEFT || corner == CORNER_TOPRIGHT;
-        const auto        RIGHT  = corner == CORNER_TOPRIGHT || corner == CORNER_BOTTOMRIGHT;
-        const auto        BOTTOM = corner == CORNER_BOTTOMLEFT || corner == CORNER_BOTTOMRIGHT;
+        const auto        LEFT   = corner == CORNER_TOPLEFT || corner == CORNER_BOTTOMLEFT || DISPLAYRIGHT;
+        const auto        TOP    = corner == CORNER_TOPLEFT || corner == CORNER_TOPRIGHT || DISPLAYBOTTOM;
+        const auto        RIGHT  = corner == CORNER_TOPRIGHT || corner == CORNER_BOTTOMRIGHT || DISPLAYLEFT;
+        const auto        BOTTOM = corner == CORNER_BOTTOMLEFT || corner == CORNER_BOTTOMRIGHT || DISPLAYTOP;
         const auto        NONE   = corner == CORNER_NONE;
 
         for (auto PCURRENT = PNODE; PCURRENT && PCURRENT->pParent; PCURRENT = PCURRENT->pParent) {
@@ -818,9 +812,7 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscree
             pWindow->m_vRealPosition = pWindow->m_vLastFloatingPosition;
             pWindow->m_vRealSize     = pWindow->m_vLastFloatingSize;
 
-            pWindow->m_sSpecialRenderData.rounding = true;
-            pWindow->m_sSpecialRenderData.border   = true;
-            pWindow->m_sSpecialRenderData.decorate = true;
+            pWindow->updateSpecialRenderData();
         }
     } else {
         // if it now got fullscreen, make it fullscreen
@@ -860,7 +852,7 @@ void CHyprDwindleLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscree
 
     g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goalv());
 
-    g_pCompositor->moveWindowToTop(pWindow);
+    g_pCompositor->changeWindowZOrder(pWindow, true);
 
     recalculateMonitor(PMONITOR->ID);
 }
@@ -895,6 +887,43 @@ SWindowRenderLayoutHints CHyprDwindleLayout::requestRenderHints(CWindow* pWindow
     return hints;
 }
 
+void CHyprDwindleLayout::moveWindowTo(CWindow* pWindow, const std::string& dir) {
+    if (!isDirection(dir))
+        return;
+
+    const auto PNODE = getNodeFromWindow(pWindow);
+
+    if (!PNODE)
+        return;
+
+    Vector2D focalPoint;
+
+    switch (dir[0]) {
+        case 't':
+        case 'u': focalPoint = pWindow->m_vPosition + Vector2D{pWindow->m_vSize.x / 2.f, -1}; break;
+        case 'd':
+        case 'b': focalPoint = pWindow->m_vPosition + Vector2D{pWindow->m_vSize.x / 2.f, pWindow->m_vSize.y + 1}; break;
+        case 'l': focalPoint = pWindow->m_vPosition + Vector2D{-1, pWindow->m_vSize.y / 2.f}; break;
+        case 'r': focalPoint = pWindow->m_vPosition + Vector2D{pWindow->m_vSize.x + 1, pWindow->m_vSize.y / 2.f}; break;
+        default: UNREACHABLE();
+    }
+
+    onWindowRemovedTiling(pWindow);
+
+    m_vOverrideFocalPoint = focalPoint;
+
+    const auto PMONITORFOCAL = g_pCompositor->getMonitorFromVector(focalPoint);
+
+    if (PMONITORFOCAL->ID != pWindow->m_iMonitorID) {
+        pWindow->moveToWorkspace(PMONITORFOCAL->activeWorkspace);
+        pWindow->m_iMonitorID = PMONITORFOCAL->ID;
+    }
+
+    onWindowCreatedTiling(pWindow);
+
+    m_vOverrideFocalPoint.reset();
+}
+
 void CHyprDwindleLayout::switchWindows(CWindow* pWindow, CWindow* pWindow2) {
     // windows should be valid, insallah
 
@@ -971,26 +1000,26 @@ std::any CHyprDwindleLayout::layoutMessage(SLayoutMessageHeader header, std::str
         switch (direction.front()) {
             case 'u':
             case 't': {
-                overrideDirection = OneTimeFocus::UP;
+                overrideDirection = DIRECTION_UP;
                 break;
             }
             case 'd':
             case 'b': {
-                overrideDirection = OneTimeFocus::DOWN;
+                overrideDirection = DIRECTION_DOWN;
                 break;
             }
             case 'r': {
-                overrideDirection = OneTimeFocus::RIGHT;
+                overrideDirection = DIRECTION_RIGHT;
                 break;
             }
             case 'l': {
-                overrideDirection = OneTimeFocus::LEFT;
+                overrideDirection = DIRECTION_LEFT;
                 break;
             }
             default: {
                 // any other character resets the focus direction
                 // needed for the persistent mode
-                overrideDirection = OneTimeFocus::NOFOCUS;
+                overrideDirection = DIRECTION_DEFAULT;
                 break;
             }
         }
@@ -1005,6 +1034,9 @@ void CHyprDwindleLayout::toggleSplit(CWindow* pWindow) {
     if (!PNODE || !PNODE->pParent)
         return;
 
+    if (pWindow->m_bIsFullscreen)
+        return;
+
     PNODE->pParent->splitTop = !PNODE->pParent->splitTop;
 
     PNODE->pParent->recalcSizePosRecursive();

src/layout/DwindleLayout.hpp

@@ -1,21 +1,15 @@
 #pragma once
 
 #include "IHyprLayout.hpp"
+
 #include <list>
 #include <deque>
-#include "../render/decorations/CHyprGroupBarDecoration.hpp"
 #include <array>
+#include <optional>
+#include <format>
 
 class CHyprDwindleLayout;
-enum eFullscreenMode : uint8_t;
-
-enum OneTimeFocus {
-    UP = 0,
-    RIGHT,
-    DOWN,
-    LEFT,
-    NOFOCUS,
-};
+enum eFullscreenMode : int8_t;
 
 struct SDwindleNodeData {
     SDwindleNodeData*                pParent = nullptr;
@@ -49,7 +43,7 @@ struct SDwindleNodeData {
 
 class CHyprDwindleLayout : public IHyprLayout {
   public:
-    virtual void                     onWindowCreatedTiling(CWindow*);
+    virtual void                     onWindowCreatedTiling(CWindow*, eDirection direction = DIRECTION_DEFAULT);
     virtual void                     onWindowRemovedTiling(CWindow*);
     virtual bool                     isWindowTiled(CWindow*);
     virtual void                     recalculateMonitor(const int&);
@@ -60,6 +54,7 @@ class CHyprDwindleLayout : public IHyprLayout {
     virtual std::any                 layoutMessage(SLayoutMessageHeader, std::string);
     virtual SWindowRenderLayoutHints requestRenderHints(CWindow*);
     virtual void                     switchWindows(CWindow*, CWindow*);
+    virtual void                     moveWindowTo(CWindow*, const std::string& dir);
     virtual void                     alterSplitRatio(CWindow*, float, bool);
     virtual std::string              getLayoutName();
     virtual void                     replaceWindowDataWith(CWindow* from, CWindow* to);
@@ -77,15 +72,31 @@ class CHyprDwindleLayout : public IHyprLayout {
         bool yExtent = false;
     } m_PseudoDragFlags;
 
-    int               getNodesOnWorkspace(const int&);
-    void              applyNodeDataToWindow(SDwindleNodeData*, bool force = false);
-    SDwindleNodeData* getNodeFromWindow(CWindow*);
-    SDwindleNodeData* getFirstNodeOnWorkspace(const int&);
-    SDwindleNodeData* getMasterNodeOnWorkspace(const int&);
+    std::optional<Vector2D> m_vOverrideFocalPoint; // for onWindowCreatedTiling.
 
-    void              toggleSplit(CWindow*);
+    int                     getNodesOnWorkspace(const int&);
+    void                    applyNodeDataToWindow(SDwindleNodeData*, bool force = false);
+    SDwindleNodeData*       getNodeFromWindow(CWindow*);
+    SDwindleNodeData*       getFirstNodeOnWorkspace(const int&);
+    SDwindleNodeData*       getMasterNodeOnWorkspace(const int&);
 
-    OneTimeFocus      overrideDirection = OneTimeFocus::NOFOCUS;
+    void                    toggleSplit(CWindow*);
+
+    eDirection              overrideDirection = DIRECTION_DEFAULT;
 
     friend struct SDwindleNodeData;
 };
+
+template <typename CharT>
+struct std::formatter<SDwindleNodeData*, CharT> : std::formatter<CharT> {
+    template <typename FormatContext>
+    auto format(const SDwindleNodeData* const& node, FormatContext& ctx) const {
+        auto out = ctx.out();
+        if (!node)
+            return std::format_to(out, "[Node nullptr]");
+        std::format_to(out, "[Node {:x}: workspace: {}, pos: {:j2}, size: {:j2}", (uintptr_t)node, node->workspaceID, node->position, node->size);
+        if (!node->isNode && node->pWindow)
+            std::format_to(out, ", window: {:x}", node->pWindow);
+        return std::format_to(out, "]");
+    }
+};

src/layout/IHyprLayout.cpp

@@ -2,7 +2,7 @@
 #include "../defines.hpp"
 #include "../Compositor.hpp"
 
-void IHyprLayout::onWindowCreated(CWindow* pWindow) {
+void IHyprLayout::onWindowCreated(CWindow* pWindow, eDirection direction) {
     if (pWindow->m_bIsFloating) {
         onWindowCreatedFloating(pWindow);
     } else {
@@ -18,7 +18,7 @@ void IHyprLayout::onWindowCreated(CWindow* pWindow) {
 
         pWindow->m_vPseudoSize = pWindow->m_vLastFloatingSize;
 
-        onWindowCreatedTiling(pWindow);
+        onWindowCreatedTiling(pWindow, direction);
     }
 }
 
@@ -31,24 +31,19 @@ void IHyprLayout::onWindowRemoved(CWindow* pWindow) {
             pWindow->m_sGroupData.pNextWindow = nullptr;
         else {
             // find last window and update
-            CWindow*   curr           = pWindow;
-            const auto CURRWASVISIBLE = curr->getGroupCurrent() == curr;
+            CWindow*   PWINDOWPREV     = pWindow->getGroupPrevious();
+            const auto WINDOWISVISIBLE = pWindow->getGroupCurrent() == pWindow;
 
-            while (curr->m_sGroupData.pNextWindow != pWindow)
-                curr = curr->m_sGroupData.pNextWindow;
+            if (WINDOWISVISIBLE)
+                PWINDOWPREV->setGroupCurrent(PWINDOWPREV);
 
-            if (CURRWASVISIBLE)
-                curr->setGroupCurrent(curr);
-
-            curr->m_sGroupData.pNextWindow = pWindow->m_sGroupData.pNextWindow;
+            PWINDOWPREV->m_sGroupData.pNextWindow = pWindow->m_sGroupData.pNextWindow;
 
             pWindow->m_sGroupData.pNextWindow = nullptr;
 
             if (pWindow->m_sGroupData.head) {
-                pWindow->m_sGroupData.head   = false;
-                curr->m_sGroupData.head      = true;
-                curr->m_sGroupData.locked    = pWindow->m_sGroupData.locked;
-                pWindow->m_sGroupData.locked = false;
+                std::swap(PWINDOWPREV->m_sGroupData.head, pWindow->m_sGroupData.head);
+                std::swap(PWINDOWPREV->m_sGroupData.locked, pWindow->m_sGroupData.locked);
             }
 
             if (pWindow == m_pLastTiledWindow)
@@ -56,6 +51,10 @@ void IHyprLayout::onWindowRemoved(CWindow* pWindow) {
 
             pWindow->setHidden(false);
 
+            pWindow->updateWindowDecos();
+            PWINDOWPREV->getGroupCurrent()->updateWindowDecos();
+            g_pCompositor->updateWindowAnimatedDecorationValues(pWindow);
+
             return;
         }
     }
@@ -75,14 +74,22 @@ void IHyprLayout::onWindowRemovedFloating(CWindow* pWindow) {
 }
 
 void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
+
     wlr_box desiredGeometry = {0};
     g_pXWaylandManager->getGeometryForWindow(pWindow, &desiredGeometry);
-    const auto         PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+    const auto PMONITOR = g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID);
+
+    if (pWindow->m_bIsX11) {
+        Vector2D xy       = {desiredGeometry.x, desiredGeometry.y};
+        xy                = g_pXWaylandManager->xwaylandToWaylandCoords(xy);
+        desiredGeometry.x = xy.x;
+        desiredGeometry.y = xy.y;
+    }
 
     static auto* const PXWLFORCESCALEZERO = &g_pConfigManager->getConfigValuePtr("xwayland:force_zero_scaling")->intValue;
 
     if (!PMONITOR) {
-        Debug::log(ERR, "Window %lx (%s) has an invalid monitor in onWindowCreatedFloating!!!", pWindow, pWindow->m_szTitle.c_str());
+        Debug::log(ERR, "{:m} has an invalid monitor in onWindowCreatedFloating!!!", pWindow);
         return;
     }
 
@@ -103,7 +110,7 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
         if (pWindow->m_bIsX11 && pWindow->m_uSurface.xwayland->override_redirect) {
 
             if (pWindow->m_uSurface.xwayland->x != 0 && pWindow->m_uSurface.xwayland->y != 0)
-                pWindow->m_vRealPosition = Vector2D{pWindow->m_uSurface.xwayland->x, pWindow->m_uSurface.xwayland->y};
+                pWindow->m_vRealPosition = g_pXWaylandManager->xwaylandToWaylandCoords({pWindow->m_uSurface.xwayland->x, pWindow->m_uSurface.xwayland->y});
             else
                 pWindow->m_vRealPosition = Vector2D(PMONITOR->vecPosition.x + (PMONITOR->vecSize.x - pWindow->m_vRealSize.goalv().x) / 2.f,
                                                     PMONITOR->vecPosition.y + (PMONITOR->vecSize.y - pWindow->m_vRealSize.goalv().y) / 2.f);
@@ -121,25 +128,15 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
         // check if it's visible on any monitor (only for XDG)
         bool visible = pWindow->m_bIsX11;
 
-        if (!pWindow->m_bIsX11) {
-            for (auto& m : g_pCompositor->m_vMonitors) {
-                if (VECINRECT(Vector2D(desiredGeometry.x, desiredGeometry.y), m->vecPosition.x, m->vecPosition.y, m->vecPosition.x + m->vecSize.x,
-                              m->vecPosition.y + m->vecPosition.y) ||
-                    VECINRECT(Vector2D(desiredGeometry.x + desiredGeometry.width, desiredGeometry.y), m->vecPosition.x, m->vecPosition.y, m->vecPosition.x + m->vecSize.x,
-                              m->vecPosition.y + m->vecPosition.y) ||
-                    VECINRECT(Vector2D(desiredGeometry.x, desiredGeometry.y + desiredGeometry.height), m->vecPosition.x, m->vecPosition.y, m->vecPosition.x + m->vecSize.x,
-                              m->vecPosition.y + m->vecPosition.y) ||
-                    VECINRECT(Vector2D(desiredGeometry.x + desiredGeometry.width, desiredGeometry.y + desiredGeometry.height), m->vecPosition.x, m->vecPosition.y,
-                              m->vecPosition.x + m->vecSize.x, m->vecPosition.y + m->vecPosition.y)) {
-
-                    visible = true;
-                    break;
-                }
-            }
+        if (!visible) {
+            visible = g_pCompositor->isPointOnAnyMonitor(Vector2D(desiredGeometry.x, desiredGeometry.y)) &&
+                g_pCompositor->isPointOnAnyMonitor(Vector2D(desiredGeometry.x + desiredGeometry.width, desiredGeometry.y)) &&
+                g_pCompositor->isPointOnAnyMonitor(Vector2D(desiredGeometry.x, desiredGeometry.y + desiredGeometry.height)) &&
+                g_pCompositor->isPointOnAnyMonitor(Vector2D(desiredGeometry.x + desiredGeometry.width, desiredGeometry.y + desiredGeometry.height));
         }
 
         // TODO: detect a popup in a more consistent way.
-        if ((desiredGeometry.x == 0 && desiredGeometry.y == 0) || !visible) {
+        if ((desiredGeometry.x == 0 && desiredGeometry.y == 0) || !visible || !pWindow->m_bIsX11) {
             // if it's not, fall back to the center placement
             pWindow->m_vRealPosition = PMONITOR->vecPosition + Vector2D((PMONITOR->vecSize.x - desiredGeometry.width) / 2.f, (PMONITOR->vecSize.y - desiredGeometry.height) / 2.f);
         } else {
@@ -153,10 +150,8 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
         }
     }
 
-    if (*PXWLFORCESCALEZERO && pWindow->m_bIsX11) {
-        pWindow->m_vRealSize     = pWindow->m_vRealSize.goalv() / PMONITOR->scale;
-        pWindow->m_vRealPosition = pWindow->m_vRealPosition.goalv() / PMONITOR->scale;
-    }
+    if (*PXWLFORCESCALEZERO && pWindow->m_bIsX11)
+        pWindow->m_vRealSize = pWindow->m_vRealSize.goalv() / PMONITOR->scale;
 
     if (pWindow->m_bX11DoesntWantBorders || (pWindow->m_bIsX11 && pWindow->m_uSurface.xwayland->override_redirect)) {
         pWindow->m_vRealPosition.warp();
@@ -166,7 +161,7 @@ void IHyprLayout::onWindowCreatedFloating(CWindow* pWindow) {
     if (pWindow->m_iX11Type != 2) {
         g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goalv());
 
-        g_pCompositor->moveWindowToTop(pWindow);
+        g_pCompositor->changeWindowZOrder(pWindow, true);
     }
 }
 
@@ -183,9 +178,8 @@ void IHyprLayout::onBeginDragWindow() {
     }
 
     if (DRAGGINGWINDOW->m_bIsFullscreen) {
-        Debug::log(LOG, "Rejecting drag on a fullscreen window.");
-        g_pInputManager->currentlyDraggedWindow = nullptr;
-        return;
+        Debug::log(LOG, "Dragging a fullscreen window");
+        g_pCompositor->setWindowFullscreen(DRAGGINGWINDOW, false, FULLSCREEN_FULL);
     }
 
     const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(DRAGGINGWINDOW->m_iWorkspaceID);
@@ -235,7 +229,7 @@ void IHyprLayout::onBeginDragWindow() {
         }
     }
 
-    if (g_pInputManager->dragMode != MBIND_RESIZE)
+    if (g_pInputManager->dragMode != MBIND_RESIZE && g_pInputManager->dragMode != MBIND_RESIZE_FORCE_RATIO && g_pInputManager->dragMode != MBIND_RESIZE_BLOCK_RATIO)
         g_pInputManager->setCursorImageUntilUnset("grab");
 
     g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
@@ -243,7 +237,7 @@ void IHyprLayout::onBeginDragWindow() {
     g_pKeybindManager->shadowKeybinds();
 
     g_pCompositor->focusWindow(DRAGGINGWINDOW);
-    g_pCompositor->moveWindowToTop(DRAGGINGWINDOW);
+    g_pCompositor->changeWindowZOrder(DRAGGINGWINDOW, true);
 }
 
 void IHyprLayout::onEndDragWindow() {
@@ -269,6 +263,8 @@ void IHyprLayout::onEndDragWindow() {
     }
 
     g_pHyprRenderer->damageWindow(DRAGGINGWINDOW);
+
+    g_pCompositor->focusWindow(DRAGGINGWINDOW);
 }
 
 void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
@@ -294,7 +290,7 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
     if ((abs(TICKDELTA.x) < 1.f && abs(TICKDELTA.y) < 1.f) ||
         (std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - TIMER).count() <
              1000.0 / g_pHyprRenderer->m_pMostHzMonitor->refreshRate &&
-         *PANIMATEMOUSE))
+         (*PANIMATEMOUSE || *PANIMATE)))
         return;
 
     TIMER = std::chrono::high_resolution_clock::now();
@@ -312,29 +308,55 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
         }
 
         g_pXWaylandManager->setWindowSize(DRAGGINGWINDOW, DRAGGINGWINDOW->m_vRealSize.goalv());
-    } else if (g_pInputManager->dragMode == MBIND_RESIZE) {
+    } else if (g_pInputManager->dragMode == MBIND_RESIZE || g_pInputManager->dragMode == MBIND_RESIZE_FORCE_RATIO || g_pInputManager->dragMode == MBIND_RESIZE_BLOCK_RATIO) {
         if (DRAGGINGWINDOW->m_bIsFloating) {
 
-            const auto MAXSIZE = g_pXWaylandManager->getMaxSizeForWindow(DRAGGINGWINDOW);
-
-            // calc the new size and pos
+            Vector2D MINSIZE = Vector2D(20, 20);
+            Vector2D MAXSIZE = g_pXWaylandManager->getMaxSizeForWindow(DRAGGINGWINDOW);
 
             Vector2D newSize = m_vBeginDragSizeXY;
             Vector2D newPos  = m_vBeginDragPositionXY;
 
-            if (m_eGrabbedCorner == CORNER_BOTTOMRIGHT) {
-                newSize = (newSize + DELTA).clamp(Vector2D(20, 20), MAXSIZE);
-            } else if (m_eGrabbedCorner == CORNER_TOPLEFT) {
-                newSize = (newSize - DELTA).clamp(Vector2D(20, 20), MAXSIZE);
-                newPos  = newPos - newSize + m_vBeginDragSizeXY;
-            } else if (m_eGrabbedCorner == CORNER_TOPRIGHT) {
-                newSize = (newSize + Vector2D(DELTA.x, -DELTA.y)).clamp(Vector2D(20, 20), MAXSIZE);
-                newPos  = newPos + Vector2D(0, (m_vBeginDragSizeXY - newSize).y);
-            } else if (m_eGrabbedCorner == CORNER_BOTTOMLEFT) {
-                newSize = (newSize + Vector2D(-DELTA.x, DELTA.y)).clamp(Vector2D(20, 20), MAXSIZE);
-                newPos  = newPos + Vector2D((m_vBeginDragSizeXY - newSize).x, 0);
+            if (m_eGrabbedCorner == CORNER_BOTTOMRIGHT)
+                newSize = newSize + DELTA;
+            else if (m_eGrabbedCorner == CORNER_TOPLEFT)
+                newSize = newSize - DELTA;
+            else if (m_eGrabbedCorner == CORNER_TOPRIGHT)
+                newSize = newSize + Vector2D(DELTA.x, -DELTA.y);
+            else if (m_eGrabbedCorner == CORNER_BOTTOMLEFT)
+                newSize = newSize + Vector2D(-DELTA.x, DELTA.y);
+
+            if ((m_vBeginDragSizeXY.x >= 1 && m_vBeginDragSizeXY.y >= 1) &&
+                (g_pInputManager->dragMode == MBIND_RESIZE_FORCE_RATIO ||
+                 (!(g_pInputManager->dragMode == MBIND_RESIZE_BLOCK_RATIO) && DRAGGINGWINDOW->m_sAdditionalConfigData.keepAspectRatio))) {
+
+                const float RATIO = m_vBeginDragSizeXY.y / m_vBeginDragSizeXY.x;
+
+                if (MINSIZE.x * RATIO > MINSIZE.y)
+                    MINSIZE = Vector2D(MINSIZE.x, MINSIZE.x * RATIO);
+                else
+                    MINSIZE = Vector2D(MINSIZE.y / RATIO, MINSIZE.y);
+
+                if (MAXSIZE.x * RATIO < MAXSIZE.y)
+                    MAXSIZE = Vector2D(MAXSIZE.x, MAXSIZE.x * RATIO);
+                else
+                    MAXSIZE = Vector2D(MAXSIZE.y / RATIO, MAXSIZE.y);
+
+                if (newSize.x * RATIO > newSize.y)
+                    newSize = Vector2D(newSize.x, newSize.x * RATIO);
+                else
+                    newSize = Vector2D(newSize.y / RATIO, newSize.y);
             }
 
+            newSize = newSize.clamp(MINSIZE, MAXSIZE);
+
+            if (m_eGrabbedCorner == CORNER_TOPLEFT)
+                newPos = newPos - newSize + m_vBeginDragSizeXY;
+            else if (m_eGrabbedCorner == CORNER_TOPRIGHT)
+                newPos = newPos + Vector2D(0, (m_vBeginDragSizeXY - newSize).y);
+            else if (m_eGrabbedCorner == CORNER_BOTTOMLEFT)
+                newPos = newPos + Vector2D((m_vBeginDragSizeXY - newSize).x, 0);
+
             if (*PANIMATE) {
                 DRAGGINGWINDOW->m_vRealSize     = newSize;
                 DRAGGINGWINDOW->m_vRealPosition = newPos;
@@ -371,11 +393,8 @@ void IHyprLayout::onMouseMove(const Vector2D& mousePos) {
 void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
 
     if (pWindow->m_bIsFullscreen) {
-        Debug::log(LOG, "Rejecting a change float order because window is fullscreen.");
-
-        // restore its' floating mode
-        pWindow->m_bIsFloating = !pWindow->m_bIsFloating;
-        return;
+        Debug::log(LOG, "changeWindowFloatingMode: fullscreen");
+        g_pCompositor->setWindowFullscreen(pWindow, false, FULLSCREEN_FULL);
     }
 
     pWindow->m_bPinned = false;
@@ -383,13 +402,13 @@ void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
     const auto TILED = isWindowTiled(pWindow);
 
     // event
-    g_pEventManager->postEvent(SHyprIPCEvent{"changefloatingmode", getFormat("%lx,%d", pWindow, (int)TILED)});
+    g_pEventManager->postEvent(SHyprIPCEvent{"changefloatingmode", std::format("{:x},{}", (uintptr_t)pWindow, (int)TILED)});
     EMIT_HOOK_EVENT("changeFloatingMode", pWindow);
 
     if (!TILED) {
         const auto PNEWMON    = g_pCompositor->getMonitorFromVector(pWindow->m_vRealPosition.vec() + pWindow->m_vRealSize.vec() / 2.f);
         pWindow->m_iMonitorID = PNEWMON->ID;
-        pWindow->moveToWorkspace(PNEWMON->activeWorkspace);
+        pWindow->moveToWorkspace(PNEWMON->specialWorkspaceID != 0 ? PNEWMON->specialWorkspaceID : PNEWMON->activeWorkspace);
         pWindow->updateGroupOutputs();
 
         // save real pos cuz the func applies the default 5,5 mid
@@ -417,7 +436,7 @@ void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
     } else {
         onWindowRemovedTiling(pWindow);
 
-        g_pCompositor->moveWindowToTop(pWindow);
+        g_pCompositor->changeWindowZOrder(pWindow, true);
 
         if (DELTALESSTHAN(pWindow->m_vRealSize.vec().x, pWindow->m_vLastFloatingSize.x, 10) && DELTALESSTHAN(pWindow->m_vRealSize.vec().y, pWindow->m_vLastFloatingSize.y, 10)) {
             pWindow->m_vRealPosition = pWindow->m_vRealPosition.goalv() + (pWindow->m_vRealSize.goalv() - pWindow->m_vLastFloatingSize) / 2.f + Vector2D{10, 10};
@@ -432,9 +451,7 @@ void IHyprLayout::changeWindowFloatingMode(CWindow* pWindow) {
 
         g_pHyprRenderer->damageMonitor(g_pCompositor->getMonitorFromID(pWindow->m_iMonitorID));
 
-        pWindow->m_sSpecialRenderData.rounding = true;
-        pWindow->m_sSpecialRenderData.border   = true;
-        pWindow->m_sSpecialRenderData.decorate = true;
+        pWindow->updateSpecialRenderData();
 
         if (pWindow == m_pLastTiledWindow)
             m_pLastTiledWindow = nullptr;
@@ -494,8 +511,7 @@ CWindow* IHyprLayout::getNextWindowCandidate(CWindow* pWindow) {
             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 && PWINDOWCANDIDATE != pWindow)
+        if (const auto PWINDOWCANDIDATE = g_pCompositor->vectorToWindowIdeal(pWindow->middle()); PWINDOWCANDIDATE && PWINDOWCANDIDATE != pWindow)
             return PWINDOWCANDIDATE;
 
         // if not, floating window
@@ -510,7 +526,7 @@ CWindow* IHyprLayout::getNextWindowCandidate(CWindow* pWindow) {
     }
 
     // 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);
+    const auto PWINDOWCANDIDATE = g_pCompositor->vectorToWindowIdeal(pWindow->middle());
 
     if (!PWINDOWCANDIDATE || pWindow == PWINDOWCANDIDATE || !PWINDOWCANDIDATE->m_bIsMapped || PWINDOWCANDIDATE->isHidden() || PWINDOWCANDIDATE->m_bX11ShouldntFocus ||
         PWINDOWCANDIDATE->m_iX11Type == 2 || PWINDOWCANDIDATE->m_iMonitorID != g_pCompositor->m_pLastMonitor->ID)
@@ -519,12 +535,22 @@ CWindow* IHyprLayout::getNextWindowCandidate(CWindow* pWindow) {
     return PWINDOWCANDIDATE;
 }
 
-void IHyprLayout::requestFocusForWindow(CWindow* pWindow) {
+bool IHyprLayout::isWindowReachable(CWindow* pWindow) {
+    return pWindow && (!pWindow->isHidden() || pWindow->m_sGroupData.pNextWindow);
+}
+
+void IHyprLayout::bringWindowToTop(CWindow* pWindow) {
+    if (pWindow == nullptr)
+        return;
+
     if (pWindow->isHidden() && pWindow->m_sGroupData.pNextWindow) {
         // grouped, change the current to this window
         pWindow->setGroupCurrent(pWindow);
     }
+}
 
+void IHyprLayout::requestFocusForWindow(CWindow* pWindow) {
+    bringWindowToTop(pWindow);
     g_pCompositor->focusWindow(pWindow);
 }
 

src/layout/IHyprLayout.hpp

@@ -13,9 +13,10 @@ struct SLayoutMessageHeader {
     CWindow* pWindow = nullptr;
 };
 
-enum eFullscreenMode : uint8_t;
+enum eFullscreenMode : int8_t;
 
-enum eRectCorner {
+enum eRectCorner
+{
     CORNER_NONE = 0,
     CORNER_TOPLEFT,
     CORNER_TOPRIGHT,
@@ -23,7 +24,16 @@ enum eRectCorner {
     CORNER_BOTTOMLEFT
 };
 
-interface IHyprLayout {
+enum eDirection
+{
+    DIRECTION_DEFAULT = -1,
+    DIRECTION_UP      = 0,
+    DIRECTION_RIGHT,
+    DIRECTION_DOWN,
+    DIRECTION_LEFT
+};
+
+class IHyprLayout {
   public:
     virtual ~IHyprLayout()   = 0;
     virtual void onEnable()  = 0;
@@ -34,8 +44,8 @@ interface IHyprLayout {
         The layout HAS TO set the goal pos and size (anim mgr will use it)
         If !animationinprogress, then the anim mgr will not apply an anim.
     */
-    virtual void onWindowCreated(CWindow*);
-    virtual void onWindowCreatedTiling(CWindow*) = 0;
+    virtual void onWindowCreated(CWindow*, eDirection direction = DIRECTION_DEFAULT);
+    virtual void onWindowCreatedTiling(CWindow*, eDirection direction = DIRECTION_DEFAULT) = 0;
     virtual void onWindowCreatedFloating(CWindow*);
 
     /*
@@ -122,6 +132,12 @@ interface IHyprLayout {
     */
     virtual void switchWindows(CWindow*, CWindow*) = 0;
 
+    /*
+        Called when the user requests a window move in a direction.
+        The layout is free to ignore.
+    */
+    virtual void moveWindowTo(CWindow*, const std::string& direction) = 0;
+
     /*
         Called when the user requests to change the splitratio by or to X
         on a window
@@ -148,10 +164,22 @@ interface IHyprLayout {
     */
     virtual void replaceWindowDataWith(CWindow* from, CWindow* to) = 0;
 
+    /*
+        Determines if a window can be focused. If hidden this usually means the window is part of a group.
+    */
+    virtual bool isWindowReachable(CWindow*);
+
+    /*
+        Called before an attempt is made to focus a window.
+        Brings the window to the top of any groups and ensures it is not hidden.
+        If the window is unmapped following this call, the focus attempt will fail.
+    */
+    virtual void bringWindowToTop(CWindow*);
+
     /*
         Called via the foreign toplevel activation protocol.
         Focuses a window, bringing it to the top of its group if applicable.
-				May be ignored.
+        May be ignored.
     */
     virtual void requestFocusForWindow(CWindow*);
 

src/layout/MasterLayout.cpp

@@ -1,5 +1,6 @@
 #include "MasterLayout.hpp"
 #include "../Compositor.hpp"
+#include "../render/decorations/CHyprGroupBarDecoration.hpp"
 #include <ranges>
 
 SMasterNodeData* CHyprMasterLayout::getNodeFromWindow(CWindow* pWindow) {
@@ -68,7 +69,7 @@ SMasterNodeData* CHyprMasterLayout::getMasterNodeOnWorkspace(const int& ws) {
     return nullptr;
 }
 
-void CHyprMasterLayout::onWindowCreatedTiling(CWindow* pWindow) {
+void CHyprMasterLayout::onWindowCreatedTiling(CWindow* pWindow, eDirection direction) {
     if (pWindow->m_bIsFloating)
         return;
 
@@ -91,33 +92,74 @@ void CHyprMasterLayout::onWindowCreatedTiling(CWindow* pWindow) {
                       getNodeFromWindow(g_pCompositor->m_pLastWindow) :
                       getMasterNodeOnWorkspace(pWindow->m_iWorkspaceID);
 
+    const auto         MOUSECOORDS = g_pInputManager->getMouseCoordsInternal();
+
     // if it's a group, add the window
-    if (OPENINGON && OPENINGON->pWindow->m_sGroupData.pNextWindow && !OPENINGON->pWindow->getGroupHead()->m_sGroupData.locked && !g_pKeybindManager->m_bGroupsLocked &&
-        OPENINGON != PNODE) { // target is an unlocked group
-
-        if (!pWindow->m_sGroupData.pNextWindow) { // source is not a group
-            m_lMasterNodesData.remove(*PNODE);
-            OPENINGON->pWindow->insertWindowToGroup(pWindow);
-            OPENINGON->pWindow->setGroupCurrent(pWindow);
+    if (OPENINGON && OPENINGON != PNODE && OPENINGON->pWindow->m_sGroupData.pNextWindow                   // target is group
+        && !g_pKeybindManager->m_bGroupsLocked                                                            // global group lock disengaged
+        && ((pWindow->m_eGroupRules & GROUP_INVADE && pWindow->m_bFirstMap)                               // window ignore local group locks, or
+            || (!OPENINGON->pWindow->getGroupHead()->m_sGroupData.locked                                  //    target unlocked
+                && !(pWindow->m_sGroupData.pNextWindow && pWindow->getGroupHead()->m_sGroupData.locked))) //    source unlocked or isn't group
+        && !pWindow->m_sGroupData.deny                                                                    // source is not denied entry
+        && !(pWindow->m_eGroupRules & GROUP_BARRED)                                                       // group rule doesn't prevent adding window
+    ) {
 
+        if (!pWindow->m_sGroupData.pNextWindow)
             pWindow->m_dWindowDecorations.emplace_back(std::make_unique<CHyprGroupBarDecoration>(pWindow));
-            pWindow->updateWindowDecos();
-            recalculateWindow(pWindow);
 
-            g_pCompositor->focusWindow(pWindow);
-            return;
+        m_lMasterNodesData.remove(*PNODE);
+
+        const wlr_box box = OPENINGON->pWindow->getDecorationByType(DECORATION_GROUPBAR)->getWindowDecorationRegion().getExtents();
+        if (wlr_box_contains_point(&box, MOUSECOORDS.x, MOUSECOORDS.y)) { // TODO: Deny when not using mouse
+            const int SIZE               = OPENINGON->pWindow->getGroupSize();
+            const int INDEX              = (int)((MOUSECOORDS.x - box.x) * 2 * SIZE / box.width + 1) / 2 - 1;
+            CWindow*  pWindowInsertAfter = OPENINGON->pWindow->getGroupWindowByIndex(INDEX);
+            pWindowInsertAfter->insertWindowToGroup(pWindow);
+            if (INDEX == -1)
+                std::swap(pWindow->m_sGroupData.pNextWindow->m_sGroupData.head, pWindow->m_sGroupData.head);
+        } else {
+            static const auto* USECURRPOS = &g_pConfigManager->getConfigValuePtr("group:insert_after_current")->intValue;
+            (*USECURRPOS ? OPENINGON->pWindow : OPENINGON->pWindow->getGroupTail())->insertWindowToGroup(pWindow);
         }
 
-        if (!pWindow->getGroupHead()->m_sGroupData.locked) { // source is an unlocked group
-            m_lMasterNodesData.remove(*PNODE);
-            OPENINGON->pWindow->insertWindowToGroup(pWindow);
-            OPENINGON->pWindow->setGroupCurrent(pWindow);
+        OPENINGON->pWindow->setGroupCurrent(pWindow);
+        pWindow->applyGroupRules();
+        pWindow->updateWindowDecos();
+        recalculateWindow(pWindow);
 
-            pWindow->updateWindowDecos();
-            recalculateWindow(pWindow);
+        return;
+    }
 
-            g_pCompositor->focusWindow(pWindow);
-            return;
+    pWindow->applyGroupRules();
+
+    static auto* const PDROPATCURSOR  = &g_pConfigManager->getConfigValuePtr("master:drop_at_cursor")->intValue;
+    const auto         PWORKSPACEDATA = getMasterWorkspaceData(pWindow->m_iWorkspaceID);
+    eOrientation       orientation    = PWORKSPACEDATA->orientation;
+    const auto         NODEIT         = std::find(m_lMasterNodesData.begin(), m_lMasterNodesData.end(), *PNODE);
+    if (*PDROPATCURSOR && g_pInputManager->dragMode == MBIND_MOVE) {
+        // if dragging window to move, drop it at the cursor position instead of bottom/top of stack
+        for (auto it = m_lMasterNodesData.begin(); it != m_lMasterNodesData.end(); ++it) {
+            if (it->workspaceID != pWindow->m_iWorkspaceID)
+                continue;
+            const wlr_box box = it->pWindow->getWindowIdealBoundingBoxIgnoreReserved();
+            if (wlr_box_contains_point(&box, MOUSECOORDS.x, MOUSECOORDS.y)) { // TODO: Deny when not using mouse
+                switch (orientation) {
+                    case ORIENTATION_LEFT:
+                    case ORIENTATION_RIGHT:
+                        if (MOUSECOORDS.y > it->pWindow->middle().y)
+                            ++it;
+                        break;
+                    case ORIENTATION_TOP:
+                    case ORIENTATION_BOTTOM:
+                        if (MOUSECOORDS.x > it->pWindow->middle().x)
+                            ++it;
+                        break;
+                    case ORIENTATION_CENTER: break;
+                    default: UNREACHABLE();
+                }
+                m_lMasterNodesData.splice(it, m_lMasterNodesData, NODEIT);
+                break;
+            }
         }
     }
 
@@ -156,13 +198,6 @@ void CHyprMasterLayout::onWindowCreatedTiling(CWindow* pWindow) {
         }
     }
 
-    const auto PWORKSPACE = g_pCompositor->getWorkspaceByID(pWindow->m_iWorkspaceID);
-
-    if (PWORKSPACE->m_bHasFullscreenWindow) {
-        const auto PFULLWINDOW = g_pCompositor->getFullscreenWindowOnWorkspace(PWORKSPACE->m_iID);
-        g_pCompositor->setWindowFullscreen(PFULLWINDOW, false, FULLSCREEN_FULL);
-    }
-
     // recalc
     recalculateMonitor(pWindow->m_iMonitorID);
 }
@@ -177,9 +212,7 @@ void CHyprMasterLayout::onWindowRemovedTiling(CWindow* pWindow) {
     const auto         MASTERSLEFT = getMastersOnWorkspace(WORKSPACEID);
     static const auto* SMALLSPLIT  = &g_pConfigManager->getConfigValuePtr("master:allow_small_split")->intValue;
 
-    pWindow->m_sSpecialRenderData.rounding = true;
-    pWindow->m_sSpecialRenderData.border   = true;
-    pWindow->m_sSpecialRenderData.decorate = true;
+    pWindow->updateSpecialRenderData();
 
     if (pWindow->m_bIsFullscreen)
         g_pCompositor->setWindowFullscreen(pWindow, false, FULLSCREEN_FULL);
@@ -268,10 +301,8 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
         return;
 
     const auto PWORKSPACEDATA = getMasterWorkspaceData(ws);
-
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
-
-    const auto PMASTERNODE = getMasterNodeOnWorkspace(PWORKSPACE->m_iID);
+    const auto PMONITOR       = g_pCompositor->getMonitorFromID(PWORKSPACE->m_iMonitorID);
+    const auto PMASTERNODE    = getMasterNodeOnWorkspace(PWORKSPACE->m_iID);
 
     if (!PMASTERNODE)
         return;
@@ -279,200 +310,261 @@ void CHyprMasterLayout::calculateWorkspace(const int& ws) {
     eOrientation       orientation        = PWORKSPACEDATA->orientation;
     bool               centerMasterWindow = false;
     static auto* const ALWAYSCENTER       = &g_pConfigManager->getConfigValuePtr("master:always_center_master")->intValue;
+    static auto* const PSMARTRESIZING     = &g_pConfigManager->getConfigValuePtr("master:smart_resizing")->intValue;
+
+    const auto         MASTERS      = getMastersOnWorkspace(PWORKSPACE->m_iID);
+    const auto         WINDOWS      = getNodesOnWorkspace(PWORKSPACE->m_iID);
+    const auto         STACKWINDOWS = WINDOWS - MASTERS;
+    const auto         WSSIZE       = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
+    const auto         WSPOS        = PMONITOR->vecPosition + PMONITOR->vecReservedTopLeft;
+
     if (orientation == ORIENTATION_CENTER) {
-        if (getNodesOnWorkspace(PWORKSPACE->m_iID) > 2 || (*ALWAYSCENTER == 1)) {
+        if (STACKWINDOWS >= 2 || (*ALWAYSCENTER == 1)) {
             centerMasterWindow = true;
         } else {
             orientation = ORIENTATION_LEFT;
         }
     }
 
-    const auto MASTERS      = getMastersOnWorkspace(PWORKSPACE->m_iID);
-    const auto WINDOWS      = getNodesOnWorkspace(PWORKSPACE->m_iID);
-    const auto STACKWINDOWS = WINDOWS - MASTERS;
-    //compute placement of master window(s)
-    if ((WINDOWS < 2) && !centerMasterWindow) {
-        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 if (orientation == ORIENTATION_LEFT || orientation == ORIENTATION_RIGHT || (orientation == ORIENTATION_CENTER && STACKWINDOWS <= 1)) {
-        float heightLeft = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y;
-        int   nodesLeft  = MASTERS;
-        float nextY      = 0;
-        float WIDTH      = 0;
+    const float totalSize             = (orientation == ORIENTATION_TOP || orientation == ORIENTATION_BOTTOM) ? WSSIZE.x : WSSIZE.y;
+    const float masterAverageSize     = totalSize / MASTERS;
+    const float slaveAverageSize      = totalSize / STACKWINDOWS;
+    float       masterAccumulatedSize = 0;
+    float       slaveAccumulatedSize  = 0;
 
-        if (STACKWINDOWS == 0 && MASTERS > 0)
-            WIDTH = (PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x);
-        else
-            WIDTH = (PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x) * PMASTERNODE->percMaster;
-
-        for (auto& n : m_lMasterNodesData) {
-            if (n.workspaceID == PWORKSPACE->m_iID && n.isMaster) {
-                if (orientation == ORIENTATION_RIGHT) {
-                    n.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition +
-                        Vector2D(PMONITOR->vecSize.x - WIDTH - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x, nextY);
-                } else {
-                    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(WIDTH, HEIGHT);
-
-                nodesLeft--;
-                heightLeft -= HEIGHT;
-                nextY += HEIGHT;
-
-                applyNodeDataToWindow(&n);
-            }
-        }
-    } else if (orientation == ORIENTATION_TOP || orientation == ORIENTATION_BOTTOM) {
-        float       widthLeft = PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x;
-        int         nodesLeft = MASTERS;
-        float       nextX     = 0;
-        const float HEIGHT    = (PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y) * PMASTERNODE->percMaster;
-
-        for (auto& n : m_lMasterNodesData) {
-            if (n.workspaceID == PWORKSPACE->m_iID && n.isMaster) {
-                if (orientation == ORIENTATION_BOTTOM) {
-                    n.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition +
-                        Vector2D(nextX, PMONITOR->vecSize.y - HEIGHT - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y);
-                } else {
-                    n.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition + Vector2D(nextX, 0);
-                }
-                float WIDTH = nodesLeft > 1 ? widthLeft / nodesLeft * n.percSize : widthLeft;
-                if (WIDTH > widthLeft * 0.9f && nodesLeft > 1)
-                    WIDTH = widthLeft * 0.9f;
-                n.size = Vector2D(WIDTH, HEIGHT);
-
-                nodesLeft--;
-                widthLeft -= WIDTH;
-                nextX += WIDTH;
-
-                applyNodeDataToWindow(&n);
-            }
-        }
-    } else if (orientation == ORIENTATION_CENTER && STACKWINDOWS >= 2) {
-        float       heightLeft = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y;
-        int         nodesLeft  = MASTERS;
-        float       nextY      = 0;
-        const float WIDTH      = (PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x) * PMASTERNODE->percMaster;
-
-        for (auto& n : m_lMasterNodesData) {
-            if (n.workspaceID == PWORKSPACE->m_iID && n.isMaster) {
-                float CENTER_OFFSET = (PMONITOR->vecSize.x - WIDTH) / 2;
-                n.position          = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition + Vector2D(CENTER_OFFSET, nextY);
-                float HEIGHT        = nodesLeft > 1 ? heightLeft / nodesLeft * n.percSize : heightLeft;
-                if (HEIGHT > heightLeft * 0.9f && nodesLeft > 1)
-                    HEIGHT = heightLeft * 0.9f;
-                n.size = Vector2D(WIDTH, HEIGHT);
-
-                nodesLeft--;
-                heightLeft -= HEIGHT;
-                nextY += HEIGHT;
-
-                applyNodeDataToWindow(&n);
+    if (*PSMARTRESIZING) {
+        // check the total width and height so that later
+        // if larger/smaller than screen size them down/up
+        for (auto& nd : m_lMasterNodesData) {
+            if (nd.workspaceID == PWORKSPACE->m_iID) {
+                if (nd.isMaster)
+                    masterAccumulatedSize += totalSize / MASTERS * nd.percSize;
+                else
+                    slaveAccumulatedSize += totalSize / STACKWINDOWS * nd.percSize;
             }
         }
     }
 
-    //compute placement of slave window(s)
-    int slavesLeft = getNodesOnWorkspace(PWORKSPACE->m_iID) - MASTERS;
-    if (orientation == ORIENTATION_LEFT || orientation == ORIENTATION_RIGHT || (orientation == ORIENTATION_CENTER && STACKWINDOWS <= 1)) {
-        float       heightLeft = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y;
-        float       nextY      = 0;
-        const float WIDTH      = PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x - PMASTERNODE->size.x;
+    // compute placement of master window(s)
+    if (WINDOWS == 1 && !centerMasterWindow) {
+        PMASTERNODE->size     = WSSIZE;
+        PMASTERNODE->position = WSPOS;
+
+        applyNodeDataToWindow(PMASTERNODE);
+        return;
+    } else if (orientation == ORIENTATION_TOP || orientation == ORIENTATION_BOTTOM) {
+        const float HEIGHT      = WSSIZE.y * PMASTERNODE->percMaster;
+        float       widthLeft   = WSSIZE.x;
+        int         mastersLeft = MASTERS;
+        float       nextX       = 0;
+        float       nextY       = 0;
+
+        if (orientation == ORIENTATION_BOTTOM)
+            nextY = WSSIZE.y - HEIGHT;
 
         for (auto& nd : m_lMasterNodesData) {
-            if (nd.workspaceID != PWORKSPACE->m_iID || nd.isMaster)
+            if (nd.workspaceID != PWORKSPACE->m_iID || !nd.isMaster)
                 continue;
 
-            if (orientation == ORIENTATION_LEFT || (orientation == ORIENTATION_CENTER && STACKWINDOWS <= 1)) {
-                nd.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition +
-                    Vector2D(PMASTERNODE->percMaster * (PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x), nextY);
-            } else {
-                nd.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition + Vector2D(0, nextY);
-            }
-            float HEIGHT = slavesLeft > 1 ? heightLeft / slavesLeft * nd.percSize : heightLeft;
-            if (HEIGHT > heightLeft * 0.9f && slavesLeft > 1)
-                HEIGHT = heightLeft * 0.9f;
-            nd.size = Vector2D(WIDTH, HEIGHT);
+            float WIDTH = mastersLeft > 1 ? widthLeft / mastersLeft * nd.percSize : widthLeft;
+            if (WIDTH > widthLeft * 0.9f && mastersLeft > 1)
+                WIDTH = widthLeft * 0.9f;
 
-            slavesLeft--;
+            if (*PSMARTRESIZING) {
+                nd.percSize *= WSSIZE.x / masterAccumulatedSize;
+                WIDTH = masterAverageSize * nd.percSize;
+            }
+
+            nd.size     = Vector2D(WIDTH, HEIGHT);
+            nd.position = WSPOS + Vector2D(nextX, nextY);
+            applyNodeDataToWindow(&nd);
+
+            mastersLeft--;
+            widthLeft -= WIDTH;
+            nextX += WIDTH;
+        }
+    } else { // orientation left, right or center
+        float WIDTH       = WSSIZE.x;
+        float heightLeft  = WSSIZE.y;
+        int   mastersLeft = MASTERS;
+        float nextX       = 0;
+        float nextY       = 0;
+
+        if (STACKWINDOWS > 0 || centerMasterWindow)
+            WIDTH *= PMASTERNODE->percMaster;
+
+        if (orientation == ORIENTATION_RIGHT) {
+            nextX = WSSIZE.x - WIDTH;
+        } else if (centerMasterWindow) {
+            nextX = (WSSIZE.x - WIDTH) / 2;
+        }
+
+        for (auto& nd : m_lMasterNodesData) {
+            if (nd.workspaceID != PWORKSPACE->m_iID || !nd.isMaster)
+                continue;
+
+            float HEIGHT = mastersLeft > 1 ? heightLeft / mastersLeft * nd.percSize : heightLeft;
+            if (HEIGHT > heightLeft * 0.9f && mastersLeft > 1)
+                HEIGHT = heightLeft * 0.9f;
+
+            if (*PSMARTRESIZING) {
+                nd.percSize *= WSSIZE.y / masterAccumulatedSize;
+                HEIGHT = masterAverageSize * nd.percSize;
+            }
+
+            nd.size     = Vector2D(WIDTH, HEIGHT);
+            nd.position = WSPOS + Vector2D(nextX, nextY);
+            applyNodeDataToWindow(&nd);
+
+            mastersLeft--;
             heightLeft -= HEIGHT;
             nextY += HEIGHT;
-
-            applyNodeDataToWindow(&nd);
         }
-    } else if (orientation == ORIENTATION_TOP || orientation == ORIENTATION_BOTTOM) {
-        float       widthLeft = PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x;
+    }
+
+    if (STACKWINDOWS == 0)
+        return;
+
+    // compute placement of slave window(s)
+    int slavesLeft = STACKWINDOWS;
+    if (orientation == ORIENTATION_TOP || orientation == ORIENTATION_BOTTOM) {
+        const float HEIGHT    = WSSIZE.y - PMASTERNODE->size.y;
+        float       widthLeft = WSSIZE.x;
         float       nextX     = 0;
-        const float HEIGHT    = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y - PMASTERNODE->size.y;
+        float       nextY     = 0;
+
+        if (orientation == ORIENTATION_TOP)
+            nextY = PMASTERNODE->size.y;
 
         for (auto& nd : m_lMasterNodesData) {
             if (nd.workspaceID != PWORKSPACE->m_iID || nd.isMaster)
                 continue;
-            if (orientation == ORIENTATION_TOP) {
-                nd.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition +
-                    Vector2D(nextX, PMASTERNODE->percMaster * (PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y));
-            } else {
-                nd.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition + Vector2D(nextX, 0);
-            }
+
             float WIDTH = slavesLeft > 1 ? widthLeft / slavesLeft * nd.percSize : widthLeft;
             if (WIDTH > widthLeft * 0.9f && slavesLeft > 1)
                 WIDTH = widthLeft * 0.9f;
-            nd.size = Vector2D(WIDTH, HEIGHT);
+
+            if (*PSMARTRESIZING) {
+                nd.percSize *= WSSIZE.x / slaveAccumulatedSize;
+                WIDTH = slaveAverageSize * nd.percSize;
+            }
+
+            nd.size     = Vector2D(WIDTH, HEIGHT);
+            nd.position = WSPOS + Vector2D(nextX, nextY);
+            applyNodeDataToWindow(&nd);
 
             slavesLeft--;
             widthLeft -= WIDTH;
             nextX += WIDTH;
-
-            applyNodeDataToWindow(&nd);
         }
-    } else if (orientation == ORIENTATION_CENTER && STACKWINDOWS >= 2) {
-        float       heightLeftL = PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y - PMONITOR->vecReservedTopLeft.y;
-        float       heightLeftR = heightLeftL;
-        float       heightLeft  = 0;
-        float       nextYL      = 0;
-        float       nextYR      = 0;
-        const float WIDTH       = (PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x - PMONITOR->vecReservedTopLeft.x - PMASTERNODE->size.x) / 2.0;
-        bool        on_left     = true;
+    } else if (orientation == ORIENTATION_LEFT || orientation == ORIENTATION_RIGHT) {
+        const float WIDTH      = WSSIZE.x - PMASTERNODE->size.x;
+        float       heightLeft = WSSIZE.y;
+        float       nextY      = 0;
+        float       nextX      = 0;
 
-        int         slavesLeftL = 1 + (slavesLeft - 1) / 2;
-        int         slavesLeftR = slavesLeft - slavesLeftL;
+        if (orientation == ORIENTATION_LEFT)
+            nextX = PMASTERNODE->size.x;
 
         for (auto& nd : m_lMasterNodesData) {
             if (nd.workspaceID != PWORKSPACE->m_iID || nd.isMaster)
                 continue;
 
-            if (on_left) {
-                nd.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition + Vector2D(0, nextYL);
-                heightLeft  = heightLeftL;
-                slavesLeft  = slavesLeftL;
-            } else {
-                nd.position = PMONITOR->vecReservedTopLeft + PMONITOR->vecPosition + Vector2D(WIDTH + PMASTERNODE->size.x, nextYR);
-                heightLeft  = heightLeftR;
-                slavesLeft  = slavesLeftR;
-            }
             float HEIGHT = slavesLeft > 1 ? heightLeft / slavesLeft * nd.percSize : heightLeft;
             if (HEIGHT > heightLeft * 0.9f && slavesLeft > 1)
                 HEIGHT = heightLeft * 0.9f;
-            nd.size = Vector2D(WIDTH, HEIGHT);
 
-            if (on_left) {
-                heightLeftL -= HEIGHT;
-                nextYL += HEIGHT;
-                slavesLeftL--;
+            if (*PSMARTRESIZING) {
+                nd.percSize *= WSSIZE.y / slaveAccumulatedSize;
+                HEIGHT = slaveAverageSize * nd.percSize;
+            }
+
+            nd.size     = Vector2D(WIDTH, HEIGHT);
+            nd.position = WSPOS + Vector2D(nextX, nextY);
+            applyNodeDataToWindow(&nd);
+
+            slavesLeft--;
+            heightLeft -= HEIGHT;
+            nextY += HEIGHT;
+        }
+    } else { // slaves for centered master window(s)
+        const float WIDTH       = (WSSIZE.x - PMASTERNODE->size.x) / 2.0;
+        float       heightLeft  = 0;
+        float       heightLeftL = WSSIZE.y;
+        float       heightLeftR = WSSIZE.y;
+        float       nextX       = 0;
+        float       nextY       = 0;
+        float       nextYL      = 0;
+        float       nextYR      = 0;
+        bool        onRight     = true;
+
+        int         slavesLeftR = 1 + (slavesLeft - 1) / 2;
+        int         slavesLeftL = slavesLeft - slavesLeftR;
+
+        const float slaveAverageHeightL     = WSSIZE.y / slavesLeftL;
+        const float slaveAverageHeightR     = WSSIZE.y / slavesLeftR;
+        float       slaveAccumulatedHeightL = 0;
+        float       slaveAccumulatedHeightR = 0;
+        if (*PSMARTRESIZING) {
+            for (auto& nd : m_lMasterNodesData) {
+                if (nd.workspaceID != PWORKSPACE->m_iID || nd.isMaster)
+                    continue;
+
+                if (onRight) {
+                    slaveAccumulatedHeightR += slaveAverageHeightR * nd.percSize;
+                } else {
+                    slaveAccumulatedHeightL += slaveAverageHeightL * nd.percSize;
+                }
+                onRight = !onRight;
+            }
+            onRight = true;
+        }
+
+        for (auto& nd : m_lMasterNodesData) {
+            if (nd.workspaceID != PWORKSPACE->m_iID || nd.isMaster)
+                continue;
+
+            if (onRight) {
+                nextX      = WIDTH + PMASTERNODE->size.x;
+                nextY      = nextYR;
+                heightLeft = heightLeftR;
+                slavesLeft = slavesLeftR;
             } else {
+                nextX      = 0;
+                nextY      = nextYL;
+                heightLeft = heightLeftL;
+                slavesLeft = slavesLeftL;
+            }
+
+            float HEIGHT = slavesLeft > 1 ? heightLeft / slavesLeft * nd.percSize : heightLeft;
+            if (HEIGHT > heightLeft * 0.9f && slavesLeft > 1)
+                HEIGHT = heightLeft * 0.9f;
+
+            if (*PSMARTRESIZING) {
+                if (onRight) {
+                    nd.percSize *= WSSIZE.y / slaveAccumulatedHeightR;
+                    HEIGHT = slaveAverageHeightR * nd.percSize;
+                } else {
+                    nd.percSize *= WSSIZE.y / slaveAccumulatedHeightL;
+                    HEIGHT = slaveAverageHeightL * nd.percSize;
+                }
+            }
+
+            nd.size     = Vector2D(WIDTH, HEIGHT);
+            nd.position = WSPOS + Vector2D(nextX, nextY);
+            applyNodeDataToWindow(&nd);
+
+            if (onRight) {
                 heightLeftR -= HEIGHT;
                 nextYR += HEIGHT;
                 slavesLeftR--;
+            } else {
+                heightLeftL -= HEIGHT;
+                nextYL += HEIGHT;
+                slavesLeftL--;
             }
 
-            applyNodeDataToWindow(&nd);
-            on_left = !on_left;
+            onRight = !onRight;
         }
     }
 }
@@ -492,7 +584,7 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
     }
 
     if (!PMONITOR) {
-        Debug::log(ERR, "Orphaned Node %lx (workspace ID: %i)!!", pNode, pNode->workspaceID);
+        Debug::log(ERR, "Orphaned Node {}!!", pNode);
         return;
     }
 
@@ -505,28 +597,23 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
     const auto PWINDOW = pNode->pWindow;
     // get specific gaps and rules for this workspace,
     // if user specified them in config
-    const auto         WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID));
+    const auto WORKSPACERULE = g_pConfigManager->getWorkspaceRuleFor(g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID));
 
-    static auto* const PGAPSIN     = &g_pConfigManager->getConfigValuePtr("general:gaps_in")->intValue;
-    static auto* const PGAPSOUT    = &g_pConfigManager->getConfigValuePtr("general:gaps_out")->intValue;
-    static auto* const PBORDERSIZE = &g_pConfigManager->getConfigValuePtr("general:border_size")->intValue;
+    PWINDOW->updateSpecialRenderData();
+
+    static auto* const PGAPSIN         = &g_pConfigManager->getConfigValuePtr("general:gaps_in")->intValue;
+    static auto* const PGAPSOUT        = &g_pConfigManager->getConfigValuePtr("general:gaps_out")->intValue;
+    static auto* const PNOGAPSWHENONLY = &g_pConfigManager->getConfigValuePtr("master:no_gaps_when_only")->intValue;
+    static auto* const PANIMATE        = &g_pConfigManager->getConfigValuePtr("misc:animate_manual_resizes")->intValue;
 
     auto               gapsIn  = WORKSPACERULE.gapsIn.value_or(*PGAPSIN);
     auto               gapsOut = WORKSPACERULE.gapsOut.value_or(*PGAPSOUT);
-    auto               borderSize =
-        PWINDOW->m_sSpecialRenderData.borderSize.toUnderlying() != -1 ? PWINDOW->m_sSpecialRenderData.borderSize.toUnderlying() : WORKSPACERULE.borderSize.value_or(*PBORDERSIZE);
-    if (PWINDOW->m_sAdditionalConfigData.borderSize.toUnderlying() != -1)
-        borderSize = PWINDOW->m_sAdditionalConfigData.borderSize.toUnderlying();
-
-    borderSize *= PWINDOW->m_sSpecialRenderData.border && !PWINDOW->m_sAdditionalConfigData.forceNoBorder;
 
     if (!g_pCompositor->windowValidMapped(PWINDOW)) {
-        Debug::log(ERR, "Node %lx holding invalid window %lx!!", pNode, PWINDOW);
+        Debug::log(ERR, "Node {} holding invalid {}!!", pNode, PWINDOW);
         return;
     }
 
-    static auto* const PNOGAPSWHENONLY = &g_pConfigManager->getConfigValuePtr("master:no_gaps_when_only")->intValue;
-
     PWINDOW->m_vSize     = pNode->size;
     PWINDOW->m_vPosition = pNode->position;
 
@@ -534,29 +621,27 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
         (getNodesOnWorkspace(PWINDOW->m_iWorkspaceID) == 1 ||
          (PWINDOW->m_bIsFullscreen && g_pCompositor->getWorkspaceByID(PWINDOW->m_iWorkspaceID)->m_efFullscreenMode == FULLSCREEN_MAXIMIZED))) {
 
-        PWINDOW->m_sSpecialRenderData.rounding = false;
-        PWINDOW->m_sSpecialRenderData.decorate = WORKSPACERULE.decorate.value_or(true);
         PWINDOW->m_sSpecialRenderData.border   = WORKSPACERULE.border.value_or(*PNOGAPSWHENONLY == 2);
+        PWINDOW->m_sSpecialRenderData.decorate = WORKSPACERULE.decorate.value_or(true);
+        PWINDOW->m_sSpecialRenderData.rounding = false;
+        PWINDOW->m_sSpecialRenderData.shadow   = false;
 
         const auto RESERVED = PWINDOW->getFullWindowReservedArea();
 
-        borderSize *= PWINDOW->m_sSpecialRenderData.border;
+        const int  BORDERSIZE = PWINDOW->getRealBorderSize();
 
-        PWINDOW->m_vRealPosition = PWINDOW->m_vPosition + Vector2D(borderSize, borderSize) + RESERVED.topLeft;
-        PWINDOW->m_vRealSize     = PWINDOW->m_vSize - Vector2D(2 * borderSize, 2 * borderSize) - (RESERVED.topLeft + RESERVED.bottomRight);
+        PWINDOW->m_vRealPosition = PWINDOW->m_vPosition + Vector2D(BORDERSIZE, BORDERSIZE) + RESERVED.topLeft;
+        PWINDOW->m_vRealSize     = PWINDOW->m_vSize - Vector2D(2 * BORDERSIZE, 2 * BORDERSIZE) - (RESERVED.topLeft + RESERVED.bottomRight);
 
         PWINDOW->updateWindowDecos();
 
         return;
     }
 
-    PWINDOW->m_sSpecialRenderData.rounding   = WORKSPACERULE.rounding.value_or(true);
-    PWINDOW->m_sSpecialRenderData.decorate   = WORKSPACERULE.decorate.value_or(true);
-    PWINDOW->m_sSpecialRenderData.border     = WORKSPACERULE.border.value_or(true);
-    PWINDOW->m_sSpecialRenderData.borderSize = WORKSPACERULE.borderSize.value_or(-1);
+    const int  BORDERSIZE = PWINDOW->getRealBorderSize();
 
-    auto       calcPos  = PWINDOW->m_vPosition + Vector2D(borderSize, borderSize);
-    auto       calcSize = PWINDOW->m_vSize - Vector2D(2 * borderSize, 2 * borderSize);
+    auto       calcPos  = PWINDOW->m_vPosition + Vector2D(BORDERSIZE, BORDERSIZE);
+    auto       calcSize = PWINDOW->m_vSize - Vector2D(2 * BORDERSIZE, 2 * BORDERSIZE);
 
     const auto OFFSETTOPLEFT = Vector2D(DISPLAYLEFT ? gapsOut : gapsIn, DISPLAYTOP ? gapsOut : gapsIn);
 
@@ -583,7 +668,7 @@ void CHyprMasterLayout::applyNodeDataToWindow(SMasterNodeData* pNode) {
         g_pXWaylandManager->setWindowSize(PWINDOW, calcSize);
     }
 
-    if (m_bForceWarps) {
+    if (m_bForceWarps && !*PANIMATE) {
         g_pHyprRenderer->damageWindow(PWINDOW);
 
         PWINDOW->m_vRealPosition.warp();
@@ -613,24 +698,47 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
         return;
     }
 
-    // get monitor
-    const auto PMONITOR = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+    const auto         PMONITOR       = g_pCompositor->getMonitorFromID(PWINDOW->m_iMonitorID);
+    const auto         PWORKSPACEDATA = getMasterWorkspaceData(PMONITOR->activeWorkspace);
+    static auto* const ALWAYSCENTER   = &g_pConfigManager->getConfigValuePtr("master:always_center_master")->intValue;
+    static auto* const PSMARTRESIZING = &g_pConfigManager->getConfigValuePtr("master:smart_resizing")->intValue;
 
-    if (getNodesOnWorkspace(PWINDOW->m_iWorkspaceID) < 2)
+    eOrientation       orientation = PWORKSPACEDATA->orientation;
+    bool               centered    = orientation == ORIENTATION_CENTER && (*ALWAYSCENTER == 1);
+    double             delta       = 0;
+
+    const bool         DISPLAYBOTTOM = STICKS(PWINDOW->m_vPosition.y + PWINDOW->m_vSize.y, PMONITOR->vecPosition.y + PMONITOR->vecSize.y - PMONITOR->vecReservedBottomRight.y);
+    const bool         DISPLAYRIGHT  = STICKS(PWINDOW->m_vPosition.x + PWINDOW->m_vSize.x, PMONITOR->vecPosition.x + PMONITOR->vecSize.x - PMONITOR->vecReservedBottomRight.x);
+    const bool         DISPLAYTOP    = STICKS(PWINDOW->m_vPosition.y, PMONITOR->vecPosition.y + PMONITOR->vecReservedTopLeft.y);
+    const bool         DISPLAYLEFT   = STICKS(PWINDOW->m_vPosition.x, PMONITOR->vecPosition.x + PMONITOR->vecReservedTopLeft.x);
+
+    const bool         LEFT = corner == CORNER_TOPLEFT || corner == CORNER_BOTTOMLEFT;
+    const bool         TOP  = corner == CORNER_TOPLEFT || corner == CORNER_TOPRIGHT;
+    const bool         NONE = corner == CORNER_NONE;
+
+    const auto         MASTERS      = getMastersOnWorkspace(PNODE->workspaceID);
+    const auto         WINDOWS      = getNodesOnWorkspace(PNODE->workspaceID);
+    const auto         STACKWINDOWS = WINDOWS - MASTERS;
+
+    if (getNodesOnWorkspace(PWINDOW->m_iWorkspaceID) == 1 && !centered)
         return;
 
     m_bForceWarps = true;
 
-    const auto PWORKSPACEDATA = getMasterWorkspaceData(PMONITOR->activeWorkspace);
-
-    double     delta = 0;
-
-    switch (PWORKSPACEDATA->orientation) {
+    switch (orientation) {
         case ORIENTATION_LEFT: delta = pixResize.x / PMONITOR->vecSize.x; break;
         case ORIENTATION_RIGHT: delta = -pixResize.x / PMONITOR->vecSize.x; break;
         case ORIENTATION_BOTTOM: delta = -pixResize.y / PMONITOR->vecSize.y; break;
         case ORIENTATION_TOP: delta = pixResize.y / PMONITOR->vecSize.y; break;
-        case ORIENTATION_CENTER: delta = pixResize.x / PMONITOR->vecSize.x; break;
+        case ORIENTATION_CENTER:
+            delta = pixResize.x / PMONITOR->vecSize.x;
+            if (WINDOWS > 2) {
+                if (!NONE || !PNODE->isMaster)
+                    delta *= 2;
+                if ((!PNODE->isMaster && DISPLAYLEFT) || (PNODE->isMaster && LEFT && *PSMARTRESIZING))
+                    delta = -delta;
+            }
+            break;
         default: UNREACHABLE();
     }
 
@@ -640,20 +748,76 @@ void CHyprMasterLayout::resizeActiveWindow(const Vector2D& pixResize, eRectCorne
     }
 
     // check the up/down resize
-    const auto RESIZEDELTA = PWORKSPACEDATA->orientation % 2 == 1 ? pixResize.x : pixResize.y;
+    const bool isStackVertical = orientation == ORIENTATION_LEFT || orientation == ORIENTATION_RIGHT || orientation == ORIENTATION_CENTER;
 
-    if (RESIZEDELTA != 0) {
-        if (PNODE->isMaster && getMastersOnWorkspace(PNODE->workspaceID) > 1) {
-            // check master size
-            const auto SIZE = PWORKSPACEDATA->orientation % 2 == 1 ?
-                (PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x) / getMastersOnWorkspace(PNODE->workspaceID) :
-                (PMONITOR->vecSize.y - PMONITOR->vecReservedTopLeft.y - PMONITOR->vecReservedBottomRight.y) / getMastersOnWorkspace(PNODE->workspaceID);
-            PNODE->percSize = std::clamp(PNODE->percSize + RESIZEDELTA / SIZE, 0.05, 1.95);
-        } else if (!PNODE->isMaster && (getNodesOnWorkspace(PWINDOW->m_iWorkspaceID) - getMastersOnWorkspace(PNODE->workspaceID)) > 1) {
-            const auto SIZE = PWORKSPACEDATA->orientation % 2 == 1 ?
-                (PMONITOR->vecSize.x - PMONITOR->vecReservedTopLeft.x - PMONITOR->vecReservedBottomRight.x) / getNodesOnWorkspace(PNODE->workspaceID) :
-                (PMONITOR->vecSize.y - PMONITOR->vecReservedTopLeft.y - PMONITOR->vecReservedBottomRight.y) / getNodesOnWorkspace(PNODE->workspaceID);
+    const auto RESIZEDELTA = isStackVertical ? pixResize.y : pixResize.x;
+    const auto WSSIZE      = PMONITOR->vecSize - PMONITOR->vecReservedTopLeft - PMONITOR->vecReservedBottomRight;
+
+    auto       nodesInSameColumn = PNODE->isMaster ? MASTERS : STACKWINDOWS;
+    if (orientation == ORIENTATION_CENTER && !PNODE->isMaster)
+        nodesInSameColumn = DISPLAYRIGHT ? (nodesInSameColumn + 1) / 2 : nodesInSameColumn / 2;
+
+    const auto SIZE = isStackVertical ? WSSIZE.y / nodesInSameColumn : WSSIZE.x / nodesInSameColumn;
+
+    if (RESIZEDELTA != 0 && nodesInSameColumn > 1) {
+        if (!*PSMARTRESIZING) {
             PNODE->percSize = std::clamp(PNODE->percSize + RESIZEDELTA / SIZE, 0.05, 1.95);
+        } else {
+            const auto  NODEIT    = std::find(m_lMasterNodesData.begin(), m_lMasterNodesData.end(), *PNODE);
+            const auto  REVNODEIT = std::find(m_lMasterNodesData.rbegin(), m_lMasterNodesData.rend(), *PNODE);
+
+            const float totalSize       = isStackVertical ? WSSIZE.y : WSSIZE.x;
+            const float minSize         = totalSize / nodesInSameColumn * 0.2;
+            const bool  resizePrevNodes = isStackVertical ? (TOP || DISPLAYBOTTOM) && !DISPLAYTOP : (LEFT || DISPLAYRIGHT) && !DISPLAYLEFT;
+
+            int         nodesLeft = 0;
+            float       sizeLeft  = 0;
+            int         nodeCount = 0;
+            // check the sizes of all the nodes to be resized for later calculation
+            auto checkNodesLeft = [&sizeLeft, &nodesLeft, orientation, isStackVertical, &nodeCount, PNODE](auto it) {
+                if (it.isMaster != PNODE->isMaster || it.workspaceID != PNODE->workspaceID)
+                    return;
+                nodeCount++;
+                if (!it.isMaster && orientation == ORIENTATION_CENTER && nodeCount % 2 == 1)
+                    return;
+                sizeLeft += isStackVertical ? it.size.y : it.size.x;
+                nodesLeft++;
+            };
+            float resizeDiff;
+            if (resizePrevNodes) {
+                std::for_each(std::next(REVNODEIT), m_lMasterNodesData.rend(), checkNodesLeft);
+                resizeDiff = -RESIZEDELTA;
+            } else {
+                std::for_each(std::next(NODEIT), m_lMasterNodesData.end(), checkNodesLeft);
+                resizeDiff = RESIZEDELTA;
+            }
+
+            const float nodeSize        = isStackVertical ? PNODE->size.y : PNODE->size.x;
+            const float maxSizeIncrease = sizeLeft - nodesLeft * minSize;
+            const float maxSizeDecrease = minSize - nodeSize;
+
+            // leaves enough room for the other nodes
+            resizeDiff = std::clamp(resizeDiff, maxSizeDecrease, maxSizeIncrease);
+            PNODE->percSize += resizeDiff / SIZE;
+
+            // resize the other nodes
+            nodeCount            = 0;
+            auto resizeNodesLeft = [maxSizeIncrease, resizeDiff, minSize, orientation, isStackVertical, SIZE, &nodeCount, nodesLeft, PNODE](auto& it) {
+                if (it.isMaster != PNODE->isMaster || it.workspaceID != PNODE->workspaceID)
+                    return;
+                nodeCount++;
+                // if center orientation, only resize when on the same side
+                if (!it.isMaster && orientation == ORIENTATION_CENTER && nodeCount % 2 == 1)
+                    return;
+                const float size               = isStackVertical ? it.size.y : it.size.x;
+                const float resizeDeltaForEach = maxSizeIncrease != 0 ? resizeDiff * (size - minSize) / maxSizeIncrease : resizeDiff / nodesLeft;
+                it.percSize -= resizeDeltaForEach / SIZE;
+            };
+            if (resizePrevNodes) {
+                std::for_each(std::next(REVNODEIT), m_lMasterNodesData.rend(), resizeNodesLeft);
+            } else {
+                std::for_each(std::next(NODEIT), m_lMasterNodesData.end(), resizeNodesLeft);
+            }
         }
     }
 
@@ -695,9 +859,7 @@ void CHyprMasterLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreen
             pWindow->m_vRealPosition = pWindow->m_vLastFloatingPosition;
             pWindow->m_vRealSize     = pWindow->m_vLastFloatingSize;
 
-            pWindow->m_sSpecialRenderData.rounding = true;
-            pWindow->m_sSpecialRenderData.border   = true;
-            pWindow->m_sSpecialRenderData.decorate = true;
+            pWindow->updateSpecialRenderData();
         }
     } else {
         // if it now got fullscreen, make it fullscreen
@@ -737,7 +899,7 @@ void CHyprMasterLayout::fullscreenRequestForWindow(CWindow* pWindow, eFullscreen
 
     g_pXWaylandManager->setWindowSize(pWindow, pWindow->m_vRealSize.goalv());
 
-    g_pCompositor->moveWindowToTop(pWindow);
+    g_pCompositor->changeWindowZOrder(pWindow, true);
 
     recalculateMonitor(PMONITOR->ID);
 }
@@ -759,6 +921,15 @@ SWindowRenderLayoutHints CHyprMasterLayout::requestRenderHints(CWindow* pWindow)
     return hints; // master doesnt have any hints
 }
 
+void CHyprMasterLayout::moveWindowTo(CWindow* pWindow, const std::string& dir) {
+    if (!isDirection(dir))
+        return;
+
+    const auto PWINDOW2 = g_pCompositor->getWindowInDirection(pWindow, dir[0]);
+
+    switchWindows(pWindow, PWINDOW2);
+}
+
 void CHyprMasterLayout::switchWindows(CWindow* pWindow, CWindow* pWindow2) {
     // windows should be valid, insallah
 
@@ -855,7 +1026,7 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
             return;
 
         g_pCompositor->focusWindow(PWINDOWTOCHANGETO);
-        g_pCompositor->warpCursorTo(PWINDOWTOCHANGETO->m_vRealPosition.goalv() + PWINDOWTOCHANGETO->m_vRealSize.goalv() / 2.f);
+        g_pCompositor->warpCursorTo(PWINDOWTOCHANGETO->middle());
     };
 
     CVarList vars(message, 0, ' ');
@@ -1087,44 +1258,87 @@ std::any CHyprMasterLayout::layoutMessage(SLayoutMessageHeader header, std::stri
         recalculateMonitor(header.pWindow->m_iMonitorID);
 
     } else if (command == "orientationnext") {
-        const auto PWINDOW = header.pWindow;
-
-        if (!PWINDOW)
-            return 0;
-
-        prepareLoseFocus(PWINDOW);
-
-        const auto PWORKSPACEDATA = getMasterWorkspaceData(PWINDOW->m_iWorkspaceID);
-
-        if (PWORKSPACEDATA->orientation == ORIENTATION_CENTER) {
-            PWORKSPACEDATA->orientation = ORIENTATION_LEFT;
-        } else {
-            PWORKSPACEDATA->orientation = (eOrientation)(PWORKSPACEDATA->orientation + 1);
-        }
-
-        recalculateMonitor(header.pWindow->m_iMonitorID);
+        runOrientationCycle(header, nullptr, 1);
     } else if (command == "orientationprev") {
-        const auto PWINDOW = header.pWindow;
-
-        if (!PWINDOW)
-            return 0;
-
-        prepareLoseFocus(PWINDOW);
-
-        const auto PWORKSPACEDATA = getMasterWorkspaceData(PWINDOW->m_iWorkspaceID);
-
-        if (PWORKSPACEDATA->orientation == ORIENTATION_LEFT) {
-            PWORKSPACEDATA->orientation = ORIENTATION_CENTER;
-        } else {
-            PWORKSPACEDATA->orientation = (eOrientation)(PWORKSPACEDATA->orientation - 1);
+        runOrientationCycle(header, nullptr, -1);
+    } else if (command == "orientationcycle") {
+        runOrientationCycle(header, &vars, 1);
+    } else if (command == "mfact") {
+        if (vars.size() >= 2) {
+            float newMfact = 0;
+            try {
+                newMfact = std::stof(vars[1]);
+            } catch (std::exception& e) {
+                Debug::log(ERR, "Argument is invalid: {}", e.what());
+                return 0;
+            }
+            for (auto& nd : m_lMasterNodesData) {
+                if (nd.isMaster)
+                    nd.percMaster = std::clamp(newMfact, 0.05f, 0.95f);
+            }
         }
-
-        recalculateMonitor(header.pWindow->m_iMonitorID);
     }
 
     return 0;
 }
 
+// If vars is null, we use the default list
+void CHyprMasterLayout::runOrientationCycle(SLayoutMessageHeader& header, CVarList* vars, int direction) {
+    std::vector<eOrientation> cycle;
+    if (vars != nullptr)
+        buildOrientationCycleVectorFromVars(cycle, *vars);
+
+    if (cycle.size() == 0)
+        buildOrientationCycleVectorFromEOperation(cycle);
+
+    const auto PWINDOW = header.pWindow;
+
+    if (!PWINDOW)
+        return;
+
+    prepareLoseFocus(PWINDOW);
+
+    const auto PWORKSPACEDATA = getMasterWorkspaceData(PWINDOW->m_iWorkspaceID);
+
+    int        nextOrPrev = 0;
+    for (size_t i = 0; i < cycle.size(); ++i) {
+        if (PWORKSPACEDATA->orientation == cycle.at(i)) {
+            nextOrPrev = i + direction;
+            break;
+        }
+    }
+
+    if (nextOrPrev >= (int)cycle.size())
+        nextOrPrev = nextOrPrev % (int)cycle.size();
+    else if (nextOrPrev < 0)
+        nextOrPrev = cycle.size() + (nextOrPrev % (int)cycle.size());
+
+    PWORKSPACEDATA->orientation = cycle.at(nextOrPrev);
+    recalculateMonitor(header.pWindow->m_iMonitorID);
+}
+
+void CHyprMasterLayout::buildOrientationCycleVectorFromEOperation(std::vector<eOrientation>& cycle) {
+    for (int i = 0; i <= ORIENTATION_CENTER; ++i) {
+        cycle.push_back((eOrientation)i);
+    }
+}
+
+void CHyprMasterLayout::buildOrientationCycleVectorFromVars(std::vector<eOrientation>& cycle, CVarList& vars) {
+    for (size_t i = 1; i < vars.size(); ++i) {
+        if (vars[i] == "top") {
+            cycle.push_back(ORIENTATION_TOP);
+        } else if (vars[i] == "right") {
+            cycle.push_back(ORIENTATION_RIGHT);
+        } else if (vars[i] == "bottom") {
+            cycle.push_back(ORIENTATION_BOTTOM);
+        } else if (vars[i] == "left") {
+            cycle.push_back(ORIENTATION_LEFT);
+        } else if (vars[i] == "center") {
+            cycle.push_back(ORIENTATION_CENTER);
+        }
+    }
+}
+
 void CHyprMasterLayout::replaceWindowDataWith(CWindow* from, CWindow* to) {
     const auto PNODE = getNodeFromWindow(from);
 

src/layout/MasterLayout.hpp

@@ -1,15 +1,17 @@
 #pragma once
 
 #include "IHyprLayout.hpp"
+#include "../config/ConfigManager.hpp"
 #include <vector>
 #include <list>
 #include <deque>
 #include <any>
 
-enum eFullscreenMode : uint8_t;
+enum eFullscreenMode : int8_t;
 
 //orientation determines which side of the screen the master area resides
-enum eOrientation : uint8_t {
+enum eOrientation : uint8_t
+{
     ORIENTATION_LEFT = 0,
     ORIENTATION_TOP,
     ORIENTATION_RIGHT,
@@ -46,7 +48,7 @@ struct SMasterWorkspaceData {
 
 class CHyprMasterLayout : public IHyprLayout {
   public:
-    virtual void                     onWindowCreatedTiling(CWindow*);
+    virtual void                     onWindowCreatedTiling(CWindow*, eDirection direction = DIRECTION_DEFAULT);
     virtual void                     onWindowRemovedTiling(CWindow*);
     virtual bool                     isWindowTiled(CWindow*);
     virtual void                     recalculateMonitor(const int&);
@@ -56,6 +58,7 @@ class CHyprMasterLayout : public IHyprLayout {
     virtual std::any                 layoutMessage(SLayoutMessageHeader, std::string);
     virtual SWindowRenderLayoutHints requestRenderHints(CWindow*);
     virtual void                     switchWindows(CWindow*, CWindow*);
+    virtual void                     moveWindowTo(CWindow*, const std::string& dir);
     virtual void                     alterSplitRatio(CWindow*, float, bool);
     virtual std::string              getLayoutName();
     virtual void                     replaceWindowDataWith(CWindow* from, CWindow* to);
@@ -69,6 +72,9 @@ class CHyprMasterLayout : public IHyprLayout {
 
     bool                              m_bForceWarps = false;
 
+    void                              buildOrientationCycleVectorFromVars(std::vector<eOrientation>& cycle, CVarList& vars);
+    void                              buildOrientationCycleVectorFromEOperation(std::vector<eOrientation>& cycle);
+    void                              runOrientationCycle(SLayoutMessageHeader& header, CVarList* vars, int next);
     int                               getNodesOnWorkspace(const int&);
     void                              applyNodeDataToWindow(SMasterNodeData*);
     SMasterNodeData*                  getNodeFromWindow(CWindow*);
@@ -83,3 +89,19 @@ class CHyprMasterLayout : public IHyprLayout {
     friend struct SMasterNodeData;
     friend struct SMasterWorkspaceData;
 };
+
+template <typename CharT>
+struct std::formatter<SMasterNodeData*, CharT> : std::formatter<CharT> {
+    template <typename FormatContext>
+    auto format(const SMasterNodeData* const& node, FormatContext& ctx) const {
+        auto out = ctx.out();
+        if (!node)
+            return std::format_to(out, "[Node nullptr]");
+        std::format_to(out, "[Node {:x}: workspace: {}, pos: {:j2}, size: {:j2}", (uintptr_t)node, node->workspaceID, node->position, node->size);
+        if (node->isMaster)
+            std::format_to(out, ", master");
+        if (node->pWindow)
+            std::format_to(out, ", window: {:x}", node->pWindow);
+        return std::format_to(out, "]");
+    }
+};

src/macros.hpp

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <cmath>
+#include <csignal>
+#include <utility>
+
+#ifndef NDEBUG
+#ifdef HYPRLAND_DEBUG
+#define ISDEBUG true
+#else
+#define ISDEBUG false
+#endif
+#else
+#define ISDEBUG false
+#endif
+
+#include "version.h"
+
+#define SPECIAL_WORKSPACE_START (-99)
+
+#define PI 3.14159265358979
+
+#define STRVAL_EMPTY "[[EMPTY]]"
+
+#define LISTENER(name)                                                                                                                                                             \
+    void               listener_##name(wl_listener*, void*);                                                                                                                       \
+    inline wl_listener listen_##name = {.notify = listener_##name}
+#define DYNLISTENFUNC(name)    void listener_##name(void*, void*)
+#define DYNLISTENER(name)      CHyprWLListener hyprListener_##name
+#define DYNMULTILISTENER(name) wl_listener listen_##name
+
+#define VECINRECT(vec, x1, y1, x2, y2) ((vec).x >= (x1) && (vec).x <= (x2) && (vec).y >= (y1) && (vec).y <= (y2))
+
+#define DELTALESSTHAN(a, b, delta) (abs((a) - (b)) < (delta))
+
+#define STICKS(a, b) abs((a) - (b)) < 2
+
+#define HYPRATOM(name)                                                                                                                                                             \
+    { name, 0 }
+
+#define RASSERT(expr, reason, ...)                                                                                                                                                 \
+    if (!(expr)) {                                                                                                                                                                 \
+        Debug::log(CRIT, "\n==========================================================================================\nASSERTION FAILED! \n\n{}\n\nat: line {} in {}",            \
+                   std::format(reason, ##__VA_ARGS__), __LINE__,                                                                                                                   \
+                   ([]() constexpr->std::string { return std::string(__FILE__).substr(std::string(__FILE__).find_last_of('/') + 1); })());                                         \
+        printf("Assertion failed! See the log in /tmp/hypr/hyprland.log for more info.");                                                                                          \
+        raise(SIGABRT);                                                                                                                                                            \
+    }
+
+#define ASSERT(expr) RASSERT(expr, "?")
+
+// absolutely ridiculous formatter spec parsing
+#define FORMAT_PARSE(specs__, type__)                                                                                                                                              \
+    template <typename FormatContext>                                                                                                                                              \
+    constexpr auto parse(FormatContext& ctx) {                                                                                                                                     \
+        auto it = ctx.begin();                                                                                                                                                     \
+        for (; it != ctx.end() && *it != '}'; it++) {                                                                                                                              \
+            switch (*it) { specs__ default : throw std::format_error("invalid format specification"); }                                                                            \
+        }                                                                                                                                                                          \
+        return it;                                                                                                                                                                 \
+    }
+
+#define FORMAT_FLAG(spec__, flag__)                                                                                                                                                \
+    case spec__:                                                                                                                                                                   \
+        (flag__) = true;                                                                                                                                                           \
+        break;
+
+#define FORMAT_NUMBER(buf__)                                                                                                                                                       \
+    case '0':                                                                                                                                                                      \
+    case '1':                                                                                                                                                                      \
+    case '2':                                                                                                                                                                      \
+    case '3':                                                                                                                                                                      \
+    case '4':                                                                                                                                                                      \
+    case '5':                                                                                                                                                                      \
+    case '6':                                                                                                                                                                      \
+    case '7':                                                                                                                                                                      \
+    case '8':                                                                                                                                                                      \
+    case '9':                                                                                                                                                                      \
+        (buf__).push_back(*it);                                                                                                                                                    \
+        break;
+
+#if ISDEBUG
+#define UNREACHABLE()                                                                                                                                                              \
+    {                                                                                                                                                                              \
+        Debug::log(CRIT, "\n\nMEMORY CORRUPTED: Unreachable failed! (Reached an unreachable position, memory corruption!!!)");                                                     \
+        raise(SIGABRT);                                                                                                                                                            \
+    }
+#else
+#define UNREACHABLE() std::unreachable();
+#endif