tablet: added option to hide cursor (#12525)

* more natural Japanese translation

* src/i18n/Engine.cpp: change パーミッション -> 権限, fix TXT_KEY_SAFE_MODE_BUTTON_UNDERSTOOD Japanese translation

* src/i18n/Engine.cpp: clang-format processed

.clang-tidy

@@ -1,4 +1,111 @@
-WarningsAsErrors: '*'
+WarningsAsErrors: >
+  -*,
+  bugprone-*,
+  -bugprone-multi-level-implicit-pointer-conversion,
+  -bugprone-empty-catch,
+  -bugprone-unused-return-value,
+  -bugprone-reserved-identifier,
+  -bugprone-switch-missing-default-case,
+  -bugprone-unused-local-non-trivial-variable,
+  -bugprone-easily-swappable-parameters,
+  -bugprone-forward-declararion-namespace,
+  -bugprone-forward-declararion-namespace,
+  -bugprone-macro-parentheses,
+  -bugprone-narrowing-conversions,
+  -bugprone-branch-clone,
+  -bugprone-assignment-in-if-condition,
+  concurrency-*,
+  -concurrency-mt-unsafe,
+  cppcoreguidelines-*,
+  -cppcoreguidelines-pro-type-const-cast,
+  -cppcoreguidelines-owning-memory,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-pro-bounds-constant-array-index,
+  -cppcoreguidelines-avoid-const-or-ref-data-members,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
+  -cppcoreguidelines-avoid-goto,
+  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
+  -cppcoreguidelines-avoid-do-while,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -cppcoreguidelines-special-member-functions,
+  -cppcoreguidelines-explicit-virtual-functions,
+  -cppcoreguidelines-avoid-c-arrays,
+  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
+  -cppcoreguidelines-narrowing-conversions,
+  -cppcoreguidelines-pro-type-union-access,
+  -cppcoreguidelines-pro-type-member-init,
+  -cppcoreguidelines-macro-usage,
+  -cppcoreguidelines-macro-to-enum,
+  -cppcoreguidelines-init-variables,
+  -cppcoreguidelines-pro-type-cstyle-cast,
+  -cppcoreguidelines-pro-type-vararg,
+  -cppcoreguidelines-pro-type-reinterpret-cast,
+  -google-global-names-in-headers,
+  -google-readability-casting,
+  google-runtime-operator,
+  misc-*,
+  -misc-use-internal-linkage,
+  -misc-unused-parameters,
+  -misc-no-recursion,
+  -misc-non-private-member-variables-in-classes,
+  -misc-include-cleaner,
+  -misc-use-anonymous-namespace,
+  -misc-const-correctness,
+  modernize-*,
+  -modernize-use-emplace,
+  -modernize-redundant-void-arg,
+  -modernize-use-starts-ends-with,
+  -modernize-use-designated-initializers,
+  -modernize-use-std-numbers,
+  -modernize-return-braced-init-list,
+  -modernize-use-trailing-return-type,
+  -modernize-use-using,
+  -modernize-use-override,
+  -modernize-avoid-c-arrays,
+  -modernize-macro-to-enum,
+  -modernize-loop-convert,
+  -modernize-use-nodiscard,
+  -modernize-pass-by-value,
+  -modernize-use-auto,
+  performance-*,
+  -performance-inefficient-vector-operation,
+  -performance-inefficient-string-concatenation,
+  -performance-enum-size,
+  -performance-move-const-arg,
+  -performance-avoid-endl,
+  -performance-unnecessary-value-param,
+  portability-std-allocator-const,
+  readability-*,
+  -readability-identifier-naming,
+  -readability-use-std-min-max,
+  -readability-math-missing-parentheses,
+  -readability-simplify-boolean-expr,
+  -readability-static-accessed-through-instance,
+  -readability-use-anyofallof,
+  -readability-enum-initial-value,
+  -readability-redundant-inline-specifier,
+  -readability-function-cognitive-complexity,
+  -readability-function-size,
+  -readability-identifier-length,
+  -readability-magic-numbers,
+  -readability-uppercase-literal-suffix,
+  -readability-braces-around-statements,
+  -readability-redundant-access-specifiers,
+  -readability-else-after-return,
+  -readability-container-data-pointer,
+  -readability-implicit-bool-conversion,
+  -readability-avoid-nested-conditional-operator,
+  -readability-redundant-member-init,
+  -readability-redundant-string-init,
+  -readability-avoid-const-params-in-decls,
+  -readability-named-parameter,
+  -readability-convert-member-functions-to-static,
+  -readability-qualified-auto,
+  -readability-make-member-function-const,
+  -readability-isolate-declaration,
+  -readability-inconsistent-declaration-parameter-name,
+  -clang-diagnostic-error,
+
 HeaderFilterRegex: '.*\.hpp'
 FormatStyle: file
 Checks: >

.github/actions/setup_base/action.yml

@@ -24,6 +24,7 @@ runs:
           glm \
           glslang \
           go \
+          gtest \
           hyprlang \
           hyprcursor \
           jq \
@@ -45,6 +46,7 @@ runs:
           libxkbfile \
           lld \
           meson \
+          muparser \
           ninja \
           pango \
           pixman \
@@ -74,16 +76,25 @@ runs:
         cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
         cmake --install build
 
-    - name: Get hyprgraphics-git
+    - name: Get hyprwire-git
       shell: bash
       run: |
-        git clone https://github.com/hyprwm/hyprgraphics && cd hyprgraphics && cmake -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -B build && cmake --build build --target hyprgraphics && cmake --install build
+        git clone https://github.com/hyprwm/hyprwire --recursive
+        cd hyprwire
+        cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -S . -B ./build
+        cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
+        cmake --install build
 
     - name: Get hyprutils-git
       shell: bash
       run: |
         git clone https://github.com/hyprwm/hyprutils && cd hyprutils && cmake -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -B build && cmake --build build --target hyprutils && cmake --install build
 
+    - name: Get hyprgraphics-git
+      shell: bash
+      run: |
+        git clone https://github.com/hyprwm/hyprgraphics && cd hyprgraphics && cmake -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -B build && cmake --build build --target hyprgraphics && cmake --install build
+
     - name: Get aquamarine-git
       shell: bash
       run: |

.github/labeler.yml

@@ -22,6 +22,10 @@ protocols:
   - changed-files:
       - any-glob-to-any-file: ["protocols/**", "src/protocols/**"]
 
+start:
+  - changed-files:
+      - any-glob-to-any-file: "start/**"
+
 core:
   - changed-files:
       - any-glob-to-any-file: "src/**"

.github/workflows/ci.yaml

@@ -21,22 +21,19 @@ jobs:
 
       - name: Build Hyprland
         run: |
-          CFLAGS=-Werror CXXFLAGS=-Werror make all
+          CFLAGS=-Werror CXXFLAGS=-Werror make nopch
 
       - name: Compress and package artifacts
         run: |
           mkdir x86_64-pc-linux-gnu
           mkdir hyprland
-          mkdir hyprland/example
-          mkdir hyprland/assets
           cp ./LICENSE hyprland/
           cp build/Hyprland hyprland/
           cp build/hyprctl/hyprctl hyprland/
           cp build/hyprpm/hyprpm hyprland/
-          cp build/Hyprland hyprland/
           cp -r example/ hyprland/
           cp -r assets/ hyprland/
-          tar -cvf Hyprland.tar.xz hyprland
+          tar -cvJf Hyprland.tar.xz hyprland
 
       - name: Release
         uses: actions/upload-artifact@v4
@@ -44,86 +41,16 @@ jobs:
           name: Build archive
           path: Hyprland.tar.xz
 
-  meson:
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork
-    name: "Build Hyprland with Meson (Arch)"
-    runs-on: ubuntu-latest
-    container:
-      image: archlinux
-    steps:
-      - name: Checkout repository actions
-        uses: actions/checkout@v4
-        with:
-          sparse-checkout: .github/actions
-
-      - name: Setup base
-        uses: ./.github/actions/setup_base
-
-      - name: Configure
-        run: meson setup build -Ddefault_library=static
-
-      - name: Compile
-        run: ninja -C build
-
-  no-pch:
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork
-    name: "Build Hyprland without precompiled headers (Arch)"
-    runs-on: ubuntu-latest
-    container:
-      image: archlinux
-    steps:
-      - name: Checkout repository actions
-        uses: actions/checkout@v4
-        with:
-          sparse-checkout: .github/actions
-
-      - name: Setup base
-        uses: ./.github/actions/setup_base
-        with:
-          INSTALL_XORG_PKGS: true
-
-      - name: Compile
-        run: make nopch
-
-  noxwayland:
-    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork
-    name: "Build Hyprland in pure Wayland (Arch)"
-    runs-on: ubuntu-latest
-    container:
-      image: archlinux
-    steps:
-      - name: Checkout repository actions
-        uses: actions/checkout@v4
-        with:
-          sparse-checkout: .github/actions
-
-      - name: Setup base
-        uses: ./.github/actions/setup_base
-
-      - name: Configure
-        run: 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 release
-
   clang-format:
     permissions: read-all
     if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork
-    name: "Code Style (Arch)"
+    name: "Code Style"
     runs-on: ubuntu-latest
-    container:
-      image: archlinux
     steps:
-      - name: Checkout repository actions
+      - name: Checkout repository
         uses: actions/checkout@v4
-        with:
-          sparse-checkout: .github/actions
-
-      - name: Setup base
-        uses: ./.github/actions/setup_base
-
-      - name: Configure
-        run: meson setup build -Ddefault_library=static
 
       - name: clang-format check
-        run: ninja -C build clang-format-check
+        uses: jidicula/clang-format-action@v4.16.0
+        with:
+          exclude-regex: ^subprojects$

.github/workflows/clang-format.yml

@@ -4,43 +4,23 @@ jobs:
   clang-format:
     permissions: write-all
     if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork
-    name: "Code Style (Arch)"
+    name: "Code Style"
     runs-on: ubuntu-latest
-    container:
-      image: archlinux
     steps:
-      - name: Checkout repository actions
+      - name: Checkout repository
         uses: actions/checkout@v4
-        with:
-          sparse-checkout: .github/actions
-
-      - name: Setup base
-        uses: ./.github/actions/setup_base
-
-      - name: Configure
-        run: meson setup build -Ddefault_library=static
 
       - name: clang-format check
-        run: ninja -C build clang-format-check
+        uses: jidicula/clang-format-action@v4.16.0
+        with:
+          exclude-regex: ^subprojects$
 
-      - name: clang-format apply
+      - name: Create comment
-        if: ${{ failure() && github.event_name == 'pull_request' }}
-        run: ninja -C build clang-format
-
-      - name: Create patch
         if: ${{ failure() && github.event_name == 'pull_request' }}
         run: |
-          echo 'Please fix the formatting issues by running [`clang-format`](https://wiki.hyprland.org/Contributing-and-Debugging/PR-Guidelines/#code-style), or directly apply this patch:' > clang-format.patch
+          echo 'Please fix the formatting issues by running [`clang-format`](https://wiki.hyprland.org/Contributing-and-Debugging/PR-Guidelines/#code-style).' > clang-format.patch
-          echo '<details>' >> clang-format.patch
-          echo '<summary>clang-format.patch</summary>' >> clang-format.patch
-          echo >> clang-format.patch
-          echo '```diff' >> clang-format.patch
-          git diff >> clang-format.patch
-          echo '```' >> clang-format.patch
-          echo >> clang-format.patch
-          echo '</details>' >> clang-format.patch
 
-      - name: Comment patch
+      - name: Post comment
         if: ${{ failure() && github.event_name == 'pull_request' }}
         uses: mshick/add-pr-comment@v2
         with:

.github/workflows/new-pr-comment.yml

@@ -0,0 +1,45 @@
+name: "New MR welcome comment"
+
+on:
+  pull_request_target:
+    types:
+      - opened
+
+jobs:
+  comment:
+    if: >
+      github.event.pull_request.user.login != 'vaxerski' &&
+      github.event.pull_request.user.login != 'fufexan' &&
+      github.event.pull_request.user.login != 'gulafaran' &&
+      github.event.pull_request.user.login != 'ujint34' &&
+      github.event.pull_request.user.login != 'paideiadilemma' &&
+      github.event.pull_request.user.login != 'notashelf'
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+
+    env:
+      PR_COMMENT: |
+        Hello and thank you for making a PR to Hyprland!
+
+        Please check the [PR Guidelines](https://wiki.hypr.land/Contributing-and-Debugging/PR-Guidelines/) and make sure your PR follows them.
+        It will make the entire review process faster. :)
+
+        If your code can be tested, please always add tests. See more [here](https://wiki.hypr.land/Contributing-and-Debugging/Tests/).
+
+        _beep boop, I'm just a bot. A real human will review your PR soon._
+
+    steps:
+      - name: Add comment to PR
+        uses: actions/github-script@v7
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          script: |
+            const pr = context.payload.pull_request;
+
+            await github.rest.issues.createComment({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: pr.number,
+              body: process.env.PR_COMMENT,
+            });

.github/workflows/nix-build.yml

@@ -1,28 +0,0 @@
-name: Nix (Build)
-
-on:
-  workflow_call:
-    secrets:
-      CACHIX_AUTH_TOKEN:
-        required: false
-
-jobs:
-  build:
-    strategy:
-      matrix:
-        package:
-          - hyprland
-          # - hyprland-cross # cross compiling fails due to qt
-          # failure chain: hyprland-qtutils -> qt6.qtsvg -> qt6.qtbase -> psqlodbc & qt6.qttranslations
-          - xdg-desktop-portal-hyprland
-
-    runs-on: ubuntu-latest
-    steps:
-      - uses: DeterminateSystems/nix-installer-action@main
-
-      - uses: cachix/cachix-action@v15
-        with:
-          name: hyprland
-          authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
-
-      - run: nix build 'github:hyprwm/Hyprland?ref=${{ github.ref }}#${{ matrix.package }}' -L --extra-substituters "https://hyprland.cachix.org"

.github/workflows/nix-ci.yml

@@ -1,4 +1,4 @@
-name: Nix (CI)
+name: Nix
 
 on: [push, pull_request, workflow_dispatch]
 
@@ -8,7 +8,22 @@ jobs:
     uses: ./.github/workflows/nix-update-inputs.yml
     secrets: inherit
 
-  build:
+  hyprland:
     if: (github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork)
-    uses: ./.github/workflows/nix-build.yml
+    uses: ./.github/workflows/nix.yml
+    secrets: inherit
+    with:
+      command: nix build 'github:${{ github.repository }}?ref=${{ github.ref }}' -L --extra-substituters "https://hyprland.cachix.org"
+
+  xdph:
+    if: (github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork)
+    needs: hyprland
+    uses: ./.github/workflows/nix.yml
+    secrets: inherit
+    with:
+      command: nix build 'github:${{ github.repository }}?ref=${{ github.ref }}#xdg-desktop-portal-hyprland' -L --extra-substituters "https://hyprland.cachix.org"
+
+  test:
+    if: (github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork)
+    uses: ./.github/workflows/nix-test.yml
     secrets: inherit

.github/workflows/nix-test.yml

@@ -0,0 +1,47 @@
+name: Nix (Test)
+
+on:
+  workflow_call:
+    secrets:
+      CACHIX_AUTH_TOKEN:
+        required: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install Nix
+        uses: nixbuild/nix-quick-install-action@v31
+        with:
+          nix_conf: |
+            keep-env-derivations = true
+            keep-outputs = true
+
+      - name: Restore and save Nix store
+        uses: nix-community/cache-nix-action@v6
+        with:
+          # restore and save a cache using this key (per job)
+          primary-key: nix-${{ runner.os }}-${{ github.job }}
+          # if there's no cache hit, restore a cache by this prefix
+          restore-prefixes-first-match: nix-${{ runner.os }}
+          # collect garbage until the Nix store size (in bytes) is at most this number
+          # before trying to save a new cache
+          gc-max-store-size-linux: 5G
+
+      - uses: cachix/cachix-action@v15
+        with:
+          name: hyprland
+          authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
+
+      - name: Run test VM
+        run: nix build 'github:${{ github.repository }}?ref=${{ github.ref }}#checks.x86_64-linux.tests' -L --extra-substituters "https://hyprland.cachix.org"
+
+      - name: Check exit status
+        run: grep 0 result/exit_status
+
+      - name: Upload artifacts
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: logs
+          path: result

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

@@ -17,7 +17,24 @@ jobs:
         with:
           token: ${{ secrets.PAT }}
 
-      - uses: DeterminateSystems/nix-installer-action@main
+      - name: Install Nix
+        uses: nixbuild/nix-quick-install-action@v31
+        with:
+          nix_conf: |
+            keep-env-derivations = true
+            keep-outputs = true
+
+      - name: Restore and save Nix store
+        uses: nix-community/cache-nix-action@v6
+        with:
+          # restore and save a cache using this key (per job)
+          primary-key: nix-${{ runner.os }}-${{ github.job }}
+          # if there's no cache hit, restore a cache by this prefix
+          restore-prefixes-first-match: nix-${{ runner.os }}
+          # collect garbage until the Nix store size (in bytes) is at most this number
+          # before trying to save a new cache
+          gc-max-store-size-linux: 5G
+
       - name: Update inputs
         run: nix/update-inputs.sh
 

.github/workflows/nix.yml

@@ -0,0 +1,41 @@
+name: Build
+
+on:
+  workflow_call:
+    inputs:
+      command:
+        required: true
+        type: string
+        description: Command to run
+    secrets:
+      CACHIX_AUTH_TOKEN:
+        required: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install Nix
+        uses: nixbuild/nix-quick-install-action@v31
+        with:
+          nix_conf: |
+            keep-env-derivations = true
+            keep-outputs = true
+
+      - name: Restore and save Nix store
+        uses: nix-community/cache-nix-action@v6
+        with:
+          # restore and save a cache using this key (per job)
+          primary-key: nix-${{ runner.os }}-${{ github.job }}
+          # if there's no cache hit, restore a cache by this prefix
+          restore-prefixes-first-match: nix-${{ runner.os }}
+          # collect garbage until the Nix store size (in bytes) is at most this number
+          # before trying to save a new cache
+          gc-max-store-size-linux: 5G
+
+      - uses: cachix/cachix-action@v15
+        with:
+          name: hyprland
+          authToken: "${{ secrets.CACHIX_AUTH_TOKEN }}"
+
+      - run: ${{ inputs.command }}

.github/workflows/release.yaml

@@ -9,17 +9,36 @@ jobs:
   source-tarball:
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout Hyprland
+      - name: Checkout repository
-        id: checkout
+        uses: actions/checkout@v5
-        uses: actions/checkout@v4
         with:
+          fetch-depth: 0
           submodules: recursive
 
-      - name: Generate version
+      - name: Populate git info in version.h.in
-        id: genversion
         run: |
-          git fetch --unshallow || echo "failed unshallowing"
+          git fetch --tags --unshallow || true
-          bash -c scripts/generateVersion.sh
+
+          COMMIT_HASH=$(git rev-parse HEAD)
+          BRANCH="${GITHUB_REF_NAME:-$(git rev-parse --abbrev-ref HEAD)}"
+          COMMIT_MSG=$(git show -s --format=%s | sed 's/[&/]/\\&/g')
+          COMMIT_DATE=$(git show -s --format=%cd --date=local)
+          GIT_DIRTY=$(git diff-index --quiet HEAD -- && echo "clean" || echo "dirty")
+          GIT_TAG=$(git describe --tags --always || echo "unknown")
+          GIT_COMMITS=$(git rev-list --count HEAD)
+
+          echo "Branch: $BRANCH"
+          echo "Tag: $GIT_TAG"
+
+          sed -i \
+            -e "s|@GIT_COMMIT_HASH@|$COMMIT_HASH|" \
+            -e "s|@GIT_BRANCH@|$BRANCH|" \
+            -e "s|@GIT_COMMIT_MESSAGE@|$COMMIT_MSG|" \
+            -e "s|@GIT_COMMIT_DATE@|$COMMIT_DATE|" \
+            -e "s|@GIT_DIRTY@|$GIT_DIRTY|" \
+            -e "s|@GIT_TAG@|$GIT_TAG|" \
+            -e "s|@GIT_COMMITS@|$GIT_COMMITS|" \
+            src/version.h.in
 
       - name: Create tarball with submodules
         id: tar

.github/workflows/translation-ai-check.yml

@@ -0,0 +1,139 @@
+name: AI Translation Check
+
+on:
+  # pull_request_target:
+  #   types:
+  #     - opened
+  issue_comment:
+    types:
+      - created
+
+permissions:
+  contents: read
+  pull-requests: write
+  issues: write
+
+jobs:
+  review:
+    name: Review Translation
+    if: ${{ github.event_name == 'pull_request_target' || (github.event_name == 'issue_comment' && github.event.action == 'created' && github.event.issue.pull_request != null && github.event.comment.user.login == 'vaxerski' && github.event.comment.body == 'ai, please recheck' ) }}
+    runs-on: ubuntu-latest
+    env:
+      OPENAI_MODEL: gpt-5-mini
+      SYSTEM_PROMPT: |
+        You are a programmer and a translator. Your job is to review the attached patch for adding translation to a piece of software and make sure the submitted translation is not malicious, and that it makes sense. If the translation is not malicious, and doesn't contain obvious grammatical mistakes, say "Translation check OK". Otherwise, say "Translation check not ok" and list bad entries.
+        Examples of bad translations include obvious trolling (slurs, etc) or nonsense sentences. Meaningful improvements may be suggested, but if there are only minor improvements, just reply with "Translation check OK". Do not provide anything but the result and (if applicable) the bad entries or improvements.
+
+      AI_PROMPT: Translation patch below.
+
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v5
+
+      - uses: dorny/paths-filter@v3
+        id: changes
+        with:
+          filters: |
+            i18n:
+              - 'src/i18n/**'
+
+      - name: Stop if i18n not changed
+        if: steps.changes.outputs.i18n != 'true'
+        run: echo "No i18n changes in this PR; skipping." && exit 0
+
+      - name: Determine PR number
+        id: pr
+        run: |
+          if [ "${{ github.event_name }}" = "pull_request_target" ]; then
+            echo "number=${{ github.event.pull_request.number }}" >> "$GITHUB_OUTPUT"
+          else
+            echo "number=${{ github.event.issue.number }}" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Download combined PR diff
+        id: get_diff
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ steps.pr.outputs.number }}
+        run: |
+          # Get the combined diff for the entire PR
+          curl -sSL \
+            -H "Authorization: token $GITHUB_TOKEN" \
+            -H "Accept: application/vnd.github.v3.diff" \
+            "https://api.github.com/repos/${{ github.repository }}/pulls/$PR_NUMBER" \
+            -o pr.diff
+
+          # Compute character length
+          LEN=$(wc -c < pr.diff | tr -d ' ')
+          echo "len=$LEN" >> "$GITHUB_OUTPUT"
+          if [ "$LEN" -gt 25000 ]; then
+            echo "too_long=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "too_long=false" >> "$GITHUB_OUTPUT"
+          fi
+
+          echo "got diff:"
+          cat pr.diff
+
+      - name: Comment when diff length exceeded
+        if: steps.get_diff.outputs.too_long == 'true'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ steps.pr.outputs.number }}
+        run: |
+          jq -n --arg body "Diff length exceeded, can't query API" '{body: ("AI translation check result:\n\n" + $body)}' > body.json
+          curl -sS -X POST \
+            -H "Authorization: token $GITHUB_TOKEN" \
+            -H "Content-Type: application/json" \
+            "https://api.github.com/repos/${{ github.repository }}/issues/$PR_NUMBER/comments" \
+            --data @body.json
+
+      - name: Query OpenAI and post review
+        if: steps.get_diff.outputs.too_long == 'false'
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          OPENAI_MODEL: ${{ env.OPENAI_MODEL }}
+          SYSTEM_PROMPT: ${{ env.SYSTEM_PROMPT }}
+          AI_PROMPT: ${{ env.AI_PROMPT }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ steps.pr.outputs.number }}
+        run: |
+          # Prepare OpenAI chat request payload (embed diff safely)
+          jq -n \
+            --arg model "$OPENAI_MODEL" \
+            --arg sys "$SYSTEM_PROMPT" \
+            --arg prompt "$AI_PROMPT" \
+            --rawfile diff pr.diff \
+            '{model:$model,
+              messages:[
+                {role:"system", content:$sys},
+                {role:"user", content: ($prompt + "\n\n```diff\n" + $diff + "\n```")}
+              ]
+            }' > payload.json
+
+          # Call OpenAI
+          curl -sS https://api.openai.com/v1/chat/completions \
+            -H "Authorization: Bearer $OPENAI_API_KEY" \
+            -H "Content-Type: application/json" \
+            -d @payload.json > response.json
+
+          # Extract response text
+          COMMENT=$(jq -r '.choices[0].message.content // empty' response.json)
+          if [ -z "$COMMENT" ]; then
+            COMMENT="AI did not return a response."
+          fi
+
+          # If failed, add a note
+          ADDITIONAL_NOTE=""
+          if [[ "$COMMENT" == *"not ok"* ]]; then
+            ADDITIONAL_NOTE=$(echo -ne "\n\nPlease note this check is a guideline, not a hard requirement. It is here to help you translate. If you disagree with some points, just state that. Any typos should be fixed.")
+          fi
+
+          # Post the review as a PR comment
+          jq -n --arg body "$COMMENT" --arg note "$ADDITIONAL_NOTE" '{body: ("AI translation check result:\n\n" + $body + $note)}' > body.json
+          echo "CURLing https://api.github.com/repos/${{ github.repository }}/issues/$PR_NUMBER/comments"
+          curl -sS -X POST \
+            -H "Authorization: token $GITHUB_TOKEN" \
+            -H "Content-Type: application/json" \
+            "https://api.github.com/repos/${{ github.repository }}/issues/$PR_NUMBER/comments" \
+            --data @body.json

.gitignore

@@ -32,6 +32,8 @@ src/render/shaders/*.inc
 src/render/shaders/Shaders.hpp
 
 hyprctl/hyprctl
+hyprctl/hw-protocols/*.c*
+hyprctl/hw-protocols/*.h*
 
 gmon.out
 *.out

CMakeLists.txt

@@ -9,6 +9,7 @@ project(
   DESCRIPTION "A Modern C++ Wayland Compositor"
   VERSION ${VER})
 
+include(CTest)
 include(CheckIncludeFile)
 include(GNUInstallDirs)
 
@@ -16,18 +17,21 @@ set(HYPRLAND_VERSION ${VER})
 set(PREFIX ${CMAKE_INSTALL_PREFIX})
 set(INCLUDEDIR ${CMAKE_INSTALL_INCLUDEDIR})
 set(BINDIR ${CMAKE_INSTALL_BINDIR})
-configure_file(hyprland.pc.in hyprland.pc @ONLY)
 
 set(CMAKE_MESSAGE_LOG_LEVEL "STATUS")
 
 message(STATUS "Gathering git info")
 
-# Get git info hash and branch
-execute_process(COMMAND ./scripts/generateVersion.sh
-                WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
 # Make shader files includable
 execute_process(COMMAND ./scripts/generateShaderIncludes.sh
-                WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+                WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+                RESULT_VARIABLE HYPR_SHADER_GEN_RESULT)
+if(NOT HYPR_SHADER_GEN_RESULT EQUAL 0)
+  message(
+    FATAL_ERROR
+      "Failed to generate shader includes (scripts/generateShaderIncludes.sh), exit code: ${HYPR_SHADER_GEN_RESULT}"
+  )
+endif()
 
 find_package(PkgConfig REQUIRED)
 
@@ -35,12 +39,24 @@ find_package(PkgConfig REQUIRED)
 # provide a .pc file and won't be detected this way
 pkg_check_modules(udis_dep IMPORTED_TARGET udis86>=1.7.2)
 
-# Fallback to subproject
+# Find non-pkgconfig udis86, otherwise fallback to subproject
 if(NOT udis_dep_FOUND)
+  find_library(udis_nopc udis86)
+  if(NOT("${udis_nopc}" MATCHES "udis_nopc-NOTFOUND"))
+    message(STATUS "Found udis86 at ${udis_nopc}")
+  else()
     add_subdirectory("subprojects/udis86")
     include_directories("subprojects/udis86")
     message(STATUS "udis86 dependency not found, falling back to subproject")
   endif()
+endif()
+
+find_library(librt rt)
+if("${librt}" MATCHES "librt-NOTFOUND")
+  unset(LIBRT)
+else()
+  set(LIBRT rt)
+endif()
 
 if(CMAKE_BUILD_TYPE)
   string(TOLOWER ${CMAKE_BUILD_TYPE} BUILDTYPE_LOWER)
@@ -70,9 +86,11 @@ message(
 if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
   message(STATUS "Configuring Hyprland in Debug with CMake")
   add_compile_definitions(HYPRLAND_DEBUG)
+  set(BUILD_TESTING ON)
 else()
   add_compile_options(-O3)
   message(STATUS "Configuring Hyprland in Release with CMake")
+  set(BUILD_TESTING OFF)
 endif()
 
 add_compile_definitions(HYPRLAND_VERSION="${HYPRLAND_VERSION}")
@@ -84,14 +102,19 @@ set(CXX_STANDARD_REQUIRED ON)
 add_compile_options(
   -Wall
   -Wextra
+  -Wpedantic
   -Wno-unused-parameter
   -Wno-unused-value
   -Wno-missing-field-initializers
+  -Wno-gnu-zero-variadic-macro-arguments
   -Wno-narrowing
   -Wno-pointer-arith
   -Wno-clobbered
   -fmacro-prefix-map=${CMAKE_SOURCE_DIR}/=)
 
+# disable lto as it may break plugins
+add_compile_options(-fno-lto)
+
 set(CMAKE_EXECUTABLE_ENABLE_EXPORTS TRUE)
 set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)
 
@@ -99,55 +122,156 @@ message(STATUS "Checking deps...")
 
 find_package(Threads REQUIRED)
 
-if(LEGACY_RENDERER)
-  set(GLES_VERSION "GLES2")
-else()
 set(GLES_VERSION "GLES3")
-endif()
 find_package(OpenGL REQUIRED COMPONENTS ${GLES_VERSION})
 
-pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine>=0.8.0)
+set(AQUAMARINE_MINIMUM_VERSION 0.9.3)
-pkg_check_modules(hyprlang_dep REQUIRED IMPORTED_TARGET hyprlang>=0.3.2)
+set(HYPRLANG_MINIMUM_VERSION 0.6.7)
-pkg_check_modules(hyprcursor_dep REQUIRED IMPORTED_TARGET hyprcursor>=0.1.7)
+set(HYPRCURSOR_MINIMUM_VERSION 0.1.7)
-pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=0.7.0)
+set(HYPRUTILS_MINIMUM_VERSION 0.11.0)
-pkg_check_modules(hyprgraphics_dep REQUIRED IMPORTED_TARGET hyprgraphics>=0.1.1)
+set(HYPRGRAPHICS_MINIMUM_VERSION 0.1.6)
+
+pkg_check_modules(aquamarine_dep REQUIRED IMPORTED_TARGET aquamarine>=${AQUAMARINE_MINIMUM_VERSION})
+pkg_check_modules(hyprlang_dep REQUIRED IMPORTED_TARGET hyprlang>=${HYPRLANG_MINIMUM_VERSION})
+pkg_check_modules(hyprcursor_dep REQUIRED IMPORTED_TARGET hyprcursor>=${HYPRCURSOR_MINIMUM_VERSION})
+pkg_check_modules(hyprutils_dep REQUIRED IMPORTED_TARGET hyprutils>=${HYPRUTILS_MINIMUM_VERSION})
+pkg_check_modules(hyprgraphics_dep REQUIRED IMPORTED_TARGET hyprgraphics>=${HYPRGRAPHICS_MINIMUM_VERSION})
 
 string(REPLACE "." ";" AQ_VERSION_LIST ${aquamarine_dep_VERSION})
 list(GET AQ_VERSION_LIST 0 AQ_VERSION_MAJOR)
 list(GET AQ_VERSION_LIST 1 AQ_VERSION_MINOR)
 list(GET AQ_VERSION_LIST 2 AQ_VERSION_PATCH)
 
-add_compile_definitions(AQUAMARINE_VERSION="${aquamarine_dep_VERSION}")
+set(AQUAMARINE_VERSION "${aquamarine_dep_VERSION}")
-add_compile_definitions(AQUAMARINE_VERSION_MAJOR=${AQ_VERSION_MAJOR})
+set(AQUAMARINE_VERSION_MAJOR "${AQ_VERSION_MAJOR}")
-add_compile_definitions(AQUAMARINE_VERSION_MINOR=${AQ_VERSION_MINOR})
+set(AQUAMARINE_VERSION_MINOR "${AQ_VERSION_MINOR}")
-add_compile_definitions(AQUAMARINE_VERSION_PATCH=${AQ_VERSION_PATCH})
+set(AQUAMARINE_VERSION_PATCH "${AQ_VERSION_PATCH}")
-add_compile_definitions(HYPRLANG_VERSION="${hyprlang_dep_VERSION}")
+set(HYPRLANG_VERSION "${hyprlang_dep_VERSION}")
-add_compile_definitions(HYPRUTILS_VERSION="${hyprutils_dep_VERSION}")
+set(HYPRUTILS_VERSION "${hyprutils_dep_VERSION}")
-add_compile_definitions(HYPRCURSOR_VERSION="${hyprcursor_dep_VERSION}")
+set(HYPRCURSOR_VERSION "${hyprcursor_dep_VERSION}")
-add_compile_definitions(HYPRGRAPHICS_VERSION="${hyprgraphics_dep_VERSION}")
+set(HYPRGRAPHICS_VERSION "${hyprgraphics_dep_VERSION}")
+
+
+find_package(Git QUIET)
+
+# Populate variables with env vars if present
+set(GIT_COMMIT_HASH "$ENV{GIT_COMMIT_HASH}")
+if(NOT GIT_COMMIT_HASH)
+  set(GIT_COMMIT_HASH "unknown")
+endif()
+
+set(GIT_BRANCH "$ENV{GIT_BRANCH}")
+if(NOT GIT_BRANCH)
+  set(GIT_BRANCH "unknown")
+endif()
+
+set(GIT_COMMIT_MESSAGE "$ENV{GIT_COMMIT_MESSAGE}")
+if(NOT GIT_COMMIT_MESSAGE)
+  set(GIT_COMMIT_MESSAGE "unknown")
+endif()
+
+set(GIT_COMMIT_DATE "$ENV{GIT_COMMIT_DATE}")
+if(NOT GIT_COMMIT_DATE)
+  set(GIT_COMMIT_DATE "unknown")
+endif()
+
+set(GIT_DIRTY "$ENV{GIT_DIRTY}")
+if(NOT GIT_DIRTY)
+  set(GIT_DIRTY "unknown")
+endif()
+
+set(GIT_TAG "$ENV{GIT_TAG}")
+if(NOT GIT_TAG)
+  set(GIT_TAG "unknown")
+endif()
+
+set(GIT_COMMITS "$ENV{GIT_COMMITS}")
+if(NOT GIT_COMMITS)
+  set(GIT_COMMITS "0")
+endif()
+
+if(Git_FOUND)
+  execute_process(
+    COMMAND ${GIT_EXECUTABLE} rev-parse --show-toplevel
+    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    OUTPUT_VARIABLE GIT_TOPLEVEL
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_QUIET
+    RESULT_VARIABLE GIT_TOPLEVEL_RESULT
+  )
+
+  if(GIT_TOPLEVEL_RESULT EQUAL 0)
+    message(STATUS "Detected git repository root: ${GIT_TOPLEVEL}")
+
+    execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse HEAD
+      WORKING_DIRECTORY ${GIT_TOPLEVEL}
+      OUTPUT_VARIABLE GIT_COMMIT_HASH OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(COMMAND ${GIT_EXECUTABLE} branch --show-current
+      WORKING_DIRECTORY ${GIT_TOPLEVEL}
+      OUTPUT_VARIABLE GIT_BRANCH OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(COMMAND sh "-c" "${GIT_EXECUTABLE} show -s --format=%s --no-show-signature | sed \"s/\\\"/\'/g\""
+      WORKING_DIRECTORY ${GIT_TOPLEVEL}
+      OUTPUT_VARIABLE GIT_COMMIT_MESSAGE OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(COMMAND ${GIT_EXECUTABLE} show -s --format=%cd --date=local --no-show-signature
+      WORKING_DIRECTORY ${GIT_TOPLEVEL}
+      OUTPUT_VARIABLE GIT_COMMIT_DATE OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(COMMAND ${GIT_EXECUTABLE} diff-index --quiet HEAD --
+      WORKING_DIRECTORY ${GIT_TOPLEVEL}
+      RESULT_VARIABLE GIT_DIRTY_RESULT)
+    if(NOT GIT_DIRTY_RESULT EQUAL 0)
+      set(GIT_DIRTY "dirty")
+    else()
+      set(GIT_DIRTY "clean")
+    endif()
+    execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags
+      WORKING_DIRECTORY ${GIT_TOPLEVEL}
+      OUTPUT_VARIABLE GIT_TAG OUTPUT_STRIP_TRAILING_WHITESPACE)
+    execute_process(COMMAND ${GIT_EXECUTABLE} rev-list --count HEAD
+      WORKING_DIRECTORY ${GIT_TOPLEVEL}
+      OUTPUT_VARIABLE GIT_COMMITS OUTPUT_STRIP_TRAILING_WHITESPACE)
+  else()
+    message(WARNING "No Git repository detected in ${CMAKE_SOURCE_DIR}")
+  endif()
+endif()
+
+configure_file(
+    ${CMAKE_SOURCE_DIR}/src/version.h.in
+    ${CMAKE_SOURCE_DIR}/src/version.h
+    @ONLY
+)
+
+set_source_files_properties(${CMAKE_SOURCE_DIR}/src/version.h PROPERTIES GENERATED TRUE)
+
+set(XKBCOMMON_MINIMUM_VERSION 1.11.0)
+set(WAYLAND_SERVER_MINIMUM_VERSION 1.22.90)
+set(WAYLAND_SERVER_PROTOCOLS_MINIMUM_VERSION 1.45)
+set(LIBINPUT_MINIMUM_VERSION 1.28)
 
 pkg_check_modules(
   deps
   REQUIRED
-  IMPORTED_TARGET
+  IMPORTED_TARGET GLOBAL
-  xkbcommon
+  xkbcommon>=${XKBCOMMON_MINIMUM_VERSION}
   uuid
-  wayland-server>=1.22.90
+  wayland-server>=${WAYLAND_SERVER_MINIMUM_VERSION}
-  wayland-protocols>=1.43
+  wayland-protocols>=${WAYLAND_SERVER_PROTOCOLS_MINIMUM_VERSION}
   cairo
   pango
   pangocairo
   pixman-1
   xcursor
   libdrm
-  libinput
+  libinput>=${LIBINPUT_MINIMUM_VERSION}
   gbm
   gio-2.0
-  re2)
+  re2
+  muparser)
 
 find_package(hyprwayland-scanner 0.3.10 REQUIRED)
 
 file(GLOB_RECURSE SRCFILES "src/*.cpp")
+get_filename_component(FULL_MAIN_PATH ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp ABSOLUTE)
+list(REMOVE_ITEM SRCFILES "${FULL_MAIN_PATH}")
 
 set(TRACY_CPP_FILES "")
 if(USE_TRACY)
@@ -155,9 +279,14 @@ if(USE_TRACY)
   message(STATUS "Tracy enabled, TRACY_CPP_FILES: " ${TRACY_CPP_FILES})
 endif()
 
-add_executable(Hyprland ${SRCFILES} ${TRACY_CPP_FILES})
+add_library(hyprland_lib STATIC ${SRCFILES})
+add_executable(Hyprland src/main.cpp ${TRACY_CPP_FILES})
+target_link_libraries(Hyprland hyprland_lib)
 
-set(USE_GPROF ON)
+target_include_directories(hyprland_lib PUBLIC ${deps_INCLUDE_DIRS})
+target_include_directories(Hyprland PUBLIC ${deps_INCLUDE_DIRS})
+
+set(USE_GPROF OFF)
 
 if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
   message(STATUS "Setting debug flags")
@@ -165,8 +294,8 @@ if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
   if(WITH_ASAN)
     message(STATUS "Enabling ASan")
 
-    target_link_libraries(Hyprland asan)
+    target_link_libraries(hyprland_lib PUBLIC asan)
-    target_compile_options(Hyprland PUBLIC -fsanitize=address)
+    target_compile_options(hyprland_lib PUBLIC -fsanitize=address)
   endif()
 
   if(USE_TRACY)
@@ -176,7 +305,7 @@ if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
     option(TRACY_ON_DEMAND "" ON)
     add_subdirectory(subprojects/tracy)
 
-    target_link_libraries(Hyprland Tracy::TracyClient)
+    target_link_libraries(hyprland_lib PUBLIC Tracy::TracyClient)
 
     if(USE_TRACY_GPU)
       message(STATUS "Tracy GPU Profiling is turned on")
@@ -192,6 +321,10 @@ if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
   endif()
 endif()
 
+if(BUILT_WITH_NIX)
+  add_compile_definitions(BUILT_WITH_NIX)
+endif()
+
 check_include_file("execinfo.h" EXECINFOH)
 if(EXECINFOH)
   message(STATUS "Configuration supports execinfo")
@@ -201,24 +334,19 @@ endif()
 include(CheckLibraryExists)
 check_library_exists(execinfo backtrace "" HAVE_LIBEXECINFO)
 if(HAVE_LIBEXECINFO)
-  target_link_libraries(Hyprland execinfo)
+  target_link_libraries(hyprland_lib PUBLIC execinfo)
 endif()
 
 check_include_file("sys/timerfd.h" HAS_TIMERFD)
 pkg_check_modules(epoll IMPORTED_TARGET epoll-shim)
 if(NOT HAS_TIMERFD AND epoll_FOUND)
-  target_link_libraries(Hyprland PkgConfig::epoll)
+  target_link_libraries(hyprland_lib PUBLIC PkgConfig::epoll)
 endif()
 
 check_include_file("sys/inotify.h" HAS_INOTIFY)
 pkg_check_modules(inotify IMPORTED_TARGET libinotify)
 if(NOT HAS_INOTIFY AND inotify_FOUND)
-  target_link_libraries(Hyprland PkgConfig::inotify)
+  target_link_libraries(hyprland_lib PUBLIC PkgConfig::inotify)
-endif()
-
-if(LEGACY_RENDERER)
-  message(STATUS "Using the legacy GLES2 renderer!")
-  add_compile_definitions(LEGACY_RENDERER)
 endif()
 
 if(NO_XWAYLAND)
@@ -226,10 +354,7 @@ if(NO_XWAYLAND)
   add_compile_definitions(NO_XWAYLAND)
 else()
   message(STATUS "XWAYLAND Enabled (NO_XWAYLAND not defined) checking deps...")
-  pkg_check_modules(
+  set(XWAYLAND_DEPENDENCIES
-    xdeps
-    REQUIRED
-    IMPORTED_TARGET
     xcb
     xcb-render
     xcb-xfixes
@@ -237,9 +362,21 @@ else()
     xcb-composite
     xcb-res
     xcb-errors)
-  target_link_libraries(Hyprland PkgConfig::xdeps)
+
+  pkg_check_modules(
+    xdeps
+    REQUIRED
+    IMPORTED_TARGET
+    ${XWAYLAND_DEPENDENCIES})
+
+  string(JOIN ", " PKGCONFIG_XWAYLAND_DEPENDENCIES ${XWAYLAND_DEPENDENCIES})
+  string(PREPEND PKGCONFIG_XWAYLAND_DEPENDENCIES ", ")
+
+  target_link_libraries(hyprland_lib PUBLIC PkgConfig::xdeps)
 endif()
 
+configure_file(hyprland.pc.in hyprland.pc @ONLY)
+
 if(NO_SYSTEMD)
   message(STATUS "SYSTEMD support is disabled...")
 else()
@@ -260,30 +397,42 @@ set(CPACK_PROJECT_NAME ${PROJECT_NAME})
 set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
 include(CPack)
 
+if(CMAKE_DISABLE_PRECOMPILE_HEADERS)
+  message(STATUS "Not using precompiled headers")
+else()
   message(STATUS "Setting precompiled headers")
-
+  target_precompile_headers(hyprland_lib PRIVATE
-target_precompile_headers(Hyprland PRIVATE
                             $<$<COMPILE_LANGUAGE:CXX>:src/pch/pch.hpp>)
+endif()
 
 message(STATUS "Setting link libraries")
 
 target_link_libraries(
-  Hyprland
+  hyprland_lib
-  rt
+  PUBLIC
   PkgConfig::aquamarine_dep
   PkgConfig::hyprlang_dep
   PkgConfig::hyprutils_dep
   PkgConfig::hyprcursor_dep
   PkgConfig::hyprgraphics_dep
-  PkgConfig::deps)
+  PkgConfig::deps
+)
+
+target_link_libraries(
+  Hyprland
+  ${LIBRT}
+  hyprland_lib)
 if(udis_dep_FOUND)
-  target_link_libraries(Hyprland PkgConfig::udis_dep)
+  target_link_libraries(hyprland_lib PUBLIC PkgConfig::udis_dep)
+elseif(NOT("${udis_nopc}" MATCHES "udis_nopc-NOTFOUND"))
+  target_link_libraries(hyprland_lib PUBLIC ${udis_nopc})
 else()
-  target_link_libraries(Hyprland libudis86)
+  target_link_libraries(hyprland_lib PUBLIC libudis86)
 endif()
 
 # used by `make installheaders`, to ensure the headers are generated
 add_custom_target(generate-protocol-headers)
+set(PROTOCOL_SOURCES "")
 
 function(protocolnew protoPath protoName external)
   if(external)
@@ -297,10 +446,15 @@ function(protocolnew protoPath protoName external)
     COMMAND hyprwayland-scanner ${path}/${protoName}.xml
             ${CMAKE_SOURCE_DIR}/protocols/
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
-  target_sources(Hyprland PRIVATE protocols/${protoName}.cpp
+  target_sources(hyprland_lib PRIVATE protocols/${protoName}.cpp
                                   protocols/${protoName}.hpp)
   target_sources(generate-protocol-headers
                  PRIVATE ${CMAKE_SOURCE_DIR}/protocols/${protoName}.hpp)
+
+  list(APPEND PROTOCOL_SOURCES "${CMAKE_SOURCE_DIR}/protocols/${protoName}.cpp")
+  set(PROTOCOL_SOURCES "${PROTOCOL_SOURCES}" PARENT_SCOPE)
+  list(APPEND PROTOCOL_SOURCES "${CMAKE_SOURCE_DIR}/protocols/${protoName}.hpp")
+  set(PROTOCOL_SOURCES "${PROTOCOL_SOURCES}" PARENT_SCOPE)
 endfunction()
 function(protocolWayland)
   add_custom_command(
@@ -310,12 +464,17 @@ function(protocolWayland)
       hyprwayland-scanner --wayland-enums
       ${WAYLAND_SCANNER_PKGDATA_DIR}/wayland.xml ${CMAKE_SOURCE_DIR}/protocols/
     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
-  target_sources(Hyprland PRIVATE protocols/wayland.cpp protocols/wayland.hpp)
+  target_sources(hyprland_lib PRIVATE protocols/wayland.cpp protocols/wayland.hpp)
   target_sources(generate-protocol-headers
                  PRIVATE ${CMAKE_SOURCE_DIR}/protocols/wayland.hpp)
+
+  list(APPEND PROTOCOL_SOURCES "${CMAKE_SOURCE_DIR}/protocols/wayland.hpp")
+  set(PROTOCOL_SOURCES "${PROTOCOL_SOURCES}" PARENT_SCOPE)
+  list(APPEND PROTOCOL_SOURCES "${CMAKE_SOURCE_DIR}/protocols/wayland.cpp")
+  set(PROTOCOL_SOURCES "${PROTOCOL_SOURCES}" PARENT_SCOPE)
 endfunction()
 
-target_link_libraries(Hyprland OpenGL::EGL OpenGL::GL Threads::Threads)
+target_link_libraries(hyprland_lib PUBLIC OpenGL::EGL OpenGL::GL Threads::Threads)
 
 pkg_check_modules(hyprland_protocols_dep hyprland-protocols>=0.6.4)
 if(hyprland_protocols_dep_FOUND)
@@ -349,7 +508,8 @@ protocolnew("protocols" "wayland-drm" true)
 protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-ctm-control-v1" true)
 protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-surface-v1" true)
 protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-lock-notify-v1" true)
-protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-toplevel-mapping-v1" true)
+protocolnew("${HYPRLAND_PROTOCOLS}/protocols" "hyprland-toplevel-mapping-v1"
+            true)
 
 protocolnew("staging/tearing-control" "tearing-control-v1" false)
 protocolnew("staging/fractional-scale" "fractional-scale-v1" false)
@@ -386,11 +546,17 @@ protocolnew("staging/content-type" "content-type-v1" false)
 protocolnew("staging/color-management" "color-management-v1" false)
 protocolnew("staging/xdg-toplevel-tag" "xdg-toplevel-tag-v1" false)
 protocolnew("staging/xdg-system-bell" "xdg-system-bell-v1" false)
+protocolnew("staging/ext-workspace" "ext-workspace-v1" false)
+protocolnew("staging/ext-data-control" "ext-data-control-v1" false)
+protocolnew("staging/pointer-warp" "pointer-warp-v1" false)
+protocolnew("staging/fifo" "fifo-v1" false)
+protocolnew("staging/commit-timing" "commit-timing-v1" false)
 
 protocolwayland()
 
 # tools
 add_subdirectory(hyprctl)
+add_subdirectory(start)
 
 if(NO_HYPRPM)
   message(STATUS "hyprpm is disabled")
@@ -417,7 +583,6 @@ add_compile_definitions(DATAROOTDIR="${CMAKE_INSTALL_FULL_DATAROOTDIR}")
 
 # installable assets
 file(GLOB_RECURSE INSTALLABLE_ASSETS "assets/install/*")
-list(FILTER INSTALLABLE_ASSETS EXCLUDE REGEX "meson.build")
 install(FILES ${INSTALLABLE_ASSETS}
         DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/hypr)
 
@@ -453,5 +618,49 @@ install(
   FILES_MATCHING
   PATTERN "*.h"
   PATTERN "*.hpp"
-  PATTERN "*.inc"
+  PATTERN "*.inc")
-  )
+
+if(BUILD_TESTING OR WITH_TESTS)
+  message(STATUS "Building tests")
+
+  # hyprtester
+  add_subdirectory(hyprtester)
+
+  # GTest
+  find_package(GTest CONFIG REQUIRED)
+  include(GoogleTest)
+  file(GLOB_RECURSE TESTFILES "tests/*.cpp")
+  add_executable(hyprland_gtests ${TESTFILES})
+  target_compile_options(hyprland_gtests PRIVATE --coverage)
+  target_link_options(hyprland_gtests PRIVATE --coverage)
+  target_include_directories(
+    hyprland_gtests
+    PUBLIC "./include"
+    PRIVATE "./src" "./src/include" "./protocols" "${CMAKE_BINARY_DIR}")
+
+  target_link_libraries(hyprland_gtests hyprland_lib GTest::gtest_main)
+
+  gtest_discover_tests(hyprland_gtests)
+
+  # Enable coverage in main hyprland lib
+  target_compile_options(hyprland_lib PRIVATE --coverage)
+  target_link_options(hyprland_lib PRIVATE --coverage)
+  target_link_libraries(hyprland_lib PUBLIC gcov)
+
+  # Enable coverage in hyprland exe
+  target_compile_options(Hyprland PRIVATE --coverage)
+  target_link_options(Hyprland PRIVATE --coverage)
+  target_link_libraries(Hyprland gcov)
+endif()
+
+if(BUILD_TESTING)
+  message(STATUS "Testing is enabled")
+
+  enable_testing()
+  add_custom_target(tests)
+
+  add_dependencies(tests hyprland_gtests)
+
+else()
+  message(STATUS "Testing is disabled")
+endif()

LICENSE

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

Makefile

@@ -3,20 +3,12 @@ PREFIX = /usr/local
 stub:
 	@echo "Do not run $(MAKE) directly without any arguments. Please refer to the wiki on how to compile Hyprland."
 
-legacyrenderer:
-	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:STRING=${PREFIX} -DLEGACY_RENDERER:BOOL=true -S . -B ./build
-	cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
-
-legacyrendererdebug:
-	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -DCMAKE_INSTALL_PREFIX:STRING=${PREFIX} -DLEGACY_RENDERER:BOOL=true -S . -B ./build
-	cmake --build ./build --config Debug --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
-
 release:
 	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:STRING=${PREFIX} -S . -B ./build
 	cmake --build ./build --config Release --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
 
 debug:
-	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -DCMAKE_INSTALL_PREFIX:STRING=${PREFIX} -S . -B ./build
+	cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Debug -DTESTS=true -DCMAKE_INSTALL_PREFIX:STRING=${PREFIX} -S . -B ./build
 	cmake --build ./build --config Debug --target all -j`nproc 2>/dev/null || getconf NPROCESSORS_CONF`
 
 nopch:
@@ -100,3 +92,7 @@ asan:
 	@echo "Hyprland done"
 
 	ASAN_OPTIONS="detect_odr_violation=0,log_path=asan.log" HYPRLAND_NO_CRASHREPORTER=1 ./build/Hyprland -c ~/.config/hypr/hyprland.conf
+
+test:
+	$(MAKE) debug
+	./build/hyprtester/hyprtester -c hyprtester/test.conf -b ./build/Hyprland -p hyprtester/plugin/hyprtestplugin.so

README.md

@@ -4,7 +4,7 @@
 
 <br>
 
-![Badge Workflow] 
+[![Badge Workflow]][Workflow]
 [![Badge License]][License] 
 ![Badge Language] 
 [![Badge Pull Requests]][Pull Requests] 
@@ -100,7 +100,7 @@ easy IPC, much more QoL stuff than other compositors and more...
 
 <!----------------------------------------------------------------------------->
 
-[Configure]: https://wiki.hyprland.org/Configuring/
+[Configure]: https://wiki.hypr.land/Configuring/
 [Stars]: https://starchart.cc/hyprwm/Hyprland
 [Hypr]: https://github.com/hyprwm/Hypr
 
@@ -108,9 +108,10 @@ easy IPC, much more QoL stuff than other compositors and more...
 [Issues]: https://github.com/hyprwm/Hyprland/issues
 [Todo]: https://github.com/hyprwm/Hyprland/projects?type=beta
 
-[Contribute]: https://wiki.hyprland.org/Contributing-and-Debugging/
+[Contribute]: https://wiki.hypr.land/Contributing-and-Debugging/
-[Install]: https://wiki.hyprland.org/Getting-Started/Installation/
+[Install]: https://wiki.hypr.land/Getting-Started/Installation/
-[Quick Start]: https://wiki.hyprland.org/Getting-Started/Master-Tutorial/
+[Quick Start]: https://wiki.hypr.land/Getting-Started/Master-Tutorial/
+[Workflow]: https://github.com/hyprwm/Hyprland/actions/workflows/ci.yaml
 [License]: LICENSE
 
 
@@ -125,9 +126,9 @@ easy IPC, much more QoL stuff than other compositors and more...
 
 <!----------------------------------{ Images }--------------------------------->
 
-[Preview A]: https://i.ibb.co/C1yTb0r/falf.png
+[Preview A]: https://i.ibb.co/XxFY75Mk/greerggergerhtrytghjnyhjn.png
-[Preview B]: https://linfindel.github.io/cdn/hyprland-preview-b.png
+[Preview B]: https://i.ibb.co/C1yTb0r/falf.png
-[Preview C]: https://i.ibb.co/B3GJg28/20221126-20h53m26s-grim.png
+[Preview C]: https://i.ibb.co/2Yc4q835/hyprland-preview-b.png
 
 
 <!----------------------------------{ Badges }--------------------------------->

VERSION

@@ -1 +1 @@
-0.49.0
+0.52.0

assets/install/meson.build

@@ -1,10 +0,0 @@
-globber = run_command('sh', '-c', 'find . -type f -not -name "*.build"', check: true)
-files = globber.stdout().strip().split('\n')
-
-foreach file : files
-  install_data(
-    file,
-    install_dir: join_paths(get_option('datadir'), 'hypr'),
-    install_tag: 'runtime',
-  )
-endforeach

assets/meson.build

@@ -1,7 +0,0 @@
-install_data(
-  'hyprland-portals.conf',
-  install_dir: join_paths(get_option('datadir'), 'xdg-desktop-portal'),
-  install_tag: 'runtime',
-)
-
-subdir('install')

docs/Hyprland.1

@@ -1,5 +1,19 @@
-.\" Automatically generated by Pandoc 2.9.2.1
+.\" Automatically generated by Pandoc 3.1.3
 .\"
+.\" Define V font for inline verbatim, using C font in formats
+.\" that render this, and otherwise B font.
+.ie "\f[CB]x\f[]"x" \{\
+. ftr V B
+. ftr VI BI
+. ftr VB B
+. ftr VBI BI
+.\}
+.el \{\
+. ftr V CR
+. ftr VI CI
+. ftr VB CB
+. ftr VBI CBI
+.\}
 .TH "Hyprland" "1" "" "" "Hyprland User Manual"
 .hy
 .SH NAME

docs/ISSUE_GUIDELINES.md

@@ -2,15 +2,15 @@
 
 First of all, please remember to:
 - Check that your issue is not a duplicate
-- Read the [FAQ](https://wiki.hyprland.org/FAQ/)
+- Read the [FAQ](https://wiki.hypr.land/FAQ/)
-- Read the [Configuring Page](https://wiki.hyprland.org/Configuring/)
+- Read the [Configuring Page](https://wiki.hypr.land/Configuring/)
 
 <br/>
 
 # Reporting suggestions
 Suggestions are welcome.
 
-Many features can be implemented using bash scripts and Hyprland sockets, read up on those [Here](https://wiki.hyprland.org/IPC). Please do not suggest features that can be implemented as such.
+Many features can be implemented using bash scripts and Hyprland sockets, read up on those [Here](https://wiki.hypr.land/IPC). Please do not suggest features that can be implemented as such.
 
 <br/>
 
@@ -70,7 +70,7 @@ A debug coredump provides more information for debugging and may speed up the pr
 
 Make sure you're on latest git. Run `git pull --recurse-submodules` to sync everything.
 
-1. [Compile Hyprland with debug mode](http://wiki.hyprland.org/Contributing-and-Debugging/#build-in-debug-mode)
+1. [Compile Hyprland with debug mode](http://wiki.hypr.land/Contributing-and-Debugging/#build-in-debug-mode)
 > Note: The config file used will be `hyprlandd.conf` instead of `hyprland.conf`
 
 2. `cd ~`

docs/hyprctl.1

@@ -1,5 +1,19 @@
-.\" Automatically generated by Pandoc 2.9.2.1
+.\" Automatically generated by Pandoc 3.1.3
 .\"
+.\" Define V font for inline verbatim, using C font in formats
+.\" that render this, and otherwise B font.
+.ie "\f[CB]x\f[]"x" \{\
+. ftr V B
+. ftr VI BI
+. ftr VB B
+. ftr VBI BI
+.\}
+.el \{\
+. ftr V CR
+. ftr VI CI
+. ftr VB CB
+. ftr VBI CBI
+.\}
 .TH "hyprctl" "1" "" "" "hyprctl User Manual"
 .hy
 .SH NAME

docs/meson.build

@@ -1,2 +0,0 @@
-install_man('Hyprland.1')
-install_man('hyprctl.1')

example/hyprland.conf

@@ -1,6 +1,6 @@
 # This is an example Hyprland config file.
 # Refer to the wiki for more information.
-# https://wiki.hyprland.org/Configuring/
+# https://wiki.hypr.land/Configuring/
 
 # Please note not all available settings / options are set here.
 # For a full list, see the wiki
@@ -14,7 +14,7 @@
 ### MONITORS ###
 ################
 
-# See https://wiki.hyprland.org/Configuring/Monitors/
+# See https://wiki.hypr.land/Configuring/Monitors/
 monitor=,preferred,auto,auto
 
 
@@ -22,12 +22,12 @@ monitor=,preferred,auto,auto
 ### MY PROGRAMS ###
 ###################
 
-# See https://wiki.hyprland.org/Configuring/Keywords/
+# See https://wiki.hypr.land/Configuring/Keywords/
 
 # Set programs that you use
 $terminal = kitty
 $fileManager = dolphin
-$menu = wofi --show drun
+$menu = hyprlauncher
 
 
 #################
@@ -46,7 +46,7 @@ $menu = wofi --show drun
 ### ENVIRONMENT VARIABLES ###
 #############################
 
-# See https://wiki.hyprland.org/Configuring/Environment-variables/
+# See https://wiki.hypr.land/Configuring/Environment-variables/
 
 env = XCURSOR_SIZE,24
 env = HYPRCURSOR_SIZE,24
@@ -56,7 +56,7 @@ env = HYPRCURSOR_SIZE,24
 ### PERMISSIONS ###
 ###################
 
-# See https://wiki.hyprland.org/Configuring/Permissions/
+# See https://wiki.hypr.land/Configuring/Permissions/
 # Please note permission changes here require a Hyprland restart and are not applied on-the-fly
 # for security reasons
 
@@ -73,29 +73,29 @@ env = HYPRCURSOR_SIZE,24
 ### LOOK AND FEEL ###
 #####################
 
-# Refer to https://wiki.hyprland.org/Configuring/Variables/
+# Refer to https://wiki.hypr.land/Configuring/Variables/
 
-# https://wiki.hyprland.org/Configuring/Variables/#general
+# https://wiki.hypr.land/Configuring/Variables/#general
 general {
     gaps_in = 5
     gaps_out = 20
 
     border_size = 2
 
-    # https://wiki.hyprland.org/Configuring/Variables/#variable-types for info about colors
+    # https://wiki.hypr.land/Configuring/Variables/#variable-types for info about colors
     col.active_border = rgba(33ccffee) rgba(00ff99ee) 45deg
     col.inactive_border = rgba(595959aa)
 
     # Set to true enable resizing windows by clicking and dragging on borders and gaps
     resize_on_border = false
 
-    # Please see https://wiki.hyprland.org/Configuring/Tearing/ before you turn this on
+    # Please see https://wiki.hypr.land/Configuring/Tearing/ before you turn this on
     allow_tearing = false
 
     layout = dwindle
 }
 
-# https://wiki.hyprland.org/Configuring/Variables/#decoration
+# https://wiki.hypr.land/Configuring/Variables/#decoration
 decoration {
     rounding = 10
     rounding_power = 2
@@ -111,7 +111,7 @@ decoration {
         color = rgba(1a1a1aee)
     }
 
-    # https://wiki.hyprland.org/Configuring/Variables/#blur
+    # https://wiki.hypr.land/Configuring/Variables/#blur
     blur {
         enabled = true
         size = 3
@@ -121,18 +121,20 @@ decoration {
     }
 }
 
-# https://wiki.hyprland.org/Configuring/Variables/#animations
+# https://wiki.hypr.land/Configuring/Variables/#animations
 animations {
     enabled = yes, please :)
 
-    # Default animations, see https://wiki.hyprland.org/Configuring/Animations/ for more
+    # Default curves, see https://wiki.hypr.land/Configuring/Animations/#curves
-
+    #        NAME,           X0,   Y0,   X1,   Y1
     bezier = easeOutQuint,   0.23, 1,    0.32, 1
     bezier = easeInOutCubic, 0.65, 0.05, 0.36, 1
     bezier = linear,         0,    0,    1,    1
-    bezier = almostLinear,0.5,0.5,0.75,1.0
+    bezier = almostLinear,   0.5,  0.5,  0.75, 1
     bezier = quick,          0.15, 0,    0.1,  1
 
+    # Default animations, see https://wiki.hypr.land/Configuring/Animations/
+    #           NAME,          ONOFF, SPEED, CURVE,        [STYLE]
     animation = global,        1,     10,    default
     animation = border,        1,     5.39,  easeOutQuint
     animation = windows,       1,     4.79,  easeOutQuint
@@ -149,30 +151,44 @@ animations {
     animation = workspaces,    1,     1.94,  almostLinear, fade
     animation = workspacesIn,  1,     1.21,  almostLinear, fade
     animation = workspacesOut, 1,     1.94,  almostLinear, fade
+    animation = zoomFactor,    1,     7,     quick
 }
 
-# Ref https://wiki.hyprland.org/Configuring/Workspace-Rules/
+# Ref https://wiki.hypr.land/Configuring/Workspace-Rules/
 # "Smart gaps" / "No gaps when only"
 # uncomment all if you wish to use that.
 # workspace = w[tv1], gapsout:0, gapsin:0
 # workspace = f[1], gapsout:0, gapsin:0
-# windowrule = bordersize 0, floating:0, onworkspace:w[tv1]
+# windowrule {
-# windowrule = rounding 0, floating:0, onworkspace:w[tv1]
+#     name = no-gaps-wtv1
-# windowrule = bordersize 0, floating:0, onworkspace:f[1]
+#     match:float = false
-# windowrule = rounding 0, floating:0, onworkspace:f[1]
+#     match:workspace = w[tv1]
+#
+#     border_size = 0
+#     rounding = 0
+# }
+#
+# windowrule {
+#     name = no-gaps-f1
+#     match:float = false
+#     match:workspace = f[1]
+#
+#     border_size = 0
+#     rounding = 0
+# }
 
-# See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
+# See https://wiki.hypr.land/Configuring/Dwindle-Layout/ for more
 dwindle {
     pseudotile = true # Master switch for pseudotiling. Enabling is bound to mainMod + P in the keybinds section below
     preserve_split = true # You probably want this
 }
 
-# See https://wiki.hyprland.org/Configuring/Master-Layout/ for more
+# See https://wiki.hypr.land/Configuring/Master-Layout/ for more
 master {
     new_status = master
 }
 
-# https://wiki.hyprland.org/Configuring/Variables/#misc
+# https://wiki.hypr.land/Configuring/Variables/#misc
 misc {
     force_default_wallpaper = -1 # Set to 0 or 1 to disable the anime mascot wallpapers
     disable_hyprland_logo = false # If true disables the random hyprland logo / anime girl background. :(
@@ -183,7 +199,7 @@ misc {
 ### INPUT ###
 #############
 
-# https://wiki.hyprland.org/Configuring/Variables/#input
+# https://wiki.hypr.land/Configuring/Variables/#input
 input {
     kb_layout = us
     kb_variant =
@@ -200,13 +216,11 @@ input {
     }
 }
 
-# https://wiki.hyprland.org/Configuring/Variables/#gestures
+# See https://wiki.hypr.land/Configuring/Gestures
-gestures {
+gesture = 3, horizontal, workspace
-    workspace_swipe = false
-}
 
 # Example per-device config
-# See https://wiki.hyprland.org/Configuring/Keywords/#per-device-input-configs for more
+# See https://wiki.hypr.land/Configuring/Keywords/#per-device-input-configs for more
 device {
     name = epic-mouse-v1
     sensitivity = -0.5
@@ -217,13 +231,13 @@ device {
 ### KEYBINDINGS ###
 ###################
 
-# See https://wiki.hyprland.org/Configuring/Keywords/
+# See https://wiki.hypr.land/Configuring/Keywords/
 $mainMod = SUPER # Sets "Windows" key as main modifier
 
-# Example binds, see https://wiki.hyprland.org/Configuring/Binds/ for more
+# Example binds, see https://wiki.hypr.land/Configuring/Binds/ for more
 bind = $mainMod, Q, exec, $terminal
 bind = $mainMod, C, killactive,
-bind = $mainMod, M, exit,
+bind = $mainMod, M, exec, command -v hyprshutdown >/dev/null 2>&1 && hyprshutdown || hyprctl dispatch exit
 bind = $mainMod, E, exec, $fileManager
 bind = $mainMod, V, togglefloating,
 bind = $mainMod, R, exec, $menu
@@ -290,14 +304,38 @@ bindl = , XF86AudioPrev, exec, playerctl previous
 ### WINDOWS AND WORKSPACES ###
 ##############################
 
-# See https://wiki.hyprland.org/Configuring/Window-Rules/ for more
+# See https://wiki.hypr.land/Configuring/Window-Rules/ for more
-# See https://wiki.hyprland.org/Configuring/Workspace-Rules/ for workspace rules
+# See https://wiki.hypr.land/Configuring/Workspace-Rules/ for workspace rules
 
-# Example windowrule
+# Example windowrules that are useful
-# windowrule = float,class:^(kitty)$,title:^(kitty)$
 
-# Ignore maximize requests from apps. You'll probably like this.
+windowrule {
-windowrule = suppressevent maximize, class:.*
+    # Ignore maximize requests from all apps. You'll probably like this.
+    name = suppress-maximize-events
+    match:class = .*
 
+    suppress_event = maximize
+}
+
+windowrule {
     # Fix some dragging issues with XWayland
-windowrule = nofocus,class:^$,title:^$,xwayland:1,floating:1,fullscreen:0,pinned:0
+    name = fix-xwayland-drags
+    match:class = ^$
+    match:title = ^$
+    match:xwayland = true
+    match:float = true
+    match:fullscreen = false
+    match:pin = false
+
+    no_focus = true
+}
+
+# Hyprland-run windowrule
+windowrule {
+    name = move-hyprland-run
+
+    match:class = hyprland-run
+
+    move = 20 monitor_h-120
+    float = yes
+}

example/hyprland.desktop

@@ -1,7 +1,7 @@
 [Desktop Entry]
 Name=Hyprland
 Comment=An intelligent dynamic tiling Wayland compositor
-Exec=Hyprland
+Exec=start-hyprland
 Type=Application
 DesktopNames=Hyprland
 Keywords=tiling;wayland;compositor;

example/meson.build

@@ -1,10 +0,0 @@
-install_data(
-  'hyprland.conf',
-  install_dir: join_paths(get_option('datadir'), 'hypr'),
-  install_tag: 'runtime',
-)
-install_data(
-  'hyprland.desktop',
-  install_dir: join_paths(get_option('datadir'), 'wayland-sessions'),
-  install_tag: 'runtime',
-)

example/screenShader.frag

@@ -2,15 +2,18 @@
 // Example blue light filter shader.
 //
 
+#version 300 es
+
 precision mediump float;
-varying vec2 v_texcoord;
+in vec2 v_texcoord;
+layout(location = 0) out vec4 fragColor;
 uniform sampler2D tex;
 
 void main() {
 
-    vec4 pixColor = texture2D(tex, v_texcoord);
+    vec4 pixColor = texture(tex, v_texcoord);
 
     pixColor[2] *= 0.8;
 
-    gl_FragColor = pixColor;
+    fragColor = pixColor;
 }

flake.lock

@@ -16,11 +16,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1745357003,
+        "lastModified": 1764714051,
-        "narHash": "sha256-jYwzQkv1r7HN/4qrAuKp+NR4YYNp2xDrOX5O9YVqkWo=",
+        "narHash": "sha256-AjcMlM3UoavFoLzr0YrcvsIxALShjyvwe+o7ikibpCM=",
         "owner": "hyprwm",
         "repo": "aquamarine",
-        "rev": "a19cf76ee1a15c1c12083fa372747ce46387289f",
+        "rev": "a43bedcceced5c21ad36578ed823e6099af78214",
         "type": "github"
       },
       "original": {
@@ -32,11 +32,11 @@
     "flake-compat": {
       "flake": false,
       "locked": {
-        "lastModified": 1696426674,
+        "lastModified": 1761588595,
-        "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=",
+        "narHash": "sha256-XKUZz9zewJNUj46b4AJdiRZJAvSZ0Dqj2BNfXvFlJC4=",
         "owner": "edolstra",
         "repo": "flake-compat",
-        "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
+        "rev": "f387cd2afec9419c8ee37694406ca490c3f34ee5",
         "type": "github"
       },
       "original": {
@@ -79,11 +79,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1745948457,
+        "lastModified": 1753964049,
-        "narHash": "sha256-lzTV10FJTCGNtMdgW5YAhCAqezeAzKOd/97HbQK8GTU=",
+        "narHash": "sha256-lIqabfBY7z/OANxHoPeIrDJrFyYy9jAM4GQLzZ2feCM=",
         "owner": "hyprwm",
         "repo": "hyprcursor",
-        "rev": "ac903e80b33ba6a88df83d02232483d99f327573",
+        "rev": "44e91d467bdad8dcf8bbd2ac7cf49972540980a5",
         "type": "github"
       },
       "original": {
@@ -105,11 +105,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1745015490,
+        "lastModified": 1763733840,
-        "narHash": "sha256-apEJ9zoSzmslhJ2vOKFcXTMZLUFYzh1ghfB6Rbw3Low=",
+        "narHash": "sha256-JnET78yl5RvpGuDQy3rCycOCkiKoLr5DN1fPhRNNMco=",
         "owner": "hyprwm",
         "repo": "hyprgraphics",
-        "rev": "60754910946b4e2dc1377b967b7156cb989c5873",
+        "rev": "8f1bec691b2d198c60cccabca7a94add2df4ed1a",
         "type": "github"
       },
       "original": {
@@ -118,6 +118,45 @@
         "type": "github"
       }
     },
+    "hyprland-guiutils": {
+      "inputs": {
+        "aquamarine": [
+          "aquamarine"
+        ],
+        "hyprgraphics": [
+          "hyprgraphics"
+        ],
+        "hyprlang": [
+          "hyprlang"
+        ],
+        "hyprtoolkit": "hyprtoolkit",
+        "hyprutils": [
+          "hyprutils"
+        ],
+        "hyprwayland-scanner": [
+          "hyprwayland-scanner"
+        ],
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "systems": [
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1764812575,
+        "narHash": "sha256-1bK1yGgaR82vajUrt6z+BSljQvFn91D74WJ/vJsydtE=",
+        "owner": "hyprwm",
+        "repo": "hyprland-guiutils",
+        "rev": "fd321368a40c782cfa299991e5584ca338e36ebe",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprland-guiutils",
+        "type": "github"
+      }
+    },
     "hyprland-protocols": {
       "inputs": {
         "nixpkgs": [
@@ -128,11 +167,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1743714874,
+        "lastModified": 1759610243,
-        "narHash": "sha256-yt8F7NhMFCFHUHy/lNjH/pjZyIDFNk52Q4tivQ31WFo=",
+        "narHash": "sha256-+KEVnKBe8wz+a6dTLq8YDcF3UrhQElwsYJaVaHXJtoI=",
         "owner": "hyprwm",
         "repo": "hyprland-protocols",
-        "rev": "3a5c2bda1c1a4e55cc1330c782547695a93f05b2",
+        "rev": "bd153e76f751f150a09328dbdeb5e4fab9d23622",
         "type": "github"
       },
       "original": {
@@ -141,67 +180,6 @@
         "type": "github"
       }
     },
-    "hyprland-qt-support": {
-      "inputs": {
-        "hyprlang": [
-          "hyprland-qtutils",
-          "hyprlang"
-        ],
-        "nixpkgs": [
-          "hyprland-qtutils",
-          "nixpkgs"
-        ],
-        "systems": [
-          "hyprland-qtutils",
-          "systems"
-        ]
-      },
-      "locked": {
-        "lastModified": 1737634706,
-        "narHash": "sha256-nGCibkfsXz7ARx5R+SnisRtMq21IQIhazp6viBU8I/A=",
-        "owner": "hyprwm",
-        "repo": "hyprland-qt-support",
-        "rev": "8810df502cdee755993cb803eba7b23f189db795",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hyprwm",
-        "repo": "hyprland-qt-support",
-        "type": "github"
-      }
-    },
-    "hyprland-qtutils": {
-      "inputs": {
-        "hyprland-qt-support": "hyprland-qt-support",
-        "hyprlang": [
-          "hyprlang"
-        ],
-        "hyprutils": [
-          "hyprland-qtutils",
-          "hyprlang",
-          "hyprutils"
-        ],
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "systems": [
-          "systems"
-        ]
-      },
-      "locked": {
-        "lastModified": 1745951494,
-        "narHash": "sha256-2dModE32doiyQMmd6EDAQeZnz+5LOs6KXyE0qX76WIg=",
-        "owner": "hyprwm",
-        "repo": "hyprland-qtutils",
-        "rev": "4be1d324faf8d6e82c2be9f8510d299984dfdd2e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hyprwm",
-        "repo": "hyprland-qtutils",
-        "type": "github"
-      }
-    },
     "hyprlang": {
       "inputs": {
         "hyprutils": [
@@ -215,11 +193,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1746655412,
+        "lastModified": 1764612430,
-        "narHash": "sha256-kVQ0bHVtX6baYxRWWIh4u3LNJZb9Zcm2xBeDPOGz5BY=",
+        "narHash": "sha256-54ltTSbI6W+qYGMchAgCR6QnC1kOdKXN6X6pJhOWxFg=",
         "owner": "hyprwm",
         "repo": "hyprlang",
-        "rev": "557241780c179cf7ef224df392f8e67dab6cef83",
+        "rev": "0d00dc118981531aa731150b6ea551ef037acddd",
         "type": "github"
       },
       "original": {
@@ -228,6 +206,51 @@
         "type": "github"
       }
     },
+    "hyprtoolkit": {
+      "inputs": {
+        "aquamarine": [
+          "hyprland-guiutils",
+          "aquamarine"
+        ],
+        "hyprgraphics": [
+          "hyprland-guiutils",
+          "hyprgraphics"
+        ],
+        "hyprlang": [
+          "hyprland-guiutils",
+          "hyprlang"
+        ],
+        "hyprutils": [
+          "hyprland-guiutils",
+          "hyprutils"
+        ],
+        "hyprwayland-scanner": [
+          "hyprland-guiutils",
+          "hyprwayland-scanner"
+        ],
+        "nixpkgs": [
+          "hyprland-guiutils",
+          "nixpkgs"
+        ],
+        "systems": [
+          "hyprland-guiutils",
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1764592794,
+        "narHash": "sha256-7CcO+wbTJ1L1NBQHierHzheQGPWwkIQug/w+fhTAVuU=",
+        "owner": "hyprwm",
+        "repo": "hyprtoolkit",
+        "rev": "5cfe0743f0e608e1462972303778d8a0859ee63e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprtoolkit",
+        "type": "github"
+      }
+    },
     "hyprutils": {
       "inputs": {
         "nixpkgs": [
@@ -238,11 +261,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1746635225,
+        "lastModified": 1764962281,
-        "narHash": "sha256-W9G9bb0zRYDBRseHbVez0J8qVpD5QbizX67H/vsudhM=",
+        "narHash": "sha256-rGbEMhTTyTzw4iyz45lch5kXseqnqcEpmrHdy+zHsfo=",
         "owner": "hyprwm",
         "repo": "hyprutils",
-        "rev": "674ea57373f08b7609ce93baff131117a0dfe70d",
+        "rev": "fe686486ac867a1a24f99c753bb40ffed338e4b0",
         "type": "github"
       },
       "original": {
@@ -261,11 +284,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1739870480,
+        "lastModified": 1763640274,
-        "narHash": "sha256-SiDN5BGxa/1hAsqhgJsS03C3t2QrLgBT8u+ENJ0Qzwc=",
+        "narHash": "sha256-Uan1Nl9i4TF/kyFoHnTq1bd/rsWh4GAK/9/jDqLbY5A=",
         "owner": "hyprwm",
         "repo": "hyprwayland-scanner",
-        "rev": "206367a08dc5ac4ba7ad31bdca391d098082e64b",
+        "rev": "f6cf414ca0e16a4d30198fd670ec86df3c89f671",
         "type": "github"
       },
       "original": {
@@ -274,13 +297,39 @@
         "type": "github"
       }
     },
+    "hyprwire": {
+      "inputs": {
+        "hyprutils": [
+          "hyprutils"
+        ],
+        "nixpkgs": [
+          "nixpkgs"
+        ],
+        "systems": [
+          "systems"
+        ]
+      },
+      "locked": {
+        "lastModified": 1764872015,
+        "narHash": "sha256-INI9AVrQG5nJZFvGPSiUZ9FEUZJLfGdsqjF1QSak7Gc=",
+        "owner": "hyprwm",
+        "repo": "hyprwire",
+        "rev": "7997451dcaab7b9d9d442f18985d514ec5891608",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hyprwm",
+        "repo": "hyprwire",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1746461020,
+        "lastModified": 1764950072,
-        "narHash": "sha256-7+pG1I9jvxNlmln4YgnlW4o+w0TZX24k688mibiFDUE=",
+        "narHash": "sha256-BmPWzogsG2GsXZtlT+MTcAWeDK5hkbGRZTeZNW42fwA=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "3730d8a308f94996a9ba7c7138ede69c1b9ac4ae",
+        "rev": "f61125a668a320878494449750330ca58b78c557",
         "type": "github"
       },
       "original": {
@@ -299,11 +348,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1746537231,
+        "lastModified": 1765016596,
-        "narHash": "sha256-Wb2xeSyOsCoTCTj7LOoD6cdKLEROyFAArnYoS+noCWo=",
+        "narHash": "sha256-rhSqPNxDVow7OQKi4qS5H8Au0P4S3AYbawBSmJNUtBQ=",
         "owner": "cachix",
         "repo": "git-hooks.nix",
-        "rev": "fa466640195d38ec97cf0493d6d6882bc4d14969",
+        "rev": "548fc44fca28a5e81c5d6b846e555e6b9c2a5a3c",
         "type": "github"
       },
       "original": {
@@ -317,11 +366,12 @@
         "aquamarine": "aquamarine",
         "hyprcursor": "hyprcursor",
         "hyprgraphics": "hyprgraphics",
+        "hyprland-guiutils": "hyprland-guiutils",
         "hyprland-protocols": "hyprland-protocols",
-        "hyprland-qtutils": "hyprland-qtutils",
         "hyprlang": "hyprlang",
         "hyprutils": "hyprutils",
         "hyprwayland-scanner": "hyprwayland-scanner",
+        "hyprwire": "hyprwire",
         "nixpkgs": "nixpkgs",
         "pre-commit-hooks": "pre-commit-hooks",
         "systems": "systems",
@@ -365,11 +415,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1745871725,
+        "lastModified": 1761431178,
-        "narHash": "sha256-M24SNc2flblWGXFkGQfqSlEOzAGZnMc9QG3GH4K/KbE=",
+        "narHash": "sha256-xzjC1CV3+wpUQKNF+GnadnkeGUCJX+vgaWIZsnz9tzI=",
         "owner": "hyprwm",
         "repo": "xdg-desktop-portal-hyprland",
-        "rev": "76bbf1a6b1378e4ab5230bad00ad04bc287c969e",
+        "rev": "4b8801228ff958d028f588f0c2b911dbf32297f9",
         "type": "github"
       },
       "original": {

flake.nix

@@ -35,11 +35,15 @@
       inputs.systems.follows = "systems";
     };
 
-    hyprland-qtutils = {
+    hyprland-guiutils = {
-      url = "github:hyprwm/hyprland-qtutils";
+      url = "github:hyprwm/hyprland-guiutils";
       inputs.nixpkgs.follows = "nixpkgs";
       inputs.systems.follows = "systems";
+      inputs.aquamarine.follows = "aquamarine";
+      inputs.hyprgraphics.follows = "hyprgraphics";
+      inputs.hyprutils.follows = "hyprutils";
       inputs.hyprlang.follows = "hyprlang";
+      inputs.hyprwayland-scanner.follows = "hyprwayland-scanner";
     };
 
     hyprlang = {
@@ -61,6 +65,13 @@
       inputs.systems.follows = "systems";
     };
 
+    hyprwire = {
+      url = "github:hyprwm/hyprwire";
+      inputs.nixpkgs.follows = "nixpkgs";
+      inputs.systems.follows = "systems";
+      inputs.hyprutils.follows = "hyprutils";
+    };
+
     xdph = {
       url = "github:hyprwm/xdg-desktop-portal-hyprland";
       inputs.nixpkgs.follows = "nixpkgs";
@@ -102,6 +113,21 @@
           hyprland-extras
         ];
       });
+    pkgsDebugFor = eachSystem (system:
+      import nixpkgs {
+        localSystem = system;
+        overlays = with self.overlays; [
+          hyprland-debug
+        ];
+      });
+    pkgsDebugCrossFor = eachSystem (system: crossSystem:
+      import nixpkgs {
+        localSystem = system;
+        inherit crossSystem;
+        overlays = with self.overlays; [
+          hyprland-debug
+        ];
+      });
   in {
     overlays = import ./nix/overlays.nix {inherit self lib inputs;};
 
@@ -123,7 +149,8 @@
             };
           };
         };
-      });
+      }
+      // (import ./nix/tests inputs pkgsFor.${system}));
 
     packages = eachSystem (system: {
       default = self.packages.${system}.hyprland;
@@ -131,13 +158,14 @@
         (pkgsFor.${system})
         # hyprland-packages
         hyprland
-        hyprland-debug
-        hyprland-legacy-renderer
         hyprland-unwrapped
+        hyprland-with-tests
         # hyprland-extras
         xdg-desktop-portal-hyprland
         ;
+      inherit (pkgsDebugFor.${system}) hyprland-debug;
       hyprland-cross = (pkgsCrossFor.${system} "aarch64-linux").hyprland;
+      hyprland-debug-cross = (pkgsDebugCrossFor.${system} "aarch64-linux").hyprland-debug;
     });
 
     devShells = eachSystem (system: {
@@ -159,7 +187,7 @@
     homeManagerModules.default = import ./nix/hm-module.nix self;
 
     # Hydra build jobs
-    # Recent versions of Hydra can aggregate jobsets from 'hydraJobs' intead of a release.nix
+    # Recent versions of Hydra can aggregate jobsets from 'hydraJobs' instead of a release.nix
     # or similar. Remember to filter large or incompatible attributes here. More eval jobs can
     # be added by merging, e.g., self.packages // self.devShells.
     hydraJobs = self.packages;

hyprctl/CMakeLists.txt

@@ -5,11 +5,32 @@ project(
     DESCRIPTION "Control utility for Hyprland"
 )
 
-pkg_check_modules(hyprctl_deps REQUIRED IMPORTED_TARGET hyprutils>=0.2.4 re2)
+pkg_check_modules(hyprctl_deps REQUIRED IMPORTED_TARGET hyprutils>=0.2.4 hyprwire re2)
 
-add_executable(hyprctl "main.cpp")
+file(GLOB_RECURSE HYPRCTL_SRCFILES CONFIGURE_DEPENDS "src/*.cpp" "hw-protocols/*.cpp" "include/*.hpp")
+
+add_executable(hyprctl ${HYPRCTL_SRCFILES})
 
 target_link_libraries(hyprctl PUBLIC PkgConfig::hyprctl_deps)
+target_include_directories(hyprctl PRIVATE "hw-protocols")
+
+# Hyprwire
+
+function(hyprprotocol protoPath protoName)
+  set(path ${CMAKE_CURRENT_SOURCE_DIR}/${protoPath})
+  add_custom_command(
+    OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/hw-protocols/${protoName}-client.cpp
+           ${CMAKE_CURRENT_SOURCE_DIR}/hw-protocols/${protoName}-client.hpp
+           ${CMAKE_CURRENT_SOURCE_DIR}/hw-protocols/${protoName}-spec.hpp
+    COMMAND hyprwire-scanner --client ${path}/${protoName}.xml
+            ${CMAKE_CURRENT_SOURCE_DIR}/hw-protocols/
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+  target_sources(hyprctl PRIVATE hw-protocols/${protoName}-client.cpp
+                                   hw-protocols/${protoName}-client.hpp
+                                   hw-protocols/${protoName}-spec.hpp)
+endfunction()
+
+hyprprotocol(hw-protocols hyprpaper_core)
 
 # binary
 install(TARGETS hyprctl)

hyprctl/hw-protocols/hyprpaper_core.xml

@@ -0,0 +1,144 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="hyprpaper_core" version="1">
+  <copyright>
+    BSD 3-Clause License
+
+    Copyright (c) 2025, Hypr Development
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this
+        list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice,
+        this list of conditions and the following disclaimer in the documentation
+        and/or other materials provided with the distribution.
+
+    3. Neither the name of the copyright holder nor the names of its
+        contributors may be used to endorse or promote products derived from
+        this software without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+    FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+    OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  </copyright>
+
+  <object name="hyprpaper_core_manager" version="1">
+    <description summary="manager object">
+      This is the core manager object for hyprpaper operations
+    </description>
+
+    <c2s name="get_wallpaper_object">
+      <description summary="Get a wallpaper object">
+        Creates a wallpaper object
+      </description>
+      <returns iface="hyprpaper_wallpaper"/>
+    </c2s>
+
+    <s2c name="add_monitor">
+      <description summary="New monitor added">
+        Emitted when a new monitor is added.
+      </description>
+      <arg name="monitor_name" type="varchar" summary="the monitor's name"/>
+    </s2c>
+
+    <s2c name="remove_monitor">
+      <description summary="A monitor was removed">
+        Emitted when a monitor is removed.
+      </description>
+      <arg name="monitor_name" type="varchar" summary="the monitor's name"/>
+    </s2c>
+
+    <c2s name="destroy" destructor="true">
+      <description summary="Destroy this object">
+        Destroys this object. Children remain alive until destroyed.
+      </description>
+    </c2s>
+  </object>
+
+  <enum name="wallpaper_fit_mode">
+    <value idx="0" name="stretch"/>
+    <value idx="1" name="cover"/>
+    <value idx="2" name="contain"/>
+    <value idx="3" name="tile"/>
+  </enum>
+
+  <enum name="wallpaper_errors">
+    <value idx="0" name="inert_wallpaper_object" description="attempted to use an inert wallpaper object"/>
+  </enum>
+
+  <enum name="applying_error">
+    <value idx="0" name="invalid_path" description="path provided was invalid"/>
+    <value idx="1" name="invalid_monitor" description="monitor provided was invalid"/>
+    <value idx="2" name="unknown_error" description="unknown error"/>
+  </enum>
+
+  <object name="hyprpaper_wallpaper" version="1">
+    <description summary="wallpaper object">
+      This is an object describing a wallpaper
+    </description>
+
+    <c2s name="path">
+      <description summary="Set a path">
+        Set a file path for the wallpaper. This has to be an absolute path from the fs root.
+        This is required.
+      </description>
+      <arg name="wallpaper" type="varchar" summary="path"/>
+    </c2s>
+
+    <c2s name="fit_mode">
+      <description summary="Set a fit mode">
+        Set a fit mode for the wallpaper. This is set to cover by default.
+      </description>
+      <arg name="fit_mode" type="enum" interface="wallpaper_fit_mode" summary="path"/>
+    </c2s>
+
+    <c2s name="monitor_name">
+      <description summary="Set the monitor name">
+        Set a monitor for the wallpaper. Setting this to empty (or not setting at all) will
+        treat this as a wildcard fallback.
+
+        See hyprpaper_core_manager.add_monitor and hyprpaper_core_manager.remove_monitor
+        for tracking monitor names.
+      </description>
+      <arg name="monitor_name" type="varchar" summary="monitor name"/>
+    </c2s>
+
+    <c2s name="apply">
+      <description summary="Apply this wallpaper">
+        Applies this object's state to the wallpaper state. Will emit .success on success,
+        and .failed on failure.
+
+        This object becomes inert after .succeess or .failed, the only valid operation
+        is to destroy it afterwards.
+      </description>
+    </c2s>
+
+    <s2c name="success">
+      <description summary="Operation succeeded">
+        Wallpaper was applied successfully.
+      </description>
+    </s2c>
+
+    <s2c name="failed">
+      <description summary="Operation failed">
+        Wallpaper was not applied. See the error field for more information.
+      </description>
+      <arg name="error" type="enum" interface="hyprpaper_wallpaper_application_error" summary="path"/>
+    </s2c>
+
+    <c2s name="destroy" destructor="true">
+      <description summary="Destroy this object">
+        Destroys this object.
+      </description>
+    </c2s>
+  </object>
+</protocol>

hyprctl/hyprctl.fish

@@ -48,7 +48,7 @@ function _hyprctl
     set descriptions[22] "Focus the urgent window or the last window"
     set descriptions[23] "Get the list of defined workspace rules"
     set descriptions[24] "Move the active workspace to a monitor"
-    set descriptions[25] "Move window doesnt switch to the workspace"
+    set descriptions[25] "Move window doesn't switch to the workspace"
     set descriptions[26] "Interact with hyprpaper if present"
     set descriptions[29] "Swap the active window with the next or previous in a group"
     set descriptions[30] "Move the cursor to the corner of the active window"

hyprctl/hyprctl.usage

@@ -1,4 +1,4 @@
-# This is a file feeded to complgen to generate bash/fish/zsh completions
+# This is a file fed to complgen to generate bash/fish/zsh completions
 # Repo: https://github.com/adaszko/complgen
 # Generate completion scripts: "complgen aot --bash-script hyprctl.bash --fish-script hyprctl.fish --zsh-script hyprctl.zsh ./hyprctl.usage"
 
@@ -111,7 +111,7 @@ hyprctl [<OPTIONS>]... <ARGUMENTS>
                 |  (closewindow)         	                          "Close a specified window"
                 |  (workspace)           	                          "Change the workspace"
                 |  (movetoworkspace)         	                      "Move the focused window to a workspace"
-                |  (movetoworkspacesilent)           	              "Move window doesnt switch to the workspace"
+                |  (movetoworkspacesilent)           	              "Move window doesn't switch to the workspace"
                 |  (togglefloating)          	                      "Toggle the current window's floating state"
                 |  (setfloating)         	                          "Set the current window's floating state to true"
                 |  (settiled)            	                          "Set the current window's floating state to false"

hyprctl/hyprctl.zsh

@@ -36,7 +36,7 @@ _hyprctl () {
     descriptions[22]="Focus the urgent window or the last window"
     descriptions[23]="Get the list of defined workspace rules"
     descriptions[24]="Move the active workspace to a monitor"
-    descriptions[25]="Move window doesnt switch to the workspace"
+    descriptions[25]="Move window doesn't switch to the workspace"
     descriptions[26]="Interact with hyprpaper if present"
     descriptions[29]="Swap the active window with the next or previous in a group"
     descriptions[30]="Move the cursor to the corner of the active window"

hyprctl/meson.build

@@ -1,27 +0,0 @@
-executable(
-  'hyprctl',
-  'main.cpp',
-  dependencies: [
-    dependency('hyprutils', version: '>= 0.1.1'),
-    dependency('re2', required: true)
-  ],
-  install: true,
-)
-
-install_data(
-  'hyprctl.bash',
-  install_dir: join_paths(get_option('datadir'), 'bash-completion/completions'),
-  install_tag: 'runtime',
-  rename: 'hyprctl',
-)
-install_data(
-  'hyprctl.fish',
-  install_dir: join_paths(get_option('datadir'), 'fish/vendor_completions.d'),
-  install_tag: 'runtime',
-)
-install_data(
-  'hyprctl.zsh',
-  install_dir: join_paths(get_option('datadir'), 'zsh/site-functions'),
-  install_tag: 'runtime',
-  rename: '_hyprctl',
-)

hyprctl/src/Strings.hpp

@@ -49,6 +49,7 @@ commands:
                           the same format as in colors in config. Will reset
                           when Hyprland's config is reloaded
     setprop ...         → Sets a window property
+    getprop ...         → Gets a window property
     splash              → Get the current splash
     switchxkblayout ... → Sets the xkb layout index for a keyboard
     systeminfo          → Get system info
@@ -73,11 +74,8 @@ flags:
 const std::string_view HYPRPAPER_HELP = R"#(usage: hyprctl [flags] hyprpaper <request>
 
 requests:
-    listactive      → Lists all active images
+    wallpaper       → Issue a wallpaper to call a config wallpaper dynamically.
-    listloaded      → Lists all loaded images
+                      Arguments are [mon],[path],[fit_mode]. Fit mode is optional.
-    preload <path>  → Preloads image
-    unload <path>   → Unloads image. Pass 'all' as path to unload all images
-    wallpaper       → Issue a wallpaper to call a config wallpaper dynamically
 
 flags:
     See 'hyprctl --help')#";
@@ -146,7 +144,7 @@ regex:
     Regular expression by which a window will be searched
 
 property:
-    See https://wiki.hyprland.org/Configuring/Using-hyprctl/#setprop for list
+    See https://wiki.hypr.land/Configuring/Using-hyprctl/#setprop for list
     of properties
 
 value:
@@ -159,6 +157,18 @@ lock:
 flags:
     See 'hyprctl --help')#";
 
+const std::string_view GETPROP_HELP = R"#(usage: hyprctl [flags] getprop <regex> <property>
+
+regex:
+    Regular expression by which a window will be searched
+
+property:
+    See https://wiki.hypr.land/Configuring/Using-hyprctl/#setprop for list
+    of properties
+
+flags:
+    See 'hyprctl --help')#";
+
 const std::string_view SWITCHXKBLAYOUT_HELP = R"#(usage: [flags] switchxkblayout <device> <cmd>
 
 device:

hyprctl/src/helpers/Memory.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <hyprutils/memory/SharedPtr.hpp>
+#include <hyprutils/memory/UniquePtr.hpp>
+#include <hyprutils/memory/Atomic.hpp>
+
+using namespace Hyprutils::Memory;
+
+#define SP CSharedPointer
+#define WP CWeakPointer
+#define UP CUniquePointer

hyprctl/src/hyprpaper/Hyprpaper.cpp

@@ -0,0 +1,148 @@
+#include "Hyprpaper.hpp"
+#include "../helpers/Memory.hpp"
+
+#include <optional>
+#include <format>
+#include <filesystem>
+
+#include <hyprpaper_core-client.hpp>
+
+#include <hyprutils/string/VarList2.hpp>
+using namespace Hyprutils::String;
+
+using namespace std::string_literals;
+
+constexpr const char*          SOCKET_NAME = ".hyprpaper.sock";
+static SP<CCHyprpaperCoreImpl> g_coreImpl;
+
+constexpr const uint32_t       PROTOCOL_VERSION_SUPPORTED = 1;
+
+//
+static hyprpaperCoreWallpaperFitMode fitFromString(const std::string_view& sv) {
+    if (sv == "contain")
+        return HYPRPAPER_CORE_WALLPAPER_FIT_MODE_CONTAIN;
+    if (sv == "fit" || sv == "stretch")
+        return HYPRPAPER_CORE_WALLPAPER_FIT_MODE_STRETCH;
+    if (sv == "tile")
+        return HYPRPAPER_CORE_WALLPAPER_FIT_MODE_TILE;
+    return HYPRPAPER_CORE_WALLPAPER_FIT_MODE_COVER;
+}
+
+static std::expected<std::string, std::string> resolvePath(const std::string_view& sv) {
+    std::error_code ec;
+    auto            can = std::filesystem::canonical(sv, ec);
+
+    if (ec)
+        return std::unexpected(std::format("invalid path: {}", ec.message()));
+
+    return can;
+}
+
+static std::expected<std::string, std::string> getFullPath(const std::string_view& sv) {
+    if (sv.empty())
+        return std::unexpected("empty path");
+
+    if (sv[0] == '~') {
+        static auto HOME = getenv("HOME");
+        if (!HOME || HOME[0] == '\0')
+            return std::unexpected("home path but no $HOME");
+
+        return resolvePath(std::string{HOME} + "/"s + std::string{sv.substr(1)});
+    }
+
+    return resolvePath(sv);
+}
+
+std::expected<void, std::string> Hyprpaper::makeHyprpaperRequest(const std::string_view& rq) {
+    if (!rq.contains(' '))
+        return std::unexpected("Invalid request");
+
+    if (!rq.starts_with("/hyprpaper "))
+        return std::unexpected("Invalid request");
+
+    std::string_view LHS, RHS;
+    auto             spacePos = rq.find(' ', 12);
+    LHS                       = rq.substr(11, spacePos - 11);
+    RHS                       = rq.substr(spacePos + 1);
+
+    if (LHS != "wallpaper")
+        return std::unexpected("Unknown hyprpaper request");
+
+    CVarList2         args(std::string{RHS}, 0, ',');
+
+    const std::string MONITOR  = std::string{args[0]};
+    const auto&       PATH_RAW = args[1];
+    const auto&       FIT      = args[2];
+
+    if (PATH_RAW.empty())
+        return std::unexpected("not enough args");
+
+    const auto RTDIR = getenv("XDG_RUNTIME_DIR");
+
+    if (!RTDIR || RTDIR[0] == '\0')
+        return std::unexpected("can't send: no XDG_RUNTIME_DIR");
+
+    const auto HIS = getenv("HYPRLAND_INSTANCE_SIGNATURE");
+
+    if (!HIS || HIS[0] == '\0')
+        return std::unexpected("can't send: no HYPRLAND_INSTANCE_SIGNATURE (not running under hyprland)");
+
+    const auto PATH = getFullPath(PATH_RAW);
+
+    if (!PATH)
+        return std::unexpected(std::format("bad path: {}", PATH_RAW));
+
+    auto socketPath = RTDIR + "/hypr/"s + HIS + "/"s + SOCKET_NAME;
+
+    auto socket = Hyprwire::IClientSocket::open(socketPath);
+
+    if (!socket)
+        return std::unexpected("can't send: failed to connect to hyprpaper (is it running?)");
+
+    g_coreImpl = makeShared<CCHyprpaperCoreImpl>(1);
+
+    socket->addImplementation(g_coreImpl);
+
+    if (!socket->waitForHandshake())
+        return std::unexpected("can't send: wire handshake failed");
+
+    auto spec = socket->getSpec(g_coreImpl->protocol()->specName());
+
+    if (!spec)
+        return std::unexpected("can't send: hyprpaper doesn't have the spec?!");
+
+    auto manager = makeShared<CCHyprpaperCoreManagerObject>(socket->bindProtocol(g_coreImpl->protocol(), PROTOCOL_VERSION_SUPPORTED));
+
+    if (!manager)
+        return std::unexpected("wire error: couldn't create manager");
+
+    auto wallpaper = makeShared<CCHyprpaperWallpaperObject>(manager->sendGetWallpaperObject());
+
+    if (!wallpaper)
+        return std::unexpected("wire error: couldn't create wallpaper object");
+
+    bool                       canExit = false;
+    std::optional<std::string> err;
+
+    wallpaper->setFailed([&canExit, &err](uint32_t code) {
+        canExit = true;
+        err     = std::format("failed to set wallpaper, code {}", code);
+    });
+    wallpaper->setSuccess([&canExit]() { canExit = true; });
+
+    wallpaper->sendPath(PATH->c_str());
+    wallpaper->sendMonitorName(MONITOR.c_str());
+    if (!FIT.empty())
+        wallpaper->sendFitMode(fitFromString(FIT));
+
+    wallpaper->sendApply();
+
+    while (!canExit) {
+        socket->dispatchEvents(true);
+    }
+
+    if (err)
+        return std::unexpected(*err);
+
+    return {};
+}

hyprctl/src/hyprpaper/Hyprpaper.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <expected>
+#include <string>
+
+namespace Hyprpaper {
+    std::expected<void, std::string> makeHyprpaperRequest(const std::string_view& rq);
+};

hyprctl/src/main.cpp

@@ -14,6 +14,9 @@
 #include <unistd.h>
 #include <algorithm>
 #include <csignal>
+#include <ranges>
+#include <optional>
+#include <charconv>
 
 #include <iostream>
 #include <string>
@@ -23,11 +26,12 @@
 #include <filesystem>
 #include <cstdarg>
 #include <hyprutils/string/String.hpp>
+#include <hyprutils/memory/Casts.hpp>
 using namespace Hyprutils::String;
+using namespace Hyprutils::Memory;
 
 #include "Strings.hpp"
-
+#include "hyprpaper/Hyprpaper.hpp"
-#define PAD
 
 std::string instanceSignature;
 bool        quiet = false;
@@ -37,10 +41,9 @@ struct SInstanceData {
     uint64_t    time;
     uint64_t    pid;
     std::string wlSocket;
-    bool        valid = true;
 };
 
-void log(const std::string& str) {
+void log(const std::string_view str) {
     if (quiet)
         return;
 
@@ -64,47 +67,74 @@ std::string getRuntimeDir() {
     return std::string{XDG} + "/hypr";
 }
 
+static std::optional<uint64_t> toUInt64(const std::string_view str) {
+    uint64_t value       = 0;
+    const auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), value);
+    if (ec != std::errc() || ptr != str.data() + str.size())
+        return std::nullopt;
+    return value;
+}
+
+static std::optional<SInstanceData> parseInstance(const std::filesystem::directory_entry& entry) {
+    if (!entry.is_directory())
+        return std::nullopt;
+
+    const auto    lockPath = entry.path() / "hyprland.lock";
+    std::ifstream ifs(lockPath);
+    if (!ifs.is_open())
+        return std::nullopt;
+
+    SInstanceData data;
+    data.id = entry.path().filename().string();
+
+    const auto first = std::string_view{data.id}.find_first_of('_');
+    const auto last  = std::string_view{data.id}.find_last_of('_');
+    if (first == std::string_view::npos || last == std::string_view::npos || last <= first)
+        return std::nullopt;
+
+    auto time = toUInt64(std::string_view{data.id}.substr(first + 1, last - first - 1));
+    if (!time)
+        return std::nullopt;
+    data.time = *time;
+
+    std::string line;
+    if (!std::getline(ifs, line))
+        return std::nullopt;
+
+    auto pid = toUInt64(std::string_view{line});
+    if (!pid)
+        return std::nullopt;
+    data.pid = *pid;
+
+    if (!std::getline(ifs, data.wlSocket))
+        return std::nullopt;
+
+    if (std::getline(ifs, line) && !line.empty())
+        return std::nullopt; // more lines than expected
+
+    return data;
+}
+
 std::vector<SInstanceData> instances() {
     std::vector<SInstanceData> result;
 
-    try {
+    std::error_code            ec;
-        if (!std::filesystem::exists(getRuntimeDir()))
+    const auto                 runtimeDir = getRuntimeDir();
-            return {};
+    if (!std::filesystem::exists(runtimeDir, ec) || ec)
-    } catch (std::exception& e) { return {}; }
+        return result;
 
-    for (const auto& el : std::filesystem::directory_iterator(getRuntimeDir())) {
+    std::filesystem::directory_iterator it(runtimeDir, std::filesystem::directory_options::skip_permission_denied, ec);
-        if (!el.is_directory() || !std::filesystem::exists(el.path().string() + "/hyprland.lock"))
+    if (ec)
-            continue;
+        return result;
 
-        // read lock
+    for (const auto& el : it) {
-        SInstanceData* data = &result.emplace_back();
+        if (auto instance = parseInstance(el))
-        data->id            = el.path().filename().string();
+            result.emplace_back(std::move(*instance));
-
-        try {
-            data->time = std::stoull(data->id.substr(data->id.find_first_of('_') + 1, data->id.find_last_of('_') - (data->id.find_first_of('_') + 1)));
-        } catch (std::exception& e) { continue; }
-
-        // read file
-        std::ifstream ifs(el.path().string() + "/hyprland.lock");
-
-        int           i = 0;
-        for (std::string line; std::getline(ifs, line); ++i) {
-            if (i == 0) {
-                try {
-                    data->pid = std::stoull(line);
-                } catch (std::exception& e) { continue; }
-            } else if (i == 1) {
-                data->wlSocket = line;
-            } else
-                break;
     }
 
-        ifs.close();
+    std::erase_if(result, [](const auto& el) { return kill(el.pid, 0) != 0 && errno == ESRCH; });
-    }
 
-    std::erase_if(result, [&](const auto& el) { return kill(el.pid, 0) != 0 && errno == ESRCH; });
+    std::ranges::sort(result, {}, &SInstanceData::time);
-
-    std::sort(result.begin(), result.end(), [&](const auto& a, const auto& b) { return a.time < b.time; });
 
     return result;
 }
@@ -146,7 +176,7 @@ int rollingRead(const int socket) {
     return 0;
 }
 
-int request(std::string arg, int minArgs = 0, bool needRoll = false) {
+int request(std::string_view arg, int minArgs = 0, bool needRoll = false) {
     const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
 
     if (SERVERSOCKET < 0) {
@@ -172,8 +202,6 @@ int request(std::string arg, int minArgs = 0, bool needRoll = false) {
         return 3;
     }
 
-    const std::string USERID = std::to_string(getUID());
-
     sockaddr_un serverAddress = {0};
     serverAddress.sun_family  = AF_UNIX;
 
@@ -181,12 +209,12 @@ int request(std::string arg, int minArgs = 0, bool needRoll = false) {
 
     strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
 
-    if (connect(SERVERSOCKET, (sockaddr*)&serverAddress, SUN_LEN(&serverAddress)) < 0) {
+    if (connect(SERVERSOCKET, rc<sockaddr*>(&serverAddress), SUN_LEN(&serverAddress)) < 0) {
         log("Couldn't connect to " + socketPath + ". (4)");
         return 4;
     }
 
-    auto sizeWritten = write(SERVERSOCKET, arg.c_str(), arg.length());
+    auto sizeWritten = write(SERVERSOCKET, arg.data(), arg.size());
 
     if (sizeWritten < 0) {
         log("Couldn't write (5)");
@@ -227,7 +255,7 @@ int request(std::string arg, int minArgs = 0, bool needRoll = false) {
     return 0;
 }
 
-int requestIPC(std::string filename, std::string arg) {
+int requestIPC(std::string_view filename, std::string_view arg) {
     const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
 
     if (SERVERSOCKET < 0) {
@@ -243,13 +271,11 @@ int requestIPC(std::string filename, std::string arg) {
     sockaddr_un serverAddress = {0};
     serverAddress.sun_family  = AF_UNIX;
 
-    const std::string USERID = std::to_string(getUID());
-
     std::string socketPath = getRuntimeDir() + "/" + instanceSignature + "/" + filename;
 
     strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
 
-    if (connect(SERVERSOCKET, (sockaddr*)&serverAddress, SUN_LEN(&serverAddress)) < 0) {
+    if (connect(SERVERSOCKET, rc<sockaddr*>(&serverAddress), SUN_LEN(&serverAddress)) < 0) {
         log("Couldn't connect to " + socketPath + ". (3)");
         return 3;
     }
@@ -257,7 +283,7 @@ int requestIPC(std::string filename, std::string arg) {
     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());
+    auto sizeWritten = write(SERVERSOCKET, arg.data(), arg.size());
 
     if (sizeWritten < 0) {
         log("Couldn't write (4)");
@@ -280,16 +306,12 @@ int requestIPC(std::string filename, std::string arg) {
     return 0;
 }
 
-int requestHyprpaper(std::string arg) {
+int requestHyprsunset(std::string_view arg) {
-    return requestIPC(".hyprpaper.sock", arg);
-}
-
-int requestHyprsunset(std::string arg) {
     return requestIPC(".hyprsunset.sock", arg);
 }
 
-void batchRequest(std::string arg, bool json) {
+void batchRequest(std::string_view arg, bool json) {
-    std::string commands = arg.substr(arg.find_first_of(' ') + 1);
+    std::string commands(arg.substr(arg.find_first_of(' ') + 1));
 
     if (json) {
         RE2::GlobalReplace(&commands, ";\\s*", ";j/");
@@ -360,7 +382,7 @@ int main(int argc, char** argv) {
             parseArgs = false;
             continue;
         }
-        if (parseArgs && (ARGS[i][0] == '-') && !isNumber(ARGS[i], true) /* For stuff like -2 */) {
+        if (parseArgs && (ARGS[i][0] == '-') && !(isNumber(ARGS[i], true) || isNumber(ARGS[i].substr(0, ARGS[i].length() - 1), true)) /* For stuff like -2 or -2, */) {
             // parse
             if (ARGS[i] == "-j" && !fullArgs.contains("j")) {
                 fullArgs += "j";
@@ -402,6 +424,8 @@ int main(int argc, char** argv) {
                     std::println("{}", PLUGIN_HELP);
                 } else if (cmd == "setprop") {
                     std::println("{}", SETPROP_HELP);
+                } else if (cmd == "getprop") {
+                    std::println("{}", GETPROP_HELP);
                 } else if (cmd == "switchxkblayout") {
                     std::println("{}", SWITCHXKBLAYOUT_HELP);
                 } else {
@@ -452,7 +476,7 @@ int main(int argc, char** argv) {
 
         const auto INSTANCES = instances();
 
-        if (INSTANCENO < 0 || static_cast<std::size_t>(INSTANCENO) >= INSTANCES.size()) {
+        if (INSTANCENO < 0 || sc<std::size_t>(INSTANCENO) >= INSTANCES.size()) {
             log("no such instance\n");
             return 1;
         }
@@ -473,9 +497,12 @@ int main(int argc, char** argv) {
 
     if (fullRequest.contains("/--batch"))
         batchRequest(fullRequest, json);
-    else if (fullRequest.contains("/hyprpaper"))
+    else if (fullRequest.contains("/hyprpaper")) {
-        exitStatus = requestHyprpaper(fullRequest);
+        auto result = Hyprpaper::makeHyprpaperRequest(fullRequest);
-    else if (fullRequest.contains("/hyprsunset"))
+        if (!result)
+            log(std::format("error: {}", result.error()));
+        exitStatus = !result;
+    } else if (fullRequest.contains("/hyprsunset"))
         exitStatus = requestHyprsunset(fullRequest);
     else if (fullRequest.contains("/switchxkblayout"))
         exitStatus = request(fullRequest, 2);

hyprland.pc.in

@@ -4,4 +4,5 @@ Name: Hyprland
 URL: https://github.com/hyprwm/Hyprland
 Description: Hyprland header files
 Version: @HYPRLAND_VERSION@
+Requires: aquamarine >= @AQUAMARINE_MINIMUM_VERSION@, hyprcursor >= @HYPRCURSOR_MINIMUM_VERSION@, hyprgraphics >= @HYPRGRAPHICS_MINIMUM_VERSION@, hyprlang >= @HYPRLANG_MINIMUM_VERSION@, hyprutils >= @HYPRUTILS_MINIMUM_VERSION@, libdrm, egl, cairo, xkbcommon >= @XKBCOMMON_MINIMUM_VERSION@, libinput >= @LIBINPUT_MINIMUM_VERSION@, wayland-server >= @WAYLAND_SERVER_MINIMUM_VERSION@@PKGCONFIG_XWAYLAND_DEPENDENCIES@
 Cflags: -I${prefix} -I${prefix}/hyprland/protocols -I${prefix}/hyprland

hyprpm/CMakeLists.txt

@@ -11,9 +11,9 @@ set(CMAKE_CXX_STANDARD 23)
 
 pkg_check_modules(hyprpm_deps REQUIRED IMPORTED_TARGET tomlplusplus hyprutils>=0.7.0)
 
-find_package(glaze QUIET)
+find_package(glaze 6.0.0 QUIET)
 if (NOT glaze_FOUND)
-    set(GLAZE_VERSION v5.1.1)
+    set(GLAZE_VERSION v6.1.0)
     message(STATUS "glaze dependency not found, retrieving ${GLAZE_VERSION} with FetchContent")
     include(FetchContent)
     FetchContent_Declare(

hyprpm/hyprpm.fish

@@ -29,8 +29,8 @@ function _hyprpm
     set descriptions[6] "Show help menu"
     set descriptions[7] "Check and update all plugins if needed"
     set descriptions[8] "Install a new plugin repository from git"
-    set descriptions[9] "Enable too much loggin"
+    set descriptions[9] "Enable too much logging"
-    set descriptions[10] "Enable too much loggin"
+    set descriptions[10] "Enable too much logging"
     set descriptions[11] "Force an operation ignoring checks (e.g. update -f)"
     set descriptions[12] "Disable shallow cloning of Hyprland sources"
     set descriptions[13] "Remove a plugin repository"

hyprpm/hyprpm.usage

@@ -3,7 +3,7 @@ hyprpm [<FLAGS>]... <ARGUMENT>
 
 <FLAGS> ::= (--notify | -n)             "Send a hyprland notification for important events (e.g. load fail)"
         |   (--help | -h)               "Show help menu"
-        |   (--verbose | -v)            "Enable too much loggin"
+        |   (--verbose | -v)            "Enable too much logging"
         |   (--force | -f)              "Force an operation ignoring checks (e.g. update -f)"
         |   (--no-shallow | -s)         "Disable shallow cloning of Hyprland sources"
         ;

hyprpm/hyprpm.zsh

@@ -19,8 +19,8 @@ _hyprpm () {
     descriptions[6]="Show help menu"
     descriptions[7]="Check and update all plugins if needed"
     descriptions[8]="Install a new plugin repository from git"
-    descriptions[9]="Enable too much loggin"
+    descriptions[9]="Enable too much logging"
-    descriptions[10]="Enable too much loggin"
+    descriptions[10]="Enable too much logging"
     descriptions[11]="Force an operation ignoring checks (e.g. update -f)"
     descriptions[12]="Disable shallow cloning of Hyprland sources"
     descriptions[13]="Remove a plugin repository"

hyprpm/src/core/DataState.cpp

@@ -18,6 +18,9 @@ static std::string getTempRoot() {
 
     const auto STR = ENV + std::string{"/hyprpm/"};
 
+    if (!std::filesystem::exists(STR))
+        mkdir(STR.c_str(), S_IRWXU);
+
     return STR;
 }
 
@@ -90,6 +93,7 @@ void DataState::addNewPluginRepo(const SPluginRepository& repo) {
     auto DATA = toml::table{
         {"repository", toml::table{
             {"name", repo.name},
+            {"author", repo.author},
             {"hash", repo.hash},
             {"url", repo.url},
             {"rev", repo.rev}
@@ -119,31 +123,32 @@ void DataState::addNewPluginRepo(const SPluginRepository& repo) {
         Debug::die("{}", failureString("Failed to write plugin state"));
 }
 
-bool DataState::pluginRepoExists(const std::string& urlOrName) {
+bool DataState::pluginRepoExists(const SPluginRepoIdentifier identifier) {
     ensureStateStoreExists();
 
     for (const auto& stateFile : getPluginStates()) {
         const auto STATE  = toml::parse_file(stateFile.c_str());
         const auto NAME   = STATE["repository"]["name"].value_or("");
+        const auto AUTHOR = STATE["repository"]["author"].value_or("");
         const auto URL    = STATE["repository"]["url"].value_or("");
 
-        if (URL == urlOrName || NAME == urlOrName)
+        if (identifier.matches(URL, NAME, AUTHOR))
             return true;
     }
 
     return false;
 }
 
-void DataState::removePluginRepo(const std::string& urlOrName) {
+void DataState::removePluginRepo(const SPluginRepoIdentifier identifier) {
     ensureStateStoreExists();
 
     for (const auto& stateFile : getPluginStates()) {
         const auto STATE  = toml::parse_file(stateFile.c_str());
         const auto NAME   = STATE["repository"]["name"].value_or("");
+        const auto AUTHOR = STATE["repository"]["author"].value_or("");
         const auto URL    = STATE["repository"]["url"].value_or("");
 
-        if (URL == urlOrName || NAME == urlOrName) {
+        if (identifier.matches(URL, NAME, AUTHOR)) {
-
             // unload the plugins!!
             for (const auto& file : std::filesystem::directory_iterator(stateFile.parent_path())) {
                 if (!file.path().string().ends_with(".so"))
@@ -178,7 +183,7 @@ void DataState::updateGlobalState(const SGlobalState& state) {
     // clang-format off
     auto DATA = toml::table{
         {"state", toml::table{
-            {"hash", state.headersHashCompiled},
+            {"hash", state.headersAbiCompiled},
             {"dont_warn_install", state.dontWarnInstall}
         }}
     };
@@ -203,7 +208,7 @@ SGlobalState DataState::getGlobalState() {
     auto         DATA = toml::parse_file(stateFile.c_str());
 
     SGlobalState state;
-    state.headersHashCompiled = DATA["state"]["hash"].value_or("");
+    state.headersAbiCompiled = DATA["state"]["hash"].value_or("");
     state.dontWarnInstall    = DATA["state"]["dont_warn_install"].value_or(false);
 
     return state;
@@ -217,6 +222,7 @@ std::vector<SPluginRepository> DataState::getAllRepositories() {
         const auto        STATE = toml::parse_file(stateFile.c_str());
 
         const auto        NAME   = STATE["repository"]["name"].value_or("");
+        const auto        AUTHOR = STATE["repository"]["author"].value_or("");
         const auto        URL    = STATE["repository"]["url"].value_or("");
         const auto        REV    = STATE["repository"]["rev"].value_or("");
         const auto        HASH   = STATE["repository"]["hash"].value_or("");
@@ -224,6 +230,7 @@ std::vector<SPluginRepository> DataState::getAllRepositories() {
         SPluginRepository repo;
         repo.hash   = HASH;
         repo.name   = NAME;
+        repo.author = AUTHOR;
         repo.url    = URL;
         repo.rev    = REV;
 
@@ -244,7 +251,7 @@ std::vector<SPluginRepository> DataState::getAllRepositories() {
     return repos;
 }
 
-bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
+bool DataState::setPluginEnabled(const SPluginRepoIdentifier identifier, bool enabled) {
     ensureStateStoreExists();
 
     for (const auto& stateFile : getPluginStates()) {
@@ -253,8 +260,17 @@ bool DataState::setPluginEnabled(const std::string& name, bool enabled) {
             if (key == "repository")
                 continue;
 
-            if (key.str() != name)
+            switch (identifier.type) {
+                case IDENTIFIER_NAME:
+                    if (key.str() != identifier.name)
                         continue;
+                    break;
+                case IDENTIFIER_AUTHOR_NAME:
+                    if (STATE["repository"]["author"] != identifier.author || key.str() != identifier.name)
+                        continue;
+                    break;
+                default: return false;
+            }
 
             const auto FAILED = STATE[key]["failed"].value_or(false);
 

hyprpm/src/core/DataState.hpp

@@ -5,7 +5,7 @@
 #include "Plugin.hpp"
 
 struct SGlobalState {
-    std::string headersHashCompiled = "";
+    std::string headersAbiCompiled = "";
     bool        dontWarnInstall    = false;
 };
 
@@ -15,11 +15,11 @@ namespace DataState {
     std::vector<std::filesystem::path> getPluginStates();
     void                               ensureStateStoreExists();
     void                               addNewPluginRepo(const SPluginRepository& repo);
-    void                               removePluginRepo(const std::string& urlOrName);
+    void                               removePluginRepo(const SPluginRepoIdentifier identifier);
-    bool                               pluginRepoExists(const std::string& urlOrName);
+    bool                               pluginRepoExists(const SPluginRepoIdentifier identifier);
     void                               updateGlobalState(const SGlobalState& state);
     void                               purgeAllCache();
     SGlobalState                       getGlobalState();
-    bool                               setPluginEnabled(const std::string& name, bool enabled);
+    bool                               setPluginEnabled(const SPluginRepoIdentifier identifier, bool enabled);
     std::vector<SPluginRepository>     getAllRepositories();
 };

hyprpm/src/core/HyprlandSocket.cpp

@@ -5,6 +5,10 @@
 #include <print>
 #include <sys/un.h>
 #include <unistd.h>
+#include <cstring>
+#include <hyprutils/memory/Casts.hpp>
+
+using namespace Hyprutils::Memory;
 
 static int getUID() {
     const auto UID   = getuid();
@@ -45,7 +49,7 @@ std::string NHyprlandSocket::send(const std::string& cmd) {
 
     strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
 
-    if (connect(SERVERSOCKET, (sockaddr*)&serverAddress, SUN_LEN(&serverAddress)) < 0) {
+    if (connect(SERVERSOCKET, rc<sockaddr*>(&serverAddress), SUN_LEN(&serverAddress)) < 0) {
         std::println("{}", failureString("Couldn't connect to " + socketPath + ". (4)"));
         return "";
     }

hyprpm/src/core/Plugin.cpp

@@ -0,0 +1,48 @@
+#include "Plugin.hpp"
+
+SPluginRepoIdentifier SPluginRepoIdentifier::fromUrl(const std::string& url) {
+    return SPluginRepoIdentifier{.type = IDENTIFIER_URL, .url = url};
+}
+
+SPluginRepoIdentifier SPluginRepoIdentifier::fromName(const std::string& name) {
+    return SPluginRepoIdentifier{.type = IDENTIFIER_NAME, .name = name};
+}
+
+SPluginRepoIdentifier SPluginRepoIdentifier::fromAuthorName(const std::string& author, const std::string& name) {
+    return SPluginRepoIdentifier{.type = IDENTIFIER_AUTHOR_NAME, .name = name, .author = author};
+}
+
+SPluginRepoIdentifier SPluginRepoIdentifier::fromString(const std::string& string) {
+    if (string.find(':') != std::string::npos) {
+        return SPluginRepoIdentifier{.type = IDENTIFIER_URL, .url = string};
+    } else {
+        auto slashPos = string.find('/');
+        if (slashPos != std::string::npos) {
+            std::string author = string.substr(0, slashPos);
+            std::string name   = string.substr(slashPos + 1, string.size() - slashPos - 1);
+            return SPluginRepoIdentifier{.type = IDENTIFIER_AUTHOR_NAME, .name = name, .author = author};
+        } else {
+            return SPluginRepoIdentifier{.type = IDENTIFIER_NAME, .name = string};
+        }
+    }
+}
+
+std::string SPluginRepoIdentifier::toString() const {
+    switch (type) {
+        case IDENTIFIER_NAME: return name;
+        case IDENTIFIER_AUTHOR_NAME: return author + '/' + name;
+        case IDENTIFIER_URL: return url;
+    }
+
+    return "";
+}
+
+bool SPluginRepoIdentifier::matches(const std::string& url, const std::string& name, const std::string& author) const {
+    switch (type) {
+        case IDENTIFIER_URL: return this->url == url;
+        case IDENTIFIER_NAME: return this->name == name;
+        case IDENTIFIER_AUTHOR_NAME: return this->author == author && this->name == name;
+    }
+
+    return false;
+}

hyprpm/src/core/Plugin.hpp

@@ -14,6 +14,27 @@ struct SPluginRepository {
     std::string          url;
     std::string          rev;
     std::string          name;
+    std::string          author;
     std::vector<SPlugin> plugins;
     std::string          hash;
 };
+
+enum ePluginRepoIdentifierType {
+    IDENTIFIER_URL,
+    IDENTIFIER_NAME,
+    IDENTIFIER_AUTHOR_NAME
+};
+
+struct SPluginRepoIdentifier {
+    ePluginRepoIdentifierType    type;
+    std::string                  url    = "";
+    std::string                  name   = "";
+    std::string                  author = "";
+
+    static SPluginRepoIdentifier fromString(const std::string& string);
+    static SPluginRepoIdentifier fromUrl(const std::string& Url);
+    static SPluginRepoIdentifier fromName(const std::string& name);
+    static SPluginRepoIdentifier fromAuthorName(const std::string& author, const std::string& name);
+    std::string                  toString() const;
+    bool                         matches(const std::string& url, const std::string& name, const std::string& author) const;
+};

hyprpm/src/core/PluginManager.cpp

@@ -11,6 +11,7 @@
 #include <cstdio>
 #include <iostream>
 #include <filesystem>
+#include <string>
 #include <print>
 #include <fstream>
 #include <algorithm>
@@ -26,8 +27,10 @@
 
 #include <hyprutils/string/String.hpp>
 #include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/Casts.hpp>
 using namespace Hyprutils::String;
 using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
 
 static std::string execAndGet(std::string cmd) {
     cmd += " 2>&1";
@@ -76,40 +79,30 @@ SHyprlandVersion CPluginManager::getHyprlandVersion(bool running) {
     else
         onceInstalled = true;
 
-    const auto HLVERCALL = running ? NHyprlandSocket::send("/version") : execAndGet("Hyprland --version");
+    const auto HLVERCALL = running ? NHyprlandSocket::send("j/version") : execAndGet("Hyprland --version-json");
-    if (m_bVerbose)
-        std::println("{}", verboseString("{} version returned: {}", running ? "running" : "installed", HLVERCALL));
 
-    if (!HLVERCALL.contains("Tag:")) {
+    auto       jsonQuery = glz::read_json<glz::generic>(HLVERCALL);
-        std::println(stderr, "\n{}", failureString("You don't seem to be running Hyprland."));
+
+    if (!jsonQuery) {
+        std::println("{}", failureString("failed to get the current hyprland version. Are you running hyprland?"));
         return SHyprlandVersion{};
     }
 
-    std::string hlcommit = HLVERCALL.substr(HLVERCALL.find("at commit") + 10);
+    auto   hlbranch  = (*jsonQuery)["branch"].get_string();
-    hlcommit             = hlcommit.substr(0, hlcommit.find_first_of(' '));
+    auto   hlcommit  = (*jsonQuery)["commit"].get_string();
+    auto   abiHash   = (*jsonQuery)["abiHash"].get_string();
+    auto   hldate    = (*jsonQuery)["commit_date"].get_string();
+    auto   hlcommits = (*jsonQuery)["commits"].get_string();
 
-    std::string hlbranch = HLVERCALL.substr(HLVERCALL.find("from branch") + 12);
+    size_t commits = 0;
-    hlbranch             = hlbranch.substr(0, hlbranch.find(" at commit "));
-
-    std::string hldate = HLVERCALL.substr(HLVERCALL.find("Date: ") + 6);
-    hldate             = hldate.substr(0, hldate.find('\n'));
-
-    std::string hlcommits;
-
-    if (HLVERCALL.contains("commits:")) {
-        hlcommits = HLVERCALL.substr(HLVERCALL.find("commits:") + 9);
-        hlcommits = hlcommits.substr(0, hlcommits.find(' '));
-    }
-
-    int commits = 0;
     try {
-        commits = std::stoi(hlcommits);
+        commits = std::stoull(hlcommits);
     } catch (...) { ; }
 
     if (m_bVerbose)
         std::println("{}", verboseString("parsed commit {} at branch {} on {}, commits {}", hlcommit, hlbranch, hldate, commits));
 
-    auto ver = SHyprlandVersion{hlbranch, hlcommit, hldate, commits};
+    auto ver = SHyprlandVersion{hlbranch, hlcommit, hldate, abiHash, commits};
 
     if (running)
         verRunning = ver;
@@ -144,7 +137,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
         return false;
     }
 
-    if (DataState::pluginRepoExists(url)) {
+    if (DataState::pluginRepoExists(SPluginRepoIdentifier::fromUrl(url))) {
         std::println(stderr, "\n{}", failureString("Could not clone the plugin repository. Repository already installed."));
         return false;
     }
@@ -152,13 +145,18 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     auto GLOBALSTATE = DataState::getGlobalState();
     if (!GLOBALSTATE.dontWarnInstall) {
         std::println("{}!{} Disclaimer: {}", Colors::YELLOW, Colors::RED, Colors::RESET);
-        std::println("plugins, especially not official, have no guarantee of stability, availablity or security.\n"
+        std::println("plugins, especially not official, have no guarantee of stability, availability or security.\n"
                      "Run them at your own risk.\n"
                      "This message will not appear again.");
         GLOBALSTATE.dontWarnInstall = true;
         DataState::updateGlobalState(GLOBALSTATE);
     }
 
+    if (GLOBALSTATE.headersAbiCompiled.empty()) {
+        std::println("\n{}", failureString("Cannot find headers in the global state. Try running hyprpm update first."));
+        return false;
+    }
+
     std::cout << Colors::GREEN << "✔" << Colors::RESET << Colors::RED << " adding a new plugin repository " << Colors::RESET << "from " << url << "\n  " << Colors::RED
               << "MAKE SURE" << Colors::RESET << " that you trust the authors. " << Colors::RED << "DO NOT" << Colors::RESET
               << " install random plugins without verifying the code and author.\n  "
@@ -256,7 +254,7 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
         progress.printMessageAbove(message);
     }
 
-    if (!pManifest->m_repository.commitPins.empty()) {
+    if (rev.empty() && !pManifest->m_repository.commitPins.empty()) {
         // check commit pins
 
         progress.printMessageAbove(infoString("Manifest has {} pins, checking", pManifest->m_repository.commitPins.size()));
@@ -336,7 +334,10 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     std::string       repohash = execAndGet("cd " + m_szWorkingPluginDirectory + " && git rev-parse HEAD");
     if (repohash.length() > 0)
         repohash.pop_back();
-    repo.name = pManifest->m_repository.name.empty() ? url.substr(url.find_last_of('/') + 1) : pManifest->m_repository.name;
+    auto lastSlash       = url.find_last_of('/');
+    auto secondLastSlash = url.find_last_of('/', lastSlash - 1);
+    repo.name            = pManifest->m_repository.name.empty() ? url.substr(lastSlash + 1) : pManifest->m_repository.name;
+    repo.author          = url.substr(secondLastSlash + 1, lastSlash - secondLastSlash - 1);
     repo.url             = url;
     repo.rev             = rev;
     repo.hash            = repohash;
@@ -359,13 +360,13 @@ bool CPluginManager::addNewPluginRepo(const std::string& url, const std::string&
     return true;
 }
 
-bool CPluginManager::removePluginRepo(const std::string& urlOrName) {
+bool CPluginManager::removePluginRepo(const SPluginRepoIdentifier identifier) {
-    if (!DataState::pluginRepoExists(urlOrName)) {
+    if (!DataState::pluginRepoExists(identifier)) {
         std::println(stderr, "\n{}", failureString("Could not remove the repository. Repository is not installed."));
         return false;
     }
 
-    std::cout << Colors::YELLOW << "!" << Colors::RESET << Colors::RED << " removing a plugin repository: " << Colors::RESET << urlOrName << "\n  "
+    std::cout << Colors::YELLOW << "!" << Colors::RESET << Colors::RED << " removing a plugin repository: " << Colors::RESET << identifier.toString() << "\n  "
               << "Are you sure? [Y/n] ";
     std::fflush(stdout);
     std::string input;
@@ -376,7 +377,7 @@ bool CPluginManager::removePluginRepo(const std::string& urlOrName) {
         return false;
     }
 
-    DataState::removePluginRepo(urlOrName);
+    DataState::removePluginRepo(identifier);
 
     return true;
 }
@@ -437,11 +438,16 @@ eHeadersErrors CPluginManager::headersValid() {
     if (hash != HLVER.hash)
         return HEADERS_MISMATCHED;
 
+    // check ABI hash too
+    const auto GLOBALSTATE = DataState::getGlobalState();
+
+    if (GLOBALSTATE.headersAbiCompiled != HLVER.abiHash)
+        return HEADERS_ABI_MISMATCH;
+
     return HEADERS_OK;
 }
 
 bool CPluginManager::updateHeaders(bool force) {
-
     DataState::ensureStateStoreExists();
 
     const auto HLVER = getHyprlandVersion(false);
@@ -566,7 +572,7 @@ bool CPluginManager::updateHeaders(bool force) {
 
     ret = execAndGet(cmd);
 
-    cmd = std::format("make -C '{}' installheaders && chmod -R 644 '{}' && find '{}' -type d -exec chmod o+x {{}} \\;", WORKINGDIR, DataState::getHeadersPath(),
+    cmd = std::format("make -C '{}' installheaders && chmod -R 644 '{}' && find '{}' -type d -exec chmod a+x {{}} \\;", WORKINGDIR, DataState::getHeadersPath(),
                       DataState::getHeadersPath());
 
     if (m_bVerbose)
@@ -582,19 +588,20 @@ bool CPluginManager::updateHeaders(bool force) {
     std::filesystem::remove_all(WORKINGDIR);
 
     auto HEADERSVALID = headersValid();
-    if (HEADERSVALID == HEADERS_OK) {
+
+    if (HEADERSVALID == HEADERS_OK || HEADERSVALID == HEADERS_MISMATCHED || HEADERSVALID == HEADERS_ABI_MISMATCH) {
         progress.printMessageAbove(successString("installed headers"));
         progress.m_iSteps           = 5;
         progress.m_szCurrentMessage = "Done!";
         progress.print();
 
         auto GLOBALSTATE               = DataState::getGlobalState();
-        GLOBALSTATE.headersHashCompiled = HLVER.hash;
+        GLOBALSTATE.headersAbiCompiled = HLVER.abiHash;
         DataState::updateGlobalState(GLOBALSTATE);
 
         std::print("\n");
     } else {
-        progress.printMessageAbove(failureString("failed to install headers with error code {} ({})", (int)HEADERSVALID, headerErrorShort(HEADERSVALID)));
+        progress.printMessageAbove(failureString("failed to install headers with error code {} ({})", sc<int>(HEADERSVALID), headerErrorShort(HEADERSVALID)));
         progress.printMessageAbove(infoString("if the problem persists, try running hyprpm purge-cache."));
         progress.m_iSteps           = 5;
         progress.m_szCurrentMessage = "Failed";
@@ -768,7 +775,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
             const auto OLDPLUGINIT = std::find_if(repo.plugins.begin(), repo.plugins.end(), [&](const auto& other) { return other.name == p.name; });
             newrepo.plugins.push_back(SPlugin{p.name, m_szWorkingPluginDirectory + "/" + p.output, OLDPLUGINIT != repo.plugins.end() ? OLDPLUGINIT->enabled : false});
         }
-        DataState::removePluginRepo(newrepo.name);
+        DataState::removePluginRepo(SPluginRepoIdentifier::fromName(newrepo.name));
         DataState::addNewPluginRepo(newrepo);
 
         std::filesystem::remove_all(m_szWorkingPluginDirectory);
@@ -781,7 +788,7 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
     progress.print();
 
     auto GLOBALSTATE               = DataState::getGlobalState();
-    GLOBALSTATE.headersHashCompiled = HLVER.hash;
+    GLOBALSTATE.headersAbiCompiled = HLVER.abiHash;
     DataState::updateGlobalState(GLOBALSTATE);
 
     progress.m_iSteps++;
@@ -793,17 +800,23 @@ bool CPluginManager::updatePlugins(bool forceUpdateAll) {
     return true;
 }
 
-bool CPluginManager::enablePlugin(const std::string& name) {
+bool CPluginManager::enablePlugin(const SPluginRepoIdentifier identifier) {
-    bool ret = DataState::setPluginEnabled(name, true);
+    bool ret = false;
+
+    switch (identifier.type) {
+        case IDENTIFIER_NAME:
+        case IDENTIFIER_AUTHOR_NAME: ret = DataState::setPluginEnabled(identifier, true); break;
+        default: return false;
+    }
     if (ret)
-        std::println("{}", successString("Enabled {}", name));
+        std::println("{}", successString("Enabled {}", identifier.name));
     return ret;
 }
 
-bool CPluginManager::disablePlugin(const std::string& name) {
+bool CPluginManager::disablePlugin(const SPluginRepoIdentifier identifier) {
-    bool ret = DataState::setPluginEnabled(name, false);
+    bool ret = DataState::setPluginEnabled(identifier, false);
     if (ret)
-        std::println("{}", successString("Disabled {}", name));
+        std::println("{}", successString("Disabled {}", identifier.name));
     return ret;
 }
 
@@ -821,7 +834,7 @@ ePluginLoadStateReturn CPluginManager::ensurePluginsLoadState(bool forceReload)
     }
     const auto HYPRPMPATH = DataState::getDataStatePath();
 
-    const auto json = glz::read_json<glz::json_t::array_t>(NHyprlandSocket::send("j/plugins list"));
+    const auto json = glz::read_json<glz::generic::array_t>(NHyprlandSocket::send("j/plugins list"));
     if (!json) {
         std::println(stderr, "PluginManager: couldn't parse plugin list output");
         return LOADSTATE_FAIL;
@@ -906,9 +919,9 @@ bool CPluginManager::loadUnloadPlugin(const std::string& path, bool load) {
     auto state = DataState::getGlobalState();
     auto HLVER = getHyprlandVersion(true);
 
-    if (state.headersHashCompiled != HLVER.hash) {
+    if (state.headersAbiCompiled != HLVER.abiHash) {
         if (load)
-            std::println("{}", infoString("Running Hyprland version ({}) differs from plugin state ({}), please restart Hyprland.", HLVER.hash, state.headersHashCompiled));
+            std::println("{}", infoString("Running Hyprland version ({}) differs from plugin state ({}), please restart Hyprland.", HLVER.hash, state.headersAbiCompiled));
         return false;
     }
 
@@ -924,7 +937,7 @@ void CPluginManager::listAllPlugins() {
     const auto REPOS = DataState::getAllRepositories();
 
     for (auto const& r : REPOS) {
-        std::println("{}", infoString("Repository {}:", r.name));
+        std::println("{}", infoString("Repository {} (by {}):", r.name, r.author));
 
         for (auto const& p : r.plugins) {
             std::println("  │ Plugin {}", p.name);
@@ -940,7 +953,7 @@ void CPluginManager::listAllPlugins() {
 }
 
 void CPluginManager::notify(const eNotifyIcons icon, uint32_t color, int durationMs, const std::string& message) {
-    NHyprlandSocket::send("/notify " + std::to_string((int)icon) + " " + std::to_string(durationMs) + " " + std::to_string(color) + " " + message);
+    NHyprlandSocket::send("/notify " + std::to_string(icon) + " " + std::to_string(durationMs) + " " + std::to_string(color) + " " + message);
 }
 
 std::string CPluginManager::headerError(const eHeadersErrors err) {
@@ -949,6 +962,7 @@ std::string CPluginManager::headerError(const eHeadersErrors err) {
         case HEADERS_MISMATCHED: return failureString("Headers version mismatch. Please run hyprpm update to fix those.\n");
         case HEADERS_NOT_HYPRLAND: return failureString("It doesn't seem you are running on hyprland.\n");
         case HEADERS_MISSING: return failureString("Headers missing. Please run hyprpm update to fix those.\n");
+        case HEADERS_ABI_MISMATCH: return failureString("ABI is mismatched. Please run hyprpm update to fix that.\n");
         case HEADERS_DUPLICATED: {
             return failureString("Headers duplicated!!! This is a very bad sign.\n"
                                  "This could be due to e.g. installing hyprland manually while a system package of hyprland is also installed.\n"
@@ -973,11 +987,15 @@ std::string CPluginManager::headerErrorShort(const eHeadersErrors err) {
 }
 
 bool CPluginManager::hasDeps() {
+    bool                     hasAllDeps = true;
     std::vector<std::string> deps       = {"meson", "cpio", "cmake", "pkg-config", "g++", "gcc", "git"};
+
     for (auto const& d : deps) {
-        if (!execAndGet("command -v " + d).contains("/"))
+        if (!execAndGet("command -v " + d).contains("/")) {
-            return false;
+            std::println(stderr, "{}", failureString("Missing dependency: {}", d));
+            hasAllDeps = false;
+        }
     }
 
-    return true;
+    return hasAllDeps;
 }

hyprpm/src/core/PluginManager.hpp

@@ -1,8 +1,11 @@
 #pragma once
 
+#include <cstdint>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
+#include "Plugin.hpp"
 
 enum eHeadersErrors {
     HEADERS_OK = 0,
@@ -10,6 +13,7 @@ enum eHeadersErrors {
     HEADERS_MISSING,
     HEADERS_CORRUPTED,
     HEADERS_MISMATCHED,
+    HEADERS_ABI_MISMATCH,
     HEADERS_DUPLICATED
 };
 
@@ -35,6 +39,7 @@ struct SHyprlandVersion {
     std::string branch;
     std::string hash;
     std::string date;
+    std::string abiHash;
     int         commits = 0;
 };
 
@@ -43,7 +48,7 @@ class CPluginManager {
     CPluginManager();
 
     bool                   addNewPluginRepo(const std::string& url, const std::string& rev);
-    bool                   removePluginRepo(const std::string& urlOrName);
+    bool                   removePluginRepo(const SPluginRepoIdentifier identifier);
 
     eHeadersErrors         headersValid();
     bool                   updateHeaders(bool force = false);
@@ -51,8 +56,8 @@ class CPluginManager {
 
     void                   listAllPlugins();
 
-    bool                   enablePlugin(const std::string& name);
+    bool                   enablePlugin(const SPluginRepoIdentifier identifier);
-    bool                   disablePlugin(const std::string& name);
+    bool                   disablePlugin(const SPluginRepoIdentifier identifier);
     ePluginLoadStateReturn ensurePluginsLoadState(bool forceReload = false);
 
     bool                   loadUnloadPlugin(const std::string& path, bool load);

hyprpm/src/helpers/Sys.cpp

@@ -4,9 +4,11 @@
 
 #include <pwd.h>
 #include <unistd.h>
+#include <sstream>
 #include <print>
 #include <filesystem>
 #include <algorithm>
+#include <sstream>
 
 #include <hyprutils/os/Process.hpp>
 #include <hyprutils/string/VarList.hpp>
@@ -152,7 +154,7 @@ bool NSys::root::install(const std::string& what, const std::string& where, cons
     if (!std::ranges::all_of(mode, [](const char& c) { return c >= '0' && c <= '9'; }))
         return false;
 
-    CProcess proc(subin(), {"install", "-m" + mode, "-o", "root", "-g", "root", what, where});
+    CProcess proc(subin(), {"install", "-m" + mode, "-o", "0", "-g", "0", what, where});
 
     return proc.runSync() && proc.exitCode() == 0;
 }

hyprpm/src/main.cpp

@@ -13,11 +13,11 @@ using namespace Hyprutils::Utils;
 
 constexpr std::string_view HELP = R"#(┏ hyprpm, a Hyprland Plugin Manager
 ┃
-┣ add [url] [git rev]    → Install a new plugin repository from git. Git revision.
+┣ add <url> [git rev]           → Install a new plugin repository from git. Git revision
 ┃                                 is optional, when set, commit locks are ignored.
-┣ remove [url/name]      → Remove an installed plugin repository.
+┣ remove <url|name|author/name> → Remove an installed plugin repository.
-┣ enable [name]          → Enable a plugin.
+┣ enable <name|author/name>     → Enable a plugin.
-┣ disable [name]         → Disable a plugin.
+┣ disable <name|author/name>    → Disable a plugin.
 ┣ update                        → Check and update all plugins if needed.
 ┣ reload                        → Reload hyprpm state. Ensure all enabled plugins are loaded.
 ┣ list                          → List all installed plugins.
@@ -25,8 +25,8 @@ constexpr std::string_view HELP = R"#(┏ hyprpm, a Hyprland Plugin Manager
 ┃
 ┣ Flags:
 ┃
-┣ --notify       | -n    → Send a hyprland notification for important events (including both successes and fail events).
+┣ --notify       | -n           → Send a hyprland notification confirming successful plugin load.
-┣ --notify-fail  | -nn   → Send a hyprland notification for fail events only.
+┃                                 Warnings/Errors trigger notifications regardless of this flag.
 ┣ --help         | -h           → Show this menu.
 ┣ --verbose      | -v           → Enable too much logging.
 ┣ --force        | -f           → Force an operation ignoring checks (e.g. update -f).
@@ -47,7 +47,7 @@ int                        main(int argc, char** argv, char** envp) {
     }
 
     std::vector<std::string> command;
-    bool                     notify = false, notifyFail = false, verbose = false, force = false, noShallow = false;
+    bool                     notify = false, verbose = false, force = false, noShallow = false;
     std::string              customHlUrl;
 
     for (int i = 1; i < argc; ++i) {
@@ -58,7 +58,9 @@ int                        main(int argc, char** argv, char** envp) {
             } else if (ARGS[i] == "--notify" || ARGS[i] == "-n") {
                 notify = true;
             } else if (ARGS[i] == "--notify-fail" || ARGS[i] == "-nn") {
-                notifyFail = notify = true;
+                // TODO: Deprecated since v.053.0. Remove in version>0.56.0
+                std::println(stderr, "{}", failureString("Deprececated flag."));
+                g_pPluginManager->notify(ICON_INFO, 0, 10000, "[hyprpm] -n flag is deprecated, see hyprpm --help.");
             } else if (ARGS[i] == "--verbose" || ARGS[i] == "-v") {
                 verbose = true;
             } else if (ARGS[i] == "--no-shallow" || ARGS[i] == "-s") {
@@ -101,12 +103,22 @@ int                        main(int argc, char** argv, char** envp) {
         if (command.size() >= 3)
             rev = command[2];
 
+        const auto HLVER       = g_pPluginManager->getHyprlandVersion();
+        auto       GLOBALSTATE = DataState::getGlobalState();
+
+        if (GLOBALSTATE.headersAbiCompiled != HLVER.abiHash) {
+            std::println(stderr, "{}", failureString("Headers outdated, please run hyprpm update."));
+            return 1;
+        }
+
         NSys::root::cacheSudo();
         CScopeGuard x([] { NSys::root::dropSudo(); });
 
+        g_pPluginManager->updateHeaders(false);
+
         return g_pPluginManager->addNewPluginRepo(command[1], rev) ? 0 : 1;
     } else if (command[0] == "remove") {
-        if (ARGS.size() < 2) {
+        if (command.size() < 2) {
             std::println(stderr, "{}", failureString("Not enough args for remove."));
             return 1;
         }
@@ -114,7 +126,7 @@ int                        main(int argc, char** argv, char** envp) {
         NSys::root::cacheSudo();
         CScopeGuard x([] { NSys::root::dropSudo(); });
 
-        return g_pPluginManager->removePluginRepo(command[1]) ? 0 : 1;
+        return g_pPluginManager->removePluginRepo(SPluginRepoIdentifier::fromString(command[1])) ? 0 : 1;
     } else if (command[0] == "update") {
         NSys::root::cacheSudo();
         CScopeGuard x([] { NSys::root::dropSudo(); });
@@ -125,7 +137,7 @@ int                        main(int argc, char** argv, char** envp) {
         if (headers) {
             const auto HLVER            = g_pPluginManager->getHyprlandVersion(false);
             auto       GLOBALSTATE      = DataState::getGlobalState();
-            const auto COMPILEDOUTDATED = HLVER.hash != GLOBALSTATE.headersHashCompiled;
+            const auto COMPILEDOUTDATED = HLVER.abiHash != GLOBALSTATE.headersAbiCompiled;
 
             bool       ret1 = g_pPluginManager->updatePlugins(!headersValid || force || COMPILEDOUTDATED);
 
@@ -139,15 +151,16 @@ int                        main(int argc, char** argv, char** envp) {
 
             if (ret2 != LOADSTATE_OK)
                 return 1;
-        } else if (notify)
+        } else {
             g_pPluginManager->notify(ICON_ERROR, 0, 10000, "[hyprpm] Couldn't update headers");
+        }
     } else if (command[0] == "enable") {
-        if (ARGS.size() < 2) {
+        if (command.size() < 2) {
             std::println(stderr, "{}", failureString("Not enough args for enable."));
             return 1;
         }
 
-        if (!g_pPluginManager->enablePlugin(command[1])) {
+        if (!g_pPluginManager->enablePlugin(SPluginRepoIdentifier::fromString(command[1]))) {
             std::println(stderr, "{}", failureString("Couldn't enable plugin (missing?)"));
             return 1;
         }
@@ -168,7 +181,7 @@ int                        main(int argc, char** argv, char** envp) {
             return 1;
         }
 
-        if (!g_pPluginManager->disablePlugin(command[1])) {
+        if (!g_pPluginManager->disablePlugin(SPluginRepoIdentifier::fromString(command[1]))) {
             std::println(stderr, "{}", failureString("Couldn't disable plugin (missing?)"));
             return 1;
         }
@@ -184,7 +197,6 @@ int                        main(int argc, char** argv, char** envp) {
         auto ret = g_pPluginManager->ensurePluginsLoadState(force);
 
         if (ret != LOADSTATE_OK) {
-            if (notify) {
             switch (ret) {
                 case LOADSTATE_FAIL:
                 case LOADSTATE_PARTIAL_FAIL: g_pPluginManager->notify(ICON_ERROR, 0, 10000, "[hyprpm] Failed to load plugins"); break;
@@ -193,10 +205,9 @@ int                        main(int argc, char** argv, char** envp) {
                     break;
                 default: break;
             }
-            }
 
             return 1;
-        } else if (notify && !notifyFail) {
+        } else if (notify) {
             g_pPluginManager->notify(ICON_OK, 0, 4000, "[hyprpm] Loaded plugins");
         }
     } else if (command[0] == "purge-cache") {

hyprpm/src/meson.build

@@ -1,32 +0,0 @@
-globber = run_command('sh', '-c', 'find . -name "*.cpp" | sort', check: true)
-src = globber.stdout().strip().split('\n')
-
-executable(
-  'hyprpm',
-  src,
-  dependencies: [
-    dependency('hyprutils', version: '>= 0.1.1'),
-    dependency('threads'),
-    dependency('tomlplusplus'),
-    dependency('glaze', method: 'cmake'),
-  ],
-  install: true,
-)
-
-install_data(
-  '../hyprpm.bash',
-  install_dir: join_paths(get_option('datadir'), 'bash-completion/completions'),
-  install_tag: 'runtime',
-  rename: 'hyprpm',
-)
-install_data(
-  '../hyprpm.fish',
-  install_dir: join_paths(get_option('datadir'), 'fish/vendor_completions.d'),
-  install_tag: 'runtime',
-)
-install_data(
-  '../hyprpm.zsh',
-  install_dir: join_paths(get_option('datadir'), 'zsh/site-functions'),
-  install_tag: 'runtime',
-  rename: '_hyprpm',
-)

hyprpm/src/progress/CProgressBar.cpp

@@ -9,9 +9,11 @@
 
 #include <algorithm>
 #include <sstream>
-
+#include <hyprutils/memory/Casts.hpp>
 #include "../helpers/Colors.hpp"
 
+using namespace Hyprutils::Memory;
+
 static winsize getTerminalSize() {
     winsize w{};
     ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
@@ -44,7 +46,7 @@ void CProgressBar::print() {
         percentDone = m_fPercentage;
     else {
         // check for divide-by-zero
-        percentDone = m_iMaxSteps > 0 ? static_cast<float>(m_iSteps) / m_iMaxSteps : 0.0f;
+        percentDone = m_iMaxSteps > 0 ? sc<float>(m_iSteps) / m_iMaxSteps : 0.0f;
     }
     // clamp to ensure no overflows (sanity check)
     percentDone = std::clamp(percentDone, 0.0f, 1.0f);
@@ -54,7 +56,7 @@ void CProgressBar::print() {
     std::ostringstream oss;
     oss << ' ' << Colors::GREEN;
 
-    size_t filled = static_cast<size_t>(std::floor(percentDone * BARWIDTH));
+    size_t filled = std::floor(percentDone * BARWIDTH);
     size_t i      = 0;
 
     for (; i < filled; ++i)
@@ -69,7 +71,7 @@ void CProgressBar::print() {
         oss << Colors::RESET;
 
     if (m_fPercentage >= 0.0f)
-        oss << "  " << std::format("{}%", static_cast<int>(percentDone * 100.0)) << ' ';
+        oss << "  " << std::format("{}%", sc<int>(percentDone * 100.0)) << ' ';
     else
         oss << "  " << std::format("{} / {}", m_iSteps, m_iMaxSteps) << ' ';
 

hyprtester/CMakeLists.txt

@@ -0,0 +1,101 @@
+cmake_minimum_required(VERSION 3.19)
+
+project(hyprtester DESCRIPTION "Hyprland test suite")
+
+include(GNUInstallDirs)
+
+set(CMAKE_CXX_STANDARD 26)
+set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)
+
+find_package(PkgConfig REQUIRED)
+
+pkg_check_modules(hyprtester_deps REQUIRED IMPORTED_TARGET hyprutils>=0.5.0)
+
+file(GLOB_RECURSE SRCFILES CONFIGURE_DEPENDS "src/*.cpp")
+
+add_executable(hyprtester ${SRCFILES})
+add_custom_command(
+  TARGET hyprtester
+  POST_BUILD
+  COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/plugin/build.sh
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/plugin)
+
+target_link_libraries(hyprtester PUBLIC PkgConfig::hyprtester_deps)
+
+install(TARGETS hyprtester)
+
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/test.conf
+        DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/hypr)
+
+install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/plugin/hyprtestplugin.so
+        DESTINATION ${CMAKE_INSTALL_PREFIX}/lib)
+
+file(WRITE ${CMAKE_CURRENT_SOURCE_DIR}/src/tests/clients/build.hpp
+  "#include <string>\n"
+  "static const std::string binaryDir = \"${CMAKE_CURRENT_BINARY_DIR}\";"
+)
+
+######## wayland protocols testing stuff
+
+if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG)
+  set(CMAKE_EXECUTABLE_ENABLE_EXPORTS TRUE)
+endif()
+
+find_package(hyprwayland-scanner 0.4.0 REQUIRED)
+pkg_check_modules(
+  protocols_deps
+  REQUIRED
+  IMPORTED_TARGET
+  hyprutils>=0.8.0
+  wayland-client
+  wayland-protocols
+)
+
+pkg_get_variable(WAYLAND_PROTOCOLS_DIR wayland-protocols pkgdatadir)
+message(STATUS "Found wayland-protocols at ${WAYLAND_PROTOCOLS_DIR}")
+pkg_get_variable(WAYLAND_SCANNER_PKGDATA_DIR wayland-scanner pkgdatadir)
+message(STATUS "Found wayland-scanner pkgdatadir at ${WAYLAND_SCANNER_PKGDATA_DIR}")
+
+# gen core wayland stuff
+add_custom_command(
+  OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/protocols/wayland.cpp
+         ${CMAKE_CURRENT_SOURCE_DIR}/protocols/wayland.hpp
+  COMMAND hyprwayland-scanner --wayland-enums --client
+          ${WAYLAND_SCANNER_PKGDATA_DIR}/wayland.xml ${CMAKE_CURRENT_SOURCE_DIR}/protocols/
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+
+function(protocolNew protoPath protoName external)
+  if(external)
+    set(path ${CMAKE_CURRENT_SOURCE_DIR}/${protoPath})
+  else()
+    set(path ${WAYLAND_PROTOCOLS_DIR}/${protoPath})
+  endif()
+
+  add_custom_command(
+    OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/protocols/${protoName}.cpp
+           ${CMAKE_CURRENT_SOURCE_DIR}/protocols/${protoName}.hpp
+    COMMAND hyprwayland-scanner --client ${path}/${protoName}.xml
+            ${CMAKE_CURRENT_SOURCE_DIR}/protocols/
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+endfunction()
+function(clientNew sourceName)
+  cmake_parse_arguments(PARSE_ARGV 1 ARG "" "" "PROTOS")
+
+  add_executable(${sourceName} clients/${sourceName}.cpp)
+
+  target_include_directories(${sourceName} BEFORE PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/protocols")
+  target_link_libraries(${sourceName} PUBLIC PkgConfig::protocols_deps)
+
+  target_sources(${sourceName} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/protocols/wayland.cpp ${CMAKE_CURRENT_SOURCE_DIR}/protocols/wayland.hpp)
+
+  foreach(protoName IN LISTS ARG_PROTOS)
+    target_sources(${sourceName} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/protocols/${protoName}.cpp
+                                         ${CMAKE_CURRENT_SOURCE_DIR}/protocols/${protoName}.hpp)
+  endforeach()
+endfunction()
+
+protocolnew("staging/pointer-warp" "pointer-warp-v1" false)
+protocolnew("stable/xdg-shell" "xdg-shell" false)
+
+clientNew("pointer-warp" PROTOS "pointer-warp-v1" "xdg-shell")
+clientNew("pointer-scroll" PROTOS "xdg-shell")

hyprtester/clients/pointer-scroll.cpp

@@ -0,0 +1,318 @@
+#include <cstring>
+#include <sys/poll.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <print>
+#include <format>
+#include <string>
+#include <fstream>
+
+#include <wayland-client.h>
+#include <wayland.hpp>
+#include <xdg-shell.hpp>
+#include <pointer-warp-v1.hpp>
+
+#include <hyprutils/memory/SharedPtr.hpp>
+#include <hyprutils/math/Vector2D.hpp>
+#include <hyprutils/os/FileDescriptor.hpp>
+
+using Hyprutils::Math::Vector2D;
+using namespace Hyprutils::Memory;
+
+struct SWlState {
+    wl_display*                  display;
+    CSharedPointer<CCWlRegistry> registry;
+
+    // protocols
+    CSharedPointer<CCWlCompositor> wlCompositor;
+    CSharedPointer<CCWlSeat>       wlSeat;
+    CSharedPointer<CCWlShm>        wlShm;
+    CSharedPointer<CCXdgWmBase>    xdgShell;
+
+    // shm/buffer stuff
+    CSharedPointer<CCWlShmPool> shmPool;
+    CSharedPointer<CCWlBuffer>  shmBuf;
+    int                         shmFd;
+    size_t                      shmBufSize;
+    bool                        xrgb8888_support = false;
+
+    // surface/toplevel stuff
+    CSharedPointer<CCWlSurface>   surf;
+    CSharedPointer<CCXdgSurface>  xdgSurf;
+    CSharedPointer<CCXdgToplevel> xdgToplevel;
+    Vector2D                      geom;
+
+    // pointer
+    CSharedPointer<CCWlPointer> pointer;
+    uint32_t                    enterSerial;
+
+    // last delta
+    float lastScrollDelta = -1.F;
+    bool  writeDelta      = false;
+};
+
+static std::ofstream logfile;
+
+static bool          debug, started, shouldExit;
+
+template <typename... Args>
+//NOLINTNEXTLINE
+static void clientLog(std::format_string<Args...> fmt, Args&&... args) {
+    std::string text = std::vformat(fmt.get(), std::make_format_args(args...));
+    std::println("{}", text);
+    logfile << text << std::endl;
+    std::fflush(stdout);
+}
+
+template <typename... Args>
+//NOLINTNEXTLINE
+static void debugLog(std::format_string<Args...> fmt, Args&&... args) {
+    std::string text = std::vformat(fmt.get(), std::make_format_args(args...));
+    logfile << text << std::endl;
+    if (!debug)
+        return;
+    std::println("{}", text);
+    std::fflush(stdout);
+}
+
+static bool bindRegistry(SWlState& state) {
+    state.registry = makeShared<CCWlRegistry>((wl_proxy*)wl_display_get_registry(state.display));
+
+    state.registry->setGlobal([&](CCWlRegistry* r, uint32_t id, const char* name, uint32_t version) {
+        const std::string NAME = name;
+        if (NAME == "wl_compositor") {
+            debugLog("  > binding to global: {} (version {}) with id {}", name, version, id);
+            state.wlCompositor = makeShared<CCWlCompositor>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &wl_compositor_interface, 6));
+        } else if (NAME == "wl_shm") {
+            debugLog("  > binding to global: {} (version {}) with id {}", name, version, id);
+            state.wlShm = makeShared<CCWlShm>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &wl_shm_interface, 1));
+        } else if (NAME == "wl_seat") {
+            debugLog("  > binding to global: {} (version {}) with id {}", name, version, id);
+            state.wlSeat = makeShared<CCWlSeat>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &wl_seat_interface, 9));
+        } else if (NAME == "xdg_wm_base") {
+            debugLog("  > binding to global: {} (version {}) with id {}", name, version, id);
+            state.xdgShell = makeShared<CCXdgWmBase>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &xdg_wm_base_interface, 1));
+        }
+    });
+    state.registry->setGlobalRemove([](CCWlRegistry* r, uint32_t id) { debugLog("Global {} removed", id); });
+
+    wl_display_roundtrip(state.display);
+
+    if (!state.wlCompositor || !state.wlShm || !state.wlSeat || !state.xdgShell) {
+        clientLog("Failed to get protocols from Hyprland");
+        return false;
+    }
+
+    return true;
+}
+
+static bool createShm(SWlState& state, Vector2D geom) {
+    if (!state.xrgb8888_support)
+        return false;
+
+    size_t stride = geom.x * 4;
+    size_t size   = geom.y * stride;
+    if (!state.shmPool) {
+        const char* name = "/wl-shm-pointer-scroll";
+        state.shmFd      = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
+        if (state.shmFd < 0)
+            return false;
+
+        if (shm_unlink(name) < 0 || ftruncate(state.shmFd, size) < 0) {
+            close(state.shmFd);
+            return false;
+        }
+
+        state.shmPool = makeShared<CCWlShmPool>(state.wlShm->sendCreatePool(state.shmFd, size));
+        if (!state.shmPool->resource()) {
+            close(state.shmFd);
+            state.shmFd = -1;
+            state.shmPool.reset();
+            return false;
+        }
+        state.shmBufSize = size;
+    } else if (size > state.shmBufSize) {
+        if (ftruncate(state.shmFd, size) < 0) {
+            close(state.shmFd);
+            state.shmFd = -1;
+            state.shmPool.reset();
+            return false;
+        }
+
+        state.shmPool->sendResize(size);
+        state.shmBufSize = size;
+    }
+
+    auto buf = makeShared<CCWlBuffer>(state.shmPool->sendCreateBuffer(0, geom.x, geom.y, stride, WL_SHM_FORMAT_XRGB8888));
+    if (!buf->resource())
+        return false;
+
+    if (state.shmBuf) {
+        state.shmBuf->sendDestroy();
+        state.shmBuf.reset();
+    }
+
+    state.shmBuf = buf;
+
+    return true;
+}
+
+static bool setupToplevel(SWlState& state) {
+    state.wlShm->setFormat([&](CCWlShm* p, uint32_t format) {
+        if (format == WL_SHM_FORMAT_XRGB8888)
+            state.xrgb8888_support = true;
+    });
+
+    state.xdgShell->setPing([&](CCXdgWmBase* p, uint32_t serial) { state.xdgShell->sendPong(serial); });
+
+    state.surf = makeShared<CCWlSurface>(state.wlCompositor->sendCreateSurface());
+    if (!state.surf->resource())
+        return false;
+
+    state.xdgSurf = makeShared<CCXdgSurface>(state.xdgShell->sendGetXdgSurface(state.surf->resource()));
+    if (!state.xdgSurf->resource())
+        return false;
+
+    state.xdgToplevel = makeShared<CCXdgToplevel>(state.xdgSurf->sendGetToplevel());
+    if (!state.xdgToplevel->resource())
+        return false;
+
+    state.xdgToplevel->setClose([&](CCXdgToplevel* p) { exit(0); });
+
+    state.xdgToplevel->setConfigure([&](CCXdgToplevel* p, int32_t w, int32_t h, wl_array* arr) {
+        state.geom = {1280, 720};
+
+        if (!createShm(state, state.geom))
+            exit(-1);
+    });
+
+    state.xdgSurf->setConfigure([&](CCXdgSurface* p, uint32_t serial) {
+        if (!state.shmBuf)
+            debugLog("xdgSurf configure but no buf made yet?");
+
+        state.xdgSurf->sendSetWindowGeometry(0, 0, state.geom.x, state.geom.y);
+        state.surf->sendAttach(state.shmBuf.get(), 0, 0);
+        state.surf->sendCommit();
+
+        state.xdgSurf->sendAckConfigure(serial);
+
+        if (!started) {
+            started = true;
+            clientLog("started");
+        }
+    });
+
+    state.xdgToplevel->sendSetTitle("pointer-scroll test client");
+    state.xdgToplevel->sendSetAppId("pointer-scroll");
+
+    state.surf->sendAttach(nullptr, 0, 0);
+    state.surf->sendCommit();
+
+    return true;
+}
+
+static bool setupSeat(SWlState& state) {
+    state.pointer = makeShared<CCWlPointer>(state.wlSeat->sendGetPointer());
+    if (!state.pointer->resource())
+        return false;
+
+    state.pointer->setEnter([&](CCWlPointer* p, uint32_t serial, wl_proxy* surf, wl_fixed_t x, wl_fixed_t y) {
+        debugLog("Got pointer enter event, serial {}, x {}, y {}", serial, x, y);
+        state.enterSerial = serial;
+    });
+
+    state.pointer->setAxis([&](CCWlPointer* p, uint32_t time, wl_pointer_axis axis, wl_fixed_t delta) {
+        debugLog("axis: ax {} delta {}", (int)axis, wl_fixed_to_double(delta));
+
+        if (state.writeDelta) {
+            clientLog("{:.2f}", wl_fixed_to_double(delta));
+            state.writeDelta      = false;
+            state.lastScrollDelta = -1;
+            return;
+        }
+
+        state.lastScrollDelta = wl_fixed_to_double(delta);
+        state.writeDelta      = true;
+    });
+
+    state.pointer->setLeave([&](CCWlPointer* p, uint32_t serial, wl_proxy* surf) { debugLog("Got pointer leave event, serial {}", serial); });
+
+    state.pointer->setMotion([&](CCWlPointer* p, uint32_t serial, wl_fixed_t x, wl_fixed_t y) { debugLog("Got pointer motion event, serial {}, x {}, y {}", serial, x, y); });
+
+    return true;
+}
+
+// return last delta after axis
+static void parseRequest(SWlState& state, std::string req) {
+    if (!state.writeDelta) {
+        state.writeDelta = true;
+        return;
+    }
+
+    clientLog("{:.2f}", state.lastScrollDelta);
+    state.writeDelta      = false;
+    state.lastScrollDelta = -1;
+}
+
+int main(int argc, char** argv) {
+    logfile.open("pointer-scroll.txt", std::ios::trunc);
+
+    if (argc != 1 && argc != 2)
+        clientLog("Only the \"--debug\" switch is allowed, it turns on debug logs.");
+
+    if (argc == 2 && std::string{argv[1]} == "--debug")
+        debug = true;
+
+    SWlState state;
+
+    // WAYLAND_DISPLAY env should be set to the correct one
+    state.display = wl_display_connect(nullptr);
+    if (!state.display) {
+        clientLog("Failed to connect to wayland display");
+        return -1;
+    }
+
+    if (!bindRegistry(state) || !setupSeat(state) || !setupToplevel(state))
+        return -1;
+
+    std::array<char, 1024> readBuf;
+    readBuf.fill(0);
+
+    wl_display_flush(state.display);
+
+    struct pollfd fds[2] = {{.fd = wl_display_get_fd(state.display), .events = POLLIN | POLLOUT}, {.fd = STDIN_FILENO, .events = POLLIN}};
+    while (!shouldExit && poll(fds, 2, 0) != -1) {
+        if (fds[0].revents & POLLIN) {
+            wl_display_flush(state.display);
+
+            if (wl_display_prepare_read(state.display) == 0) {
+                wl_display_read_events(state.display);
+                wl_display_dispatch_pending(state.display);
+            } else
+                wl_display_dispatch(state.display);
+
+            int ret = 0;
+            do {
+                ret = wl_display_dispatch_pending(state.display);
+                wl_display_flush(state.display);
+            } while (ret > 0);
+        }
+
+        if (fds[1].revents & POLLIN) {
+            ssize_t bytesRead = read(fds[1].fd, readBuf.data(), 1023);
+            if (bytesRead == -1)
+                continue;
+            readBuf[bytesRead] = 0;
+
+            parseRequest(state, std::string{readBuf.data()});
+        }
+    }
+
+    wl_display* display = state.display;
+    state               = {};
+
+    wl_display_disconnect(display);
+    logfile.flush();
+    logfile.close();
+    return 0;
+}

hyprtester/clients/pointer-warp.cpp

@@ -0,0 +1,317 @@
+#include <cstring>
+#include <sys/poll.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <print>
+#include <format>
+#include <string>
+
+#include <wayland-client.h>
+#include <wayland.hpp>
+#include <xdg-shell.hpp>
+#include <pointer-warp-v1.hpp>
+
+#include <hyprutils/memory/SharedPtr.hpp>
+#include <hyprutils/math/Vector2D.hpp>
+#include <hyprutils/os/FileDescriptor.hpp>
+
+using Hyprutils::Math::Vector2D;
+using namespace Hyprutils::Memory;
+
+struct SWlState {
+    wl_display*                  display;
+    CSharedPointer<CCWlRegistry> registry;
+
+    // protocols
+    CSharedPointer<CCWlCompositor>    wlCompositor;
+    CSharedPointer<CCWlSeat>          wlSeat;
+    CSharedPointer<CCWlShm>           wlShm;
+    CSharedPointer<CCXdgWmBase>       xdgShell;
+    CSharedPointer<CCWpPointerWarpV1> pointerWarp;
+
+    // shm/buffer stuff
+    CSharedPointer<CCWlShmPool> shmPool;
+    CSharedPointer<CCWlBuffer>  shmBuf;
+    int                         shmFd;
+    size_t                      shmBufSize;
+    bool                        xrgb8888_support = false;
+
+    // surface/toplevel stuff
+    CSharedPointer<CCWlSurface>   surf;
+    CSharedPointer<CCXdgSurface>  xdgSurf;
+    CSharedPointer<CCXdgToplevel> xdgToplevel;
+    Vector2D                      geom;
+
+    // pointer
+    CSharedPointer<CCWlPointer> pointer;
+    uint32_t                    enterSerial;
+};
+
+static bool debug, started, shouldExit;
+
+template <typename... Args>
+//NOLINTNEXTLINE
+static void clientLog(std::format_string<Args...> fmt, Args&&... args) {
+    std::println("{}", std::vformat(fmt.get(), std::make_format_args(args...)));
+    std::fflush(stdout);
+}
+
+template <typename... Args>
+//NOLINTNEXTLINE
+static void debugLog(std::format_string<Args...> fmt, Args&&... args) {
+    if (!debug)
+        return;
+    std::println("{}", std::vformat(fmt.get(), std::make_format_args(args...)));
+    std::fflush(stdout);
+}
+
+static bool bindRegistry(SWlState& state) {
+    state.registry = makeShared<CCWlRegistry>((wl_proxy*)wl_display_get_registry(state.display));
+
+    state.registry->setGlobal([&](CCWlRegistry* r, uint32_t id, const char* name, uint32_t version) {
+        const std::string NAME = name;
+        if (NAME == "wl_compositor") {
+            debugLog("  > binding to global: {} (version {}) with id {}", name, version, id);
+            state.wlCompositor = makeShared<CCWlCompositor>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &wl_compositor_interface, 6));
+        } else if (NAME == "wl_shm") {
+            debugLog("  > binding to global: {} (version {}) with id {}", name, version, id);
+            state.wlShm = makeShared<CCWlShm>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &wl_shm_interface, 1));
+        } else if (NAME == "wl_seat") {
+            debugLog("  > binding to global: {} (version {}) with id {}", name, version, id);
+            state.wlSeat = makeShared<CCWlSeat>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &wl_seat_interface, 9));
+        } else if (NAME == "xdg_wm_base") {
+            debugLog("  > binding to global: {} (version {}) with id {}", name, version, id);
+            state.xdgShell = makeShared<CCXdgWmBase>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &xdg_wm_base_interface, 1));
+        } else if (NAME == "wp_pointer_warp_v1") {
+            debugLog("  > binding to global: {} (version {}) with id {}", name, version, id);
+            state.pointerWarp = makeShared<CCWpPointerWarpV1>((wl_proxy*)wl_registry_bind((wl_registry*)state.registry->resource(), id, &wp_pointer_warp_v1_interface, 1));
+        }
+    });
+    state.registry->setGlobalRemove([](CCWlRegistry* r, uint32_t id) { debugLog("Global {} removed", id); });
+
+    wl_display_roundtrip(state.display);
+
+    if (!state.wlCompositor || !state.wlShm || !state.wlSeat || !state.xdgShell || !state.pointerWarp) {
+        clientLog("Failed to get protocols from Hyprland");
+        return false;
+    }
+
+    return true;
+}
+
+static bool createShm(SWlState& state, Vector2D geom) {
+    if (!state.xrgb8888_support)
+        return false;
+
+    size_t stride = geom.x * 4;
+    size_t size   = geom.y * stride;
+    if (!state.shmPool) {
+        const char* name = "/wl-shm-pointer-warp";
+        state.shmFd      = shm_open(name, O_RDWR | O_CREAT | O_EXCL, 0600);
+        if (state.shmFd < 0)
+            return false;
+
+        if (shm_unlink(name) < 0 || ftruncate(state.shmFd, size) < 0) {
+            close(state.shmFd);
+            return false;
+        }
+
+        state.shmPool = makeShared<CCWlShmPool>(state.wlShm->sendCreatePool(state.shmFd, size));
+        if (!state.shmPool->resource()) {
+            close(state.shmFd);
+            state.shmFd = -1;
+            state.shmPool.reset();
+            return false;
+        }
+        state.shmBufSize = size;
+    } else if (size > state.shmBufSize) {
+        if (ftruncate(state.shmFd, size) < 0) {
+            close(state.shmFd);
+            state.shmFd = -1;
+            state.shmPool.reset();
+            return false;
+        }
+
+        state.shmPool->sendResize(size);
+        state.shmBufSize = size;
+    }
+
+    auto buf = makeShared<CCWlBuffer>(state.shmPool->sendCreateBuffer(0, geom.x, geom.y, stride, WL_SHM_FORMAT_XRGB8888));
+    if (!buf->resource())
+        return false;
+
+    if (state.shmBuf) {
+        state.shmBuf->sendDestroy();
+        state.shmBuf.reset();
+    }
+
+    state.shmBuf = buf;
+
+    return true;
+}
+
+static bool setupToplevel(SWlState& state) {
+    state.wlShm->setFormat([&](CCWlShm* p, uint32_t format) {
+        if (format == WL_SHM_FORMAT_XRGB8888)
+            state.xrgb8888_support = true;
+    });
+
+    state.xdgShell->setPing([&](CCXdgWmBase* p, uint32_t serial) { state.xdgShell->sendPong(serial); });
+
+    state.surf = makeShared<CCWlSurface>(state.wlCompositor->sendCreateSurface());
+    if (!state.surf->resource())
+        return false;
+
+    state.xdgSurf = makeShared<CCXdgSurface>(state.xdgShell->sendGetXdgSurface(state.surf->resource()));
+    if (!state.xdgSurf->resource())
+        return false;
+
+    state.xdgToplevel = makeShared<CCXdgToplevel>(state.xdgSurf->sendGetToplevel());
+    if (!state.xdgToplevel->resource())
+        return false;
+
+    state.xdgToplevel->setClose([&](CCXdgToplevel* p) { exit(0); });
+
+    state.xdgToplevel->setConfigure([&](CCXdgToplevel* p, int32_t w, int32_t h, wl_array* arr) {
+        state.geom = {1280, 720};
+
+        if (!createShm(state, state.geom))
+            exit(-1);
+    });
+
+    state.xdgSurf->setConfigure([&](CCXdgSurface* p, uint32_t serial) {
+        if (!state.shmBuf)
+            debugLog("xdgSurf configure but no buf made yet?");
+
+        state.xdgSurf->sendSetWindowGeometry(0, 0, state.geom.x, state.geom.y);
+        state.surf->sendAttach(state.shmBuf.get(), 0, 0);
+        state.surf->sendCommit();
+
+        state.xdgSurf->sendAckConfigure(serial);
+
+        if (!started) {
+            started = true;
+            clientLog("started");
+        }
+    });
+
+    state.xdgToplevel->sendSetTitle("pointer-warp test client");
+    state.xdgToplevel->sendSetAppId("pointer-warp");
+
+    state.surf->sendAttach(nullptr, 0, 0);
+    state.surf->sendCommit();
+
+    return true;
+}
+
+static bool setupSeat(SWlState& state) {
+    state.pointer = makeShared<CCWlPointer>(state.wlSeat->sendGetPointer());
+    if (!state.pointer->resource())
+        return false;
+
+    state.pointer->setEnter([&](CCWlPointer* p, uint32_t serial, wl_proxy* surf, wl_fixed_t x, wl_fixed_t y) {
+        debugLog("Got pointer enter event, serial {}, x {}, y {}", serial, x, y);
+        state.enterSerial = serial;
+    });
+
+    state.pointer->setLeave([&](CCWlPointer* p, uint32_t serial, wl_proxy* surf) { debugLog("Got pointer leave event, serial {}", serial); });
+
+    state.pointer->setMotion([&](CCWlPointer* p, uint32_t serial, wl_fixed_t x, wl_fixed_t y) { debugLog("Got pointer motion event, serial {}, x {}, y {}", serial, x, y); });
+
+    return true;
+}
+
+// format is like below
+// "warp 20 20\n" would ask to warp cursor to x=20,y=20 in surface local coords
+static void parseRequest(SWlState& state, std::string req) {
+    if (req.contains("exit")) {
+        shouldExit = true;
+        return;
+    }
+
+    if (!req.starts_with("warp "))
+        return;
+
+    auto it = req.find_first_of('\n');
+    if (it == std::string::npos)
+        return;
+
+    req = req.substr(0, it);
+
+    it = req.find_first_of(' ');
+    if (it == std::string::npos)
+        return;
+
+    req = req.substr(it + 1);
+
+    it = req.find_first_of(' ');
+
+    int x = std::stoi(req.substr(0, it));
+    int y = std::stoi(req.substr(it + 1));
+
+    state.pointerWarp->sendWarpPointer(state.surf->resource(), state.pointer->resource(), wl_fixed_from_int(x), wl_fixed_from_int(y), state.enterSerial);
+
+    // sync the request then reply
+    wl_display_roundtrip(state.display);
+
+    clientLog("parsed request to move to x:{}, y:{}", x, y);
+}
+
+int main(int argc, char** argv) {
+    if (argc != 1 && argc != 2)
+        clientLog("Only the \"--debug\" switch is allowed, it turns on debug logs.");
+
+    if (argc == 2 && std::string{argv[1]} == "--debug")
+        debug = true;
+
+    SWlState state;
+
+    // WAYLAND_DISPLAY env should be set to the correct one
+    state.display = wl_display_connect(nullptr);
+    if (!state.display) {
+        clientLog("Failed to connect to wayland display");
+        return -1;
+    }
+
+    if (!bindRegistry(state) || !setupSeat(state) || !setupToplevel(state))
+        return -1;
+
+    std::array<char, 1024> readBuf;
+    readBuf.fill(0);
+
+    wl_display_flush(state.display);
+
+    struct pollfd fds[2] = {{.fd = wl_display_get_fd(state.display), .events = POLLIN | POLLOUT}, {.fd = STDIN_FILENO, .events = POLLIN}};
+    while (!shouldExit && poll(fds, 2, 0) != -1) {
+        if (fds[0].revents & POLLIN) {
+            wl_display_flush(state.display);
+
+            if (wl_display_prepare_read(state.display) == 0) {
+                wl_display_read_events(state.display);
+                wl_display_dispatch_pending(state.display);
+            } else
+                wl_display_dispatch(state.display);
+
+            int ret = 0;
+            do {
+                ret = wl_display_dispatch_pending(state.display);
+                wl_display_flush(state.display);
+            } while (ret > 0);
+        }
+
+        if (fds[1].revents & POLLIN) {
+            ssize_t bytesRead = read(fds[1].fd, readBuf.data(), 1023);
+            if (bytesRead == -1)
+                continue;
+            readBuf[bytesRead] = 0;
+
+            parseRequest(state, std::string{readBuf.data()});
+        }
+    }
+
+    wl_display* display = state.display;
+    state               = {};
+
+    wl_display_disconnect(display);
+    return 0;
+}

hyprtester/plugin/Makefile

@@ -0,0 +1,16 @@
+CXXFLAGS = -shared -fPIC -g -std=c++2b -Wno-c++11-narrowing
+INCLUDES = `pkg-config --cflags pixman-1 libdrm pangocairo libinput libudev wayland-server xkbcommon`
+LIBS = `pkg-config --libs pangocairo`
+
+SRC = src/main.cpp
+TARGET = hyprtestplugin.so
+
+all: $(TARGET)
+
+$(TARGET): $(SRC)
+	$(CXX) $(CXXFLAGS) -I../.. -I../../protocols $(INCLUDES) $^ $> -o $@ $(LIBS) -O2
+
+clean:
+	rm -f ./$(TARGET)
+
+.PHONY: all clean

hyprtester/plugin/build.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+make clean
+make all

hyprtester/plugin/src/globals.hpp

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <src/plugins/PluginAPI.hpp>
+
+inline HANDLE PHANDLE = nullptr;

hyprtester/plugin/src/main.cpp

@@ -0,0 +1,306 @@
+#include <unistd.h>
+#include <src/includes.hpp>
+#include <sstream>
+#include <any>
+
+#define private public
+#include <src/config/ConfigManager.hpp>
+#include <src/config/ConfigDescriptions.hpp>
+#include <src/layout/IHyprLayout.hpp>
+#include <src/managers/LayoutManager.hpp>
+#include <src/managers/input/InputManager.hpp>
+#include <src/managers/PointerManager.hpp>
+#include <src/managers/input/trackpad/TrackpadGestures.hpp>
+#include <src/desktop/rule/windowRule/WindowRuleEffectContainer.hpp>
+#include <src/desktop/rule/windowRule/WindowRuleApplicator.hpp>
+#include <src/Compositor.hpp>
+#include <src/desktop/state/FocusState.hpp>
+#undef private
+
+#include <hyprutils/utils/ScopeGuard.hpp>
+#include <hyprutils/string/VarList.hpp>
+using namespace Hyprutils::Utils;
+using namespace Hyprutils::String;
+
+#include "globals.hpp"
+
+// Do NOT change this function.
+APICALL EXPORT std::string PLUGIN_API_VERSION() {
+    return HYPRLAND_API_VERSION;
+}
+
+static SDispatchResult test(std::string in) {
+    bool        success = true;
+    std::string errors  = "";
+
+    if (g_pConfigManager->m_configValueNumber != CONFIG_OPTIONS.size() + 1 /* autogenerated is special */) {
+        errors += "config value number mismatches descriptions size\n";
+        success = false;
+    }
+
+    return SDispatchResult{
+        .success = success,
+        .error   = errors,
+    };
+}
+
+// Trigger a snap move event for the active window
+static SDispatchResult snapMove(std::string in) {
+    const auto PLASTWINDOW = Desktop::focusState()->window();
+    if (!PLASTWINDOW->m_isFloating)
+        return {.success = false, .error = "Window must be floating"};
+
+    Vector2D pos  = PLASTWINDOW->m_realPosition->goal();
+    Vector2D size = PLASTWINDOW->m_realSize->goal();
+
+    g_pLayoutManager->getCurrentLayout()->performSnap(pos, size, PLASTWINDOW, MBIND_MOVE, -1, size);
+    *PLASTWINDOW->m_realPosition = pos.round();
+
+    return {};
+}
+
+class CTestKeyboard : public IKeyboard {
+  public:
+    static SP<CTestKeyboard> create(bool isVirtual) {
+        auto keeb           = SP<CTestKeyboard>(new CTestKeyboard());
+        keeb->m_self        = keeb;
+        keeb->m_isVirtual   = isVirtual;
+        keeb->m_shareStates = !isVirtual;
+        return keeb;
+    }
+
+    virtual bool isVirtual() {
+        return m_isVirtual;
+    }
+
+    virtual SP<Aquamarine::IKeyboard> aq() {
+        return nullptr;
+    }
+
+    void sendKey(uint32_t key, bool pressed) {
+        auto event = IKeyboard::SKeyEvent{
+            .timeMs  = sc<uint32_t>(Time::millis(Time::steadyNow())),
+            .keycode = key,
+            .state   = pressed ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED,
+        };
+        updatePressed(event.keycode, pressed);
+        m_keyboardEvents.key.emit(event);
+    }
+
+    void destroy() {
+        m_events.destroy.emit();
+    }
+
+  private:
+    bool m_isVirtual = false;
+};
+
+class CTestMouse : public IPointer {
+  public:
+    static SP<CTestMouse> create(bool isVirtual) {
+        auto maus          = SP<CTestMouse>(new CTestMouse());
+        maus->m_self       = maus;
+        maus->m_isVirtual  = isVirtual;
+        maus->m_deviceName = "test-mouse";
+        maus->m_hlName     = "test-mouse";
+        return maus;
+    }
+
+    virtual bool isVirtual() {
+        return m_isVirtual;
+    }
+
+    virtual SP<Aquamarine::IPointer> aq() {
+        return nullptr;
+    }
+
+    void destroy() {
+        m_events.destroy.emit();
+    }
+
+  private:
+    bool m_isVirtual = false;
+};
+
+SP<CTestMouse>         g_mouse;
+SP<CTestKeyboard>      g_keyboard;
+
+static SDispatchResult pressAlt(std::string in) {
+    g_pInputManager->m_lastMods = in == "1" ? HL_MODIFIER_ALT : 0;
+
+    return {.success = true};
+}
+
+static SDispatchResult simulateGesture(std::string in) {
+    CVarList data(in);
+
+    uint32_t fingers = 3;
+    try {
+        fingers = std::stoul(data[1]);
+    } catch (...) { return {.success = false}; }
+
+    if (data[0] == "down") {
+        g_pTrackpadGestures->gestureBegin(IPointer::SSwipeBeginEvent{});
+        g_pTrackpadGestures->gestureUpdate(IPointer::SSwipeUpdateEvent{.fingers = fingers, .delta = {0, 300}});
+        g_pTrackpadGestures->gestureEnd(IPointer::SSwipeEndEvent{});
+    } else if (data[0] == "up") {
+        g_pTrackpadGestures->gestureBegin(IPointer::SSwipeBeginEvent{});
+        g_pTrackpadGestures->gestureUpdate(IPointer::SSwipeUpdateEvent{.fingers = fingers, .delta = {0, -300}});
+        g_pTrackpadGestures->gestureEnd(IPointer::SSwipeEndEvent{});
+    } else if (data[0] == "left") {
+        g_pTrackpadGestures->gestureBegin(IPointer::SSwipeBeginEvent{});
+        g_pTrackpadGestures->gestureUpdate(IPointer::SSwipeUpdateEvent{.fingers = fingers, .delta = {-300, 0}});
+        g_pTrackpadGestures->gestureEnd(IPointer::SSwipeEndEvent{});
+    } else {
+        g_pTrackpadGestures->gestureBegin(IPointer::SSwipeBeginEvent{});
+        g_pTrackpadGestures->gestureUpdate(IPointer::SSwipeUpdateEvent{.fingers = fingers, .delta = {300, 0}});
+        g_pTrackpadGestures->gestureEnd(IPointer::SSwipeEndEvent{});
+    }
+
+    return {.success = true};
+}
+
+static SDispatchResult vkb(std::string in) {
+    auto tkb0 = CTestKeyboard::create(false);
+    auto tkb1 = CTestKeyboard::create(false);
+    auto vkb0 = CTestKeyboard::create(true);
+
+    g_pInputManager->newKeyboard(tkb0);
+    g_pInputManager->newKeyboard(tkb1);
+    g_pInputManager->newKeyboard(vkb0);
+
+    CScopeGuard    x([&] {
+        tkb0->destroy();
+        tkb1->destroy();
+        vkb0->destroy();
+    });
+
+    const auto&    PRESSED = g_pInputManager->getKeysFromAllKBs();
+    const uint32_t TESTKEY = 1;
+
+    tkb0->sendKey(TESTKEY, true);
+    if (!std::ranges::contains(PRESSED, TESTKEY)) {
+        return {
+            .success = false,
+            .error   = "Expected pressed key not found",
+        };
+    }
+
+    tkb1->sendKey(TESTKEY, true);
+    tkb0->sendKey(TESTKEY, false);
+    if (!std::ranges::contains(PRESSED, TESTKEY)) {
+        return {
+            .success = false,
+            .error   = "Expected pressed key not found (kb share state)",
+        };
+    }
+
+    vkb0->sendKey(TESTKEY, true);
+    tkb1->sendKey(TESTKEY, false);
+    if (std::ranges::contains(PRESSED, TESTKEY)) {
+        return {
+            .success = false,
+            .error   = "Expected released key found in pressed (vkb no share state)",
+        };
+    }
+
+    return {};
+}
+
+static SDispatchResult scroll(std::string in) {
+    double by;
+    try {
+        by = std::stod(in);
+    } catch (...) { return SDispatchResult{.success = false, .error = "invalid input"}; }
+
+    Log::logger->log(Log::DEBUG, "tester: scrolling by {}", by);
+
+    g_mouse->m_pointerEvents.axis.emit(IPointer::SAxisEvent{
+        .delta         = by,
+        .deltaDiscrete = 120,
+        .mouse         = true,
+    });
+
+    return {};
+}
+
+static SDispatchResult keybind(std::string in) {
+    CVarList2 data(std::move(in));
+    // 0 = release, 1 = press
+    bool press;
+    // See src/devices/IKeyboard.hpp : eKeyboardModifiers for modifier bitmasks
+    // 0 = none, eKeyboardModifiers is shifted to start at 1
+    uint32_t modifier;
+    // keycode
+    uint32_t key;
+    try {
+        press    = std::stoul(std::string{data[0]}) == 1;
+        modifier = std::stoul(std::string{data[1]});
+        key      = std::stoul(std::string{data[2]}) - 8; // xkb offset
+    } catch (...) { return {.success = false, .error = "invalid input"}; }
+
+    uint32_t modifierMask = 0;
+    if (modifier > 0)
+        modifierMask = 1 << (modifier - 1);
+    g_pInputManager->m_lastMods = modifierMask;
+    g_keyboard->sendKey(key, press);
+
+    return {};
+}
+
+static Desktop::Rule::CWindowRuleEffectContainer::storageType ruleIDX = 0;
+
+//
+static SDispatchResult addRule(std::string in) {
+    ruleIDX = Desktop::Rule::windowEffects()->registerEffect("plugin_rule");
+
+    if (Desktop::Rule::windowEffects()->registerEffect("plugin_rule") != ruleIDX)
+        return {.success = false, .error = "re-registering returned a different id?"};
+    return {};
+}
+
+static SDispatchResult checkRule(std::string in) {
+    const auto PLASTWINDOW = Desktop::focusState()->window();
+
+    if (!PLASTWINDOW)
+        return {.success = false, .error = "No window"};
+
+    if (!PLASTWINDOW->m_ruleApplicator->m_otherProps.props.contains(ruleIDX))
+        return {.success = false, .error = "No rule"};
+
+    if (PLASTWINDOW->m_ruleApplicator->m_otherProps.props[ruleIDX]->effect != "effect")
+        return {.success = false, .error = "Effect isn't \"effect\""};
+
+    return {};
+}
+
+APICALL EXPORT PLUGIN_DESCRIPTION_INFO PLUGIN_INIT(HANDLE handle) {
+    PHANDLE = handle;
+
+    HyprlandAPI::addDispatcherV2(PHANDLE, "plugin:test:test", ::test);
+    HyprlandAPI::addDispatcherV2(PHANDLE, "plugin:test:snapmove", ::snapMove);
+    HyprlandAPI::addDispatcherV2(PHANDLE, "plugin:test:vkb", ::vkb);
+    HyprlandAPI::addDispatcherV2(PHANDLE, "plugin:test:alt", ::pressAlt);
+    HyprlandAPI::addDispatcherV2(PHANDLE, "plugin:test:gesture", ::simulateGesture);
+    HyprlandAPI::addDispatcherV2(PHANDLE, "plugin:test:scroll", ::scroll);
+    HyprlandAPI::addDispatcherV2(PHANDLE, "plugin:test:keybind", ::keybind);
+    HyprlandAPI::addDispatcherV2(PHANDLE, "plugin:test:add_rule", ::addRule);
+    HyprlandAPI::addDispatcherV2(PHANDLE, "plugin:test:check_rule", ::checkRule);
+
+    // init mouse
+    g_mouse = CTestMouse::create(false);
+    g_pInputManager->newMouse(g_mouse);
+
+    // init keyboard
+    g_keyboard = CTestKeyboard::create(false);
+    g_pInputManager->newKeyboard(g_keyboard);
+
+    return {"hyprtestplugin", "hyprtestplugin", "Vaxry", "1.0"};
+}
+
+APICALL EXPORT void PLUGIN_EXIT() {
+    g_mouse->destroy();
+    g_mouse.reset();
+    g_keyboard->destroy();
+    g_keyboard.reset();
+}

hyprtester/protocols/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

hyprtester/src/Log.hpp

@@ -0,0 +1,17 @@
+#pragma once
+#include <string>
+#include <format>
+#include <print>
+
+namespace NLog {
+    template <typename... Args>
+    //NOLINTNEXTLINE
+    void log(std::format_string<Args...> fmt, Args&&... args) {
+        std::string logMsg = "";
+
+        logMsg += std::vformat(fmt.get(), std::make_format_args(args...));
+
+        std::println("{}", logMsg);
+        std::fflush(stdout);
+    }
+}

hyprtester/src/hyprctlCompat.cpp

@@ -0,0 +1,138 @@
+#include "hyprctlCompat.hpp"
+#include "shared.hpp"
+
+#include <pwd.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include <filesystem>
+#include <fstream>
+#include <algorithm>
+#include <csignal>
+#include <cerrno>
+#include <print>
+#include <hyprutils/memory/Casts.hpp>
+using namespace Hyprutils::Memory;
+
+static int getUID() {
+    const auto UID   = getuid();
+    const auto PWUID = getpwuid(UID);
+    return PWUID ? PWUID->pw_uid : UID;
+}
+
+static std::string getRuntimeDir() {
+    const auto XDG = getenv("XDG_RUNTIME_DIR");
+
+    if (!XDG) {
+        const std::string USERID = std::to_string(getUID());
+        return "/run/user/" + USERID + "/hypr";
+    }
+
+    return std::string{XDG} + "/hypr";
+}
+
+std::vector<SInstanceData> instances() {
+    std::vector<SInstanceData> result;
+
+    try {
+        if (!std::filesystem::exists(getRuntimeDir()))
+            return {};
+    } catch (std::exception& e) { return {}; }
+
+    for (const auto& el : std::filesystem::directory_iterator(getRuntimeDir())) {
+        if (!el.is_directory() || !std::filesystem::exists(el.path().string() + "/hyprland.lock"))
+            continue;
+
+        // read lock
+        SInstanceData* data = &result.emplace_back();
+        data->id            = el.path().filename().string();
+
+        try {
+            data->time = std::stoull(data->id.substr(data->id.find_first_of('_') + 1, data->id.find_last_of('_') - (data->id.find_first_of('_') + 1)));
+        } catch (std::exception& e) { continue; }
+
+        // read file
+        std::ifstream ifs(el.path().string() + "/hyprland.lock");
+
+        int           i = 0;
+        for (std::string line; std::getline(ifs, line); ++i) {
+            if (i == 0) {
+                try {
+                    data->pid = std::stoull(line);
+                } catch (std::exception& e) { continue; }
+            } else if (i == 1) {
+                data->wlSocket = line;
+            } else
+                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;
+}
+
+std::string getFromSocket(const std::string& cmd) {
+    const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
+
+    auto       t = timeval{.tv_sec = 5, .tv_usec = 0};
+    setsockopt(SERVERSOCKET, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval));
+
+    if (SERVERSOCKET < 0) {
+        std::println("socket: Couldn't open a socket (1)");
+        return "";
+    }
+
+    sockaddr_un serverAddress = {0};
+    serverAddress.sun_family  = AF_UNIX;
+
+    std::string socketPath = getRuntimeDir() + "/" + HIS + "/.socket.sock";
+
+    strncpy(serverAddress.sun_path, socketPath.c_str(), sizeof(serverAddress.sun_path) - 1);
+
+    if (connect(SERVERSOCKET, rc<sockaddr*>(&serverAddress), SUN_LEN(&serverAddress)) < 0) {
+        std::println("Couldn't connect to {}. (3)", socketPath);
+        return "";
+    }
+
+    auto sizeWritten = write(SERVERSOCKET, cmd.c_str(), cmd.length());
+
+    if (sizeWritten < 0) {
+        std::println("Couldn't write (4)");
+        return "";
+    }
+
+    std::string reply        = "";
+    char        buffer[8192] = {0};
+
+    sizeWritten = read(SERVERSOCKET, buffer, 8192);
+
+    if (sizeWritten < 0) {
+        if (errno == EWOULDBLOCK)
+            std::println("Hyprland IPC didn't respond in time");
+        std::println("Couldn't read (5)");
+        return "";
+    }
+
+    reply += std::string(buffer, sizeWritten);
+
+    while (sizeWritten == 8192) {
+        sizeWritten = read(SERVERSOCKET, buffer, 8192);
+        if (sizeWritten < 0) {
+            std::println("Couldn't read (5)");
+            return "";
+        }
+        reply += std::string(buffer, sizeWritten);
+    }
+
+    close(SERVERSOCKET);
+
+    return reply;
+}

hyprtester/src/hyprctlCompat.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <vector>
+#include <string>
+#include <cstdint>
+
+struct SInstanceData {
+    std::string id;
+    uint64_t    time;
+    uint64_t    pid;
+    std::string wlSocket;
+    bool        valid = true;
+};
+
+std::vector<SInstanceData> instances();
+std::string                getFromSocket(const std::string& cmd);

hyprtester/src/main.cpp

@@ -0,0 +1,261 @@
+
+// This is a tester for Hyprland. It will launch the built binary in ./build/Hyprland
+// in headless mode and test various things.
+// for now it's quite basic and limited, but will be expanded in the future.
+
+// NOTE: This tester has to be ran from its directory!!
+
+// Some TODO:
+// - Add a plugin built alongside so that we can do more detailed tests (e.g. simulating keystrokes)
+// - test coverage
+// - maybe figure out a way to do some visual tests too?
+
+// Required runtime deps for checks:
+// - kitty
+// - xeyes
+
+#include "shared.hpp"
+#include "hyprctlCompat.hpp"
+#include "tests/main/tests.hpp"
+#include "tests/clients/tests.hpp"
+#include "tests/plugin/plugin.hpp"
+
+#include <filesystem>
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include <hyprutils/memory/Casts.hpp>
+using namespace Hyprutils::Memory;
+
+#include <csignal>
+#include <cerrno>
+#include <chrono>
+#include <thread>
+#include <print>
+#include <string_view>
+#include <span>
+
+#include "Log.hpp"
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+#define SP CSharedPointer
+
+static int               ret = 0;
+static SP<CProcess>      hyprlandProc;
+static const std::string cwd = std::filesystem::current_path().string();
+
+//
+static bool launchHyprland(std::string configPath, std::string binaryPath) {
+    if (binaryPath == "") {
+        std::error_code ec;
+        if (!std::filesystem::exists(cwd + "/../build/Hyprland", ec) || ec) {
+            NLog::log("{}No Hyprland binary", Colors::RED);
+            return false;
+        }
+
+        binaryPath = cwd + "/../build/Hyprland";
+    }
+
+    if (configPath == "") {
+        std::error_code ec;
+        if (!std::filesystem::exists(cwd + "/test.conf", ec) || ec) {
+            NLog::log("{}No test config", Colors::RED);
+            return false;
+        }
+
+        configPath = cwd + "/test.conf";
+    }
+
+    NLog::log("{}Launching Hyprland", Colors::YELLOW);
+    hyprlandProc = makeShared<CProcess>(binaryPath, std::vector<std::string>{"--config", configPath});
+    hyprlandProc->addEnv("HYPRLAND_HEADLESS_ONLY", "1");
+
+    NLog::log("{}Launched async process", Colors::YELLOW);
+
+    return hyprlandProc->runAsync();
+}
+
+static bool hyprlandAlive() {
+    NLog::log("{}hyprlandAlive", Colors::YELLOW);
+    kill(hyprlandProc->pid(), 0);
+    return errno != ESRCH;
+}
+
+static void help() {
+    NLog::log("usage: hyprtester [arg [...]].\n");
+    NLog::log(R"(Arguments:
+    --help              -h       - Show this message again
+    --config FILE       -c FILE  - Specify config file to use
+    --binary FILE       -b FILE  - Specify Hyprland binary to use
+    --plugin FILE       -p FILE  - Specify the location of the test plugin)");
+}
+
+int main(int argc, char** argv, char** envp) {
+
+    std::string configPath = "";
+    std::string binaryPath = "";
+    std::string pluginPath = std::filesystem::current_path().string();
+
+    if (argc > 1) {
+        std::span<char*> args{argv + 1, sc<std::size_t>(argc - 1)};
+
+        for (auto it = args.begin(); it != args.end(); it++) {
+            std::string_view value = *it;
+
+            if (value == "--config" || value == "-c") {
+                if (std::next(it) == args.end()) {
+                    help();
+
+                    return 1;
+                }
+
+                configPath = *std::next(it);
+
+                try {
+                    configPath = std::filesystem::canonical(configPath);
+
+                    if (!std::filesystem::is_regular_file(configPath)) {
+                        throw std::exception();
+                    }
+                } catch (...) {
+                    std::println(stderr, "[ ERROR ] Config file '{}' doesn't exist!", configPath);
+                    help();
+
+                    return 1;
+                }
+
+                it++;
+
+                continue;
+            } else if (value == "--binary" || value == "-b") {
+                if (std::next(it) == args.end()) {
+                    help();
+
+                    return 1;
+                }
+
+                binaryPath = *std::next(it);
+
+                try {
+                    binaryPath = std::filesystem::canonical(binaryPath);
+
+                    if (!std::filesystem::is_regular_file(binaryPath)) {
+                        throw std::exception();
+                    }
+                } catch (...) {
+                    std::println(stderr, "[ ERROR ] Binary '{}' doesn't exist!", binaryPath);
+                    help();
+
+                    return 1;
+                }
+
+                it++;
+
+                continue;
+            } else if (value == "--plugin" || value == "-p") {
+                if (std::next(it) == args.end()) {
+                    help();
+
+                    return 1;
+                }
+
+                pluginPath = *std::next(it);
+
+                try {
+                    pluginPath = std::filesystem::canonical(pluginPath);
+
+                    if (!std::filesystem::is_regular_file(pluginPath)) {
+                        throw std::exception();
+                    }
+                } catch (...) {
+                    std::println(stderr, "[ ERROR ] plugin '{}' doesn't exist!", pluginPath);
+                    help();
+
+                    return 1;
+                }
+
+                it++;
+
+                continue;
+            } else if (value == "--help" || value == "-h") {
+                help();
+
+                return 0;
+            } else {
+                std::println(stderr, "[ ERROR ] Unknown option '{}' !", *it);
+                help();
+
+                return 1;
+            }
+        }
+    }
+
+    NLog::log("{}launching hl", Colors::YELLOW);
+    if (!launchHyprland(configPath, binaryPath)) {
+        NLog::log("{}well it failed", Colors::RED);
+        return 1;
+    }
+
+    // hyprland has launched, let's check if it's alive after 10s
+    std::this_thread::sleep_for(std::chrono::milliseconds(10000));
+    NLog::log("{}slept for 10s", Colors::YELLOW);
+    if (!hyprlandAlive()) {
+        NLog::log("{}Hyprland failed to launch", Colors::RED);
+        return 1;
+    }
+
+    // wonderful, we are in. Let's get the instance signature.
+    NLog::log("{}trying to get INSTANCES", Colors::YELLOW);
+    const auto INSTANCES = instances();
+    if (INSTANCES.empty()) {
+        NLog::log("{}Hyprland failed to launch (2)", Colors::RED);
+        return 1;
+    }
+
+    HIS       = INSTANCES.back().id;
+    WLDISPLAY = INSTANCES.back().wlSocket;
+
+    NLog::log("{}trying to get create headless output", Colors::YELLOW);
+    getFromSocket("/output create headless");
+
+    NLog::log("{}trying to load plugin", Colors::YELLOW);
+    if (const auto R = getFromSocket(std::format("/plugin load {}", pluginPath)); R != "ok") {
+        NLog::log("{}Failed to load the test plugin: {}", Colors::RED, R);
+        getFromSocket("/dispatch exit 1");
+        return 1;
+    }
+
+    NLog::log("{}Loaded plugin", Colors::YELLOW);
+
+    NLog::log("{}Running main tests", Colors::YELLOW);
+
+    for (const auto& fn : testFns) {
+        EXPECT(fn(), true);
+    }
+
+    NLog::log("{}Running protocol client tests", Colors::YELLOW);
+
+    for (const auto& fn : clientTestFns) {
+        EXPECT(fn(), true);
+    }
+
+    NLog::log("{}running plugin test", Colors::YELLOW);
+    EXPECT(testPlugin(), true);
+
+    NLog::log("{}running vkb test from plugin", Colors::YELLOW);
+    EXPECT(testVkb(), true);
+
+    // kill hyprland
+    NLog::log("{}dispatching exit", Colors::YELLOW);
+    getFromSocket("/dispatch exit");
+
+    NLog::log("\n{}Summary:\n\tPASSED: {}{}{}/{}\n\tFAILED: {}{}{}/{}\n{}", Colors::RESET, Colors::GREEN, TESTS_PASSED, Colors::RESET, TESTS_PASSED + TESTS_FAILED, Colors::RED,
+              TESTS_FAILED, Colors::RESET, TESTS_PASSED + TESTS_FAILED, (TESTS_FAILED > 0 ? std::string{Colors::RED} + "\nSome tests failed.\n" : ""));
+
+    kill(hyprlandProc->pid(), SIGKILL);
+
+    hyprlandProc.reset();
+
+    return ret || TESTS_FAILED;
+}

hyprtester/src/shared.hpp

@@ -0,0 +1,101 @@
+// Stolen from hyprutils
+
+#pragma once
+#include <iostream>
+
+inline std::string HIS          = "";
+inline std::string WLDISPLAY    = "";
+inline int         TESTS_PASSED = 0;
+inline int         TESTS_FAILED = 0;
+
+namespace Colors {
+    constexpr const char* RED     = "\x1b[31m";
+    constexpr const char* GREEN   = "\x1b[32m";
+    constexpr const char* YELLOW  = "\x1b[33m";
+    constexpr const char* BLUE    = "\x1b[34m";
+    constexpr const char* MAGENTA = "\x1b[35m";
+    constexpr const char* CYAN    = "\x1b[36m";
+    constexpr const char* RESET   = "\x1b[0m";
+};
+
+#define EXPECT_MAX_DELTA(expr, desired, delta)                                                                                                                                     \
+    if (const auto RESULT = expr; std::abs(RESULT - (desired)) > delta) {                                                                                                          \
+        NLog::log("{}Failed: {}{}, expected max delta of {}, got delta {} ({} - {}). Source: {}@{}.", Colors::RED, Colors::RESET, #expr, delta, (RESULT - (desired)), RESULT,      \
+                  desired, __FILE__, __LINE__);                                                                                                                                    \
+        ret = 1;                                                                                                                                                                   \
+        TESTS_FAILED++;                                                                                                                                                            \
+    } else {                                                                                                                                                                       \
+        NLog::log("{}Passed: {}{}. Got {}", Colors::GREEN, Colors::RESET, #expr, (RESULT - (desired)));                                                                            \
+        TESTS_PASSED++;                                                                                                                                                            \
+    }
+
+#define EXPECT(expr, val)                                                                                                                                                          \
+    if (const auto RESULT = expr; RESULT != (val)) {                                                                                                                               \
+        NLog::log("{}Failed: {}{}, expected {}, got {}. Source: {}@{}.", Colors::RED, Colors::RESET, #expr, val, RESULT, __FILE__, __LINE__);                                      \
+        ret = 1;                                                                                                                                                                   \
+        TESTS_FAILED++;                                                                                                                                                            \
+    } else {                                                                                                                                                                       \
+        NLog::log("{}Passed: {}{}. Got {}", Colors::GREEN, Colors::RESET, #expr, val);                                                                                             \
+        TESTS_PASSED++;                                                                                                                                                            \
+    }
+
+#define EXPECT_VECTOR2D(expr, val)                                                                                                                                                 \
+    do {                                                                                                                                                                           \
+        const auto& RESULT   = expr;                                                                                                                                               \
+        const auto& EXPECTED = val;                                                                                                                                                \
+        if (!(std::abs(RESULT.x - EXPECTED.x) < 1e-6 && std::abs(RESULT.y - EXPECTED.y) < 1e-6)) {                                                                                 \
+            NLog::log("{}Failed: {}{}, expected [{}, {}], got [{}, {}]. Source: {}@{}.", Colors::RED, Colors::RESET, #expr, EXPECTED.x, EXPECTED.y, RESULT.x, RESULT.y, __FILE__,  \
+                      __LINE__);                                                                                                                                                   \
+            ret = 1;                                                                                                                                                               \
+            TESTS_FAILED++;                                                                                                                                                        \
+        } else {                                                                                                                                                                   \
+            NLog::log("{}Passed: {}{}. Got [{}, {}].", Colors::GREEN, Colors::RESET, #expr, RESULT.x, RESULT.y);                                                                   \
+            TESTS_PASSED++;                                                                                                                                                        \
+        }                                                                                                                                                                          \
+    } while (0)
+
+#define EXPECT_CONTAINS(haystack, needle)                                                                                                                                          \
+    if (const auto EXPECTED = needle; !std::string{haystack}.contains(EXPECTED)) {                                                                                                 \
+        NLog::log("{}Failed: {}{} should contain {} but doesn't. Source: {}@{}. Haystack is:\n{}", Colors::RED, Colors::RESET, #haystack, #needle, __FILE__, __LINE__,             \
+                  std::string{haystack});                                                                                                                                          \
+        ret = 1;                                                                                                                                                                   \
+        TESTS_FAILED++;                                                                                                                                                            \
+    } else {                                                                                                                                                                       \
+        NLog::log("{}Passed: {}{} contains {}.", Colors::GREEN, Colors::RESET, #haystack, EXPECTED);                                                                               \
+        TESTS_PASSED++;                                                                                                                                                            \
+    }
+
+#define EXPECT_NOT_CONTAINS(haystack, needle)                                                                                                                                      \
+    if (std::string{haystack}.contains(needle)) {                                                                                                                                  \
+        NLog::log("{}Failed: {}{} shouldn't contain {} but does. Source: {}@{}. Haystack is:\n{}", Colors::RED, Colors::RESET, #haystack, #needle, __FILE__, __LINE__,             \
+                  std::string{haystack});                                                                                                                                          \
+        ret = 1;                                                                                                                                                                   \
+        TESTS_FAILED++;                                                                                                                                                            \
+    } else {                                                                                                                                                                       \
+        NLog::log("{}Passed: {}{} doesn't contain {}.", Colors::GREEN, Colors::RESET, #haystack, #needle);                                                                         \
+        TESTS_PASSED++;                                                                                                                                                            \
+    }
+
+#define EXPECT_STARTS_WITH(str, what)                                                                                                                                              \
+    if (!std::string{str}.starts_with(what)) {                                                                                                                                     \
+        NLog::log("{}Failed: {}{} should start with {} but doesn't. Source: {}@{}. String is:\n{}", Colors::RED, Colors::RESET, #str, #what, __FILE__, __LINE__,                   \
+                  std::string{str});                                                                                                                                               \
+        ret = 1;                                                                                                                                                                   \
+        TESTS_FAILED++;                                                                                                                                                            \
+    } else {                                                                                                                                                                       \
+        NLog::log("{}Passed: {}{} starts with {}.", Colors::GREEN, Colors::RESET, #str, #what);                                                                                    \
+        TESTS_PASSED++;                                                                                                                                                            \
+    }
+
+#define EXPECT_COUNT_STRING(str, what, no)                                                                                                                                         \
+    if (Tests::countOccurrences(str, what) != no) {                                                                                                                                \
+        NLog::log("{}Failed: {}{} should contain {} {} times, but doesn't. Source: {}@{}. String is:\n{}", Colors::RED, Colors::RESET, #str, #what, no, __FILE__, __LINE__,        \
+                  std::string{str});                                                                                                                                               \
+        ret = 1;                                                                                                                                                                   \
+        TESTS_FAILED++;                                                                                                                                                            \
+    } else {                                                                                                                                                                       \
+        NLog::log("{}Passed: {}{} contains {} {} times.", Colors::GREEN, Colors::RESET, #str, #what, no);                                                                          \
+        TESTS_PASSED++;                                                                                                                                                            \
+    }
+
+#define OK(x) EXPECT(x, "ok")

hyprtester/src/tests/clients/.gitignore

@@ -0,0 +1 @@
+build.hpp

hyprtester/src/tests/clients/pointer-scroll.cpp

@@ -0,0 +1,145 @@
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include "../shared.hpp"
+#include "tests.hpp"
+#include "build.hpp"
+
+#include <hyprutils/os/FileDescriptor.hpp>
+#include <hyprutils/os/Process.hpp>
+
+#include <sys/poll.h>
+#include <csignal>
+#include <thread>
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+#define SP CSharedPointer
+
+struct SClient {
+    SP<CProcess>           proc;
+    std::array<char, 1024> readBuf;
+    CFileDescriptor        readFd, writeFd;
+    struct pollfd          fds;
+};
+
+static int  ret = 0;
+
+static bool startClient(SClient& client) {
+    client.proc = makeShared<CProcess>(binaryDir + "/pointer-scroll", std::vector<std::string>{});
+
+    client.proc->addEnv("WAYLAND_DISPLAY", WLDISPLAY);
+
+    int pipeFds1[2], pipeFds2[2];
+    if (pipe(pipeFds1) != 0 || pipe(pipeFds2) != 0) {
+        NLog::log("{}Unable to open pipe to client", Colors::RED);
+        return false;
+    }
+
+    client.writeFd = CFileDescriptor(pipeFds1[1]);
+    client.proc->setStdinFD(pipeFds1[0]);
+
+    client.readFd = CFileDescriptor(pipeFds2[0]);
+    client.proc->setStdoutFD(pipeFds2[1]);
+
+    client.proc->runAsync();
+
+    close(pipeFds1[0]);
+    close(pipeFds2[1]);
+
+    client.fds = {.fd = client.readFd.get(), .events = POLLIN};
+    if (poll(&client.fds, 1, 1000) != 1 || !(client.fds.revents & POLLIN))
+        return false;
+
+    client.readBuf.fill(0);
+    if (read(client.readFd.get(), client.readBuf.data(), client.readBuf.size() - 1) == -1)
+        return false;
+
+    std::string ret = std::string{client.readBuf.data()};
+    if (ret.find("started") == std::string::npos) {
+        NLog::log("{}Failed to start pointer-scroll client, read {}", Colors::RED, ret);
+        return false;
+    }
+
+    // wait for window to appear
+    std::this_thread::sleep_for(std::chrono::milliseconds(5000));
+
+    if (getFromSocket(std::format("/dispatch setprop pid:{} no_anim 1", client.proc->pid())) != "ok") {
+        NLog::log("{}Failed to disable animations for client window", Colors::RED, ret);
+        return false;
+    }
+
+    if (getFromSocket(std::format("/dispatch focuswindow pid:{}", client.proc->pid())) != "ok") {
+        NLog::log("{}Failed to focus pointer-scroll client", Colors::RED, ret);
+        return false;
+    }
+
+    NLog::log("{}Started pointer-scroll client", Colors::YELLOW);
+
+    return true;
+}
+
+static void stopClient(SClient& client) {
+    std::string cmd = "exit\n";
+    write(client.writeFd.get(), cmd.c_str(), cmd.length());
+
+    kill(client.proc->pid(), SIGKILL);
+    client.proc.reset();
+}
+
+static int getLastDelta(SClient& client) {
+    std::string cmd = "hypr";
+    if ((size_t)write(client.writeFd.get(), cmd.c_str(), cmd.length()) != cmd.length())
+        return false;
+
+    if (poll(&client.fds, 1, 1500) != 1 || !(client.fds.revents & POLLIN))
+        return false;
+    ssize_t bytesRead = read(client.fds.fd, client.readBuf.data(), 1023);
+    if (bytesRead == -1)
+        return false;
+
+    client.readBuf[bytesRead] = 0;
+    std::string received      = std::string{client.readBuf.data()};
+    received.pop_back();
+
+    try {
+        return std::stoi(received);
+    } catch (...) { return -1; }
+}
+
+static bool sendScroll(int delta) {
+    return getFromSocket(std::format("/dispatch plugin:test:scroll {}", delta)) == "ok";
+}
+
+static bool test() {
+    SClient client;
+
+    if (!startClient(client))
+        return false;
+
+    EXPECT(getFromSocket("/keyword input:emulate_discrete_scroll 0"), "ok");
+
+    EXPECT(sendScroll(10), true);
+    EXPECT(getLastDelta(client), 10);
+
+    EXPECT(getFromSocket("/keyword input:scroll_factor 2"), "ok");
+    EXPECT(sendScroll(10), true);
+    EXPECT(getLastDelta(client), 20);
+
+    EXPECT(getFromSocket("r/keyword device[test-mouse-1]:scroll_factor 3"), "ok");
+    EXPECT(sendScroll(10), true);
+    EXPECT(getLastDelta(client), 30);
+
+    EXPECT(getFromSocket("r/dispatch setprop active scroll_mouse 4"), "ok");
+    EXPECT(sendScroll(10), true);
+    EXPECT(getLastDelta(client), 40);
+
+    stopClient(client);
+
+    NLog::log("{}Reloading the config", Colors::YELLOW);
+    OK(getFromSocket("/reload"));
+
+    return !ret;
+}
+
+REGISTER_CLIENT_TEST_FN(test);

hyprtester/src/tests/clients/pointer-warp.cpp

@@ -0,0 +1,183 @@
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include "../shared.hpp"
+#include "tests.hpp"
+#include "build.hpp"
+
+#include <hyprutils/os/FileDescriptor.hpp>
+#include <hyprutils/os/Process.hpp>
+
+#include <sys/poll.h>
+#include <csignal>
+#include <thread>
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+#define SP CSharedPointer
+
+struct SClient {
+    SP<CProcess>           proc;
+    std::array<char, 1024> readBuf;
+    CFileDescriptor        readFd, writeFd;
+    struct pollfd          fds;
+};
+
+static int  ret = 0;
+
+static bool startClient(SClient& client) {
+    client.proc = makeShared<CProcess>(binaryDir + "/pointer-warp", std::vector<std::string>{});
+
+    client.proc->addEnv("WAYLAND_DISPLAY", WLDISPLAY);
+
+    int pipeFds1[2], pipeFds2[2];
+    if (pipe(pipeFds1) != 0 || pipe(pipeFds2) != 0) {
+        NLog::log("{}Unable to open pipe to client", Colors::RED);
+        return false;
+    }
+
+    client.writeFd = CFileDescriptor(pipeFds1[1]);
+    client.proc->setStdinFD(pipeFds1[0]);
+
+    client.readFd = CFileDescriptor(pipeFds2[0]);
+    client.proc->setStdoutFD(pipeFds2[1]);
+
+    client.proc->runAsync();
+
+    close(pipeFds1[0]);
+    close(pipeFds2[1]);
+
+    client.fds = {.fd = client.readFd.get(), .events = POLLIN};
+    if (poll(&client.fds, 1, 1000) != 1 || !(client.fds.revents & POLLIN))
+        return false;
+
+    client.readBuf.fill(0);
+    if (read(client.readFd.get(), client.readBuf.data(), client.readBuf.size() - 1) == -1)
+        return false;
+
+    std::string ret = std::string{client.readBuf.data()};
+    if (ret.find("started") == std::string::npos) {
+        NLog::log("{}Failed to start pointer-warp client, read {}", Colors::RED, ret);
+        return false;
+    }
+
+    // wait for window to appear
+    std::this_thread::sleep_for(std::chrono::milliseconds(5000));
+
+    if (getFromSocket(std::format("/dispatch setprop pid:{} no_anim 1", client.proc->pid())) != "ok") {
+        NLog::log("{}Failed to disable animations for client window", Colors::RED, ret);
+        return false;
+    }
+
+    if (getFromSocket(std::format("/dispatch focuswindow pid:{}", client.proc->pid())) != "ok") {
+        NLog::log("{}Failed to focus pointer-warp client", Colors::RED, ret);
+        return false;
+    }
+
+    NLog::log("{}Started pointer-warp client", Colors::YELLOW);
+
+    return true;
+}
+
+static void stopClient(SClient& client) {
+    std::string cmd = "exit\n";
+    write(client.writeFd.get(), cmd.c_str(), cmd.length());
+
+    kill(client.proc->pid(), SIGKILL);
+    client.proc.reset();
+}
+
+// format is like below
+// "warp 20 20\n" would ask to warp cursor to x=20,y=20 in surface local coords
+static bool sendWarp(SClient& client, int x, int y) {
+    std::string cmd = std::format("warp {} {}\n", x, y);
+    if ((size_t)write(client.writeFd.get(), cmd.c_str(), cmd.length()) != cmd.length())
+        return false;
+
+    if (poll(&client.fds, 1, 1500) != 1 || !(client.fds.revents & POLLIN))
+        return false;
+    ssize_t bytesRead = read(client.fds.fd, client.readBuf.data(), 1023);
+    if (bytesRead == -1)
+        return false;
+
+    client.readBuf[bytesRead] = 0;
+    std::string recieved      = std::string{client.readBuf.data()};
+    recieved.pop_back();
+
+    return true;
+}
+
+static bool isCursorPos(int x, int y) {
+    // TODO: add a better way to do this using test plugin?
+    std::string res = getFromSocket("/cursorpos");
+    if (res == "error") {
+        NLog::log("{}Cursorpos err'd: {}", Colors::RED, res);
+        return false;
+    }
+
+    auto it = res.find_first_of(' ');
+    if (res.at(it - 1) != ',') {
+        NLog::log("{}Cursorpos err'd: {}", Colors::RED, res);
+        return false;
+    }
+
+    int cursorX = std::stoi(res.substr(0, it - 1));
+    int cursorY = std::stoi(res.substr(it + 1));
+
+    // somehow this is always gives 1 less than surfbox->pos()??
+    res = getFromSocket("/activewindow");
+    it  = res.find("at: ") + 4;
+    res = res.substr(it, res.find_first_of('\n', it) - it);
+
+    it          = res.find_first_of(',');
+    int clientX = cursorX - std::stoi(res.substr(0, it)) + 1;
+    int clientY = cursorY - std::stoi(res.substr(it + 1)) + 1;
+
+    return clientX == x && clientY == y;
+}
+
+static bool test() {
+    SClient client;
+
+    if (!startClient(client))
+        return false;
+
+    EXPECT(sendWarp(client, 100, 100), true);
+    EXPECT(isCursorPos(100, 100), true);
+
+    EXPECT(sendWarp(client, 0, 0), true);
+    EXPECT(isCursorPos(0, 0), true);
+
+    EXPECT(sendWarp(client, 200, 200), true);
+    EXPECT(isCursorPos(200, 200), true);
+
+    EXPECT(sendWarp(client, 100, -100), true);
+    EXPECT(isCursorPos(200, 200), true);
+
+    EXPECT(sendWarp(client, 234, 345), true);
+    EXPECT(isCursorPos(234, 345), true);
+
+    EXPECT(sendWarp(client, -1, -1), true);
+    EXPECT(isCursorPos(234, 345), true);
+
+    EXPECT(sendWarp(client, 1, -1), true);
+    EXPECT(isCursorPos(234, 345), true);
+
+    EXPECT(sendWarp(client, 13, 37), true);
+    EXPECT(isCursorPos(13, 37), true);
+
+    EXPECT(sendWarp(client, -100, 100), true);
+    EXPECT(isCursorPos(13, 37), true);
+
+    EXPECT(sendWarp(client, -1, 1), true);
+    EXPECT(isCursorPos(13, 37), true);
+
+    stopClient(client);
+
+    NLog::log("{}Reloading the config", Colors::YELLOW);
+    OK(getFromSocket("/reload"));
+
+    return !ret;
+}
+
+REGISTER_CLIENT_TEST_FN(test);

hyprtester/src/tests/clients/tests.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <vector>
+#include <functional>
+
+inline std::vector<std::function<bool()>> clientTestFns;
+
+#define REGISTER_CLIENT_TEST_FN(fn)                                                                                                                                                \
+    static auto _register_fn = [] {                                                                                                                                                \
+        clientTestFns.emplace_back(fn);                                                                                                                                            \
+        return 1;                                                                                                                                                                  \
+    }();

hyprtester/src/tests/main/animations.cpp

@@ -0,0 +1,22 @@
+#include "../../Log.hpp"
+#include "tests.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+
+static int ret = 0;
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+static bool test() {
+    NLog::log("{}Testing animations", Colors::GREEN);
+
+    auto str = getFromSocket("/animations");
+    NLog::log("{}Testing bezier curve output from `hyprctl animations`", Colors::YELLOW);
+    {EXPECT_CONTAINS(str, std::format("beziers:\n\n\tname: quick\n\t\tX0: 0.15\n\t\tY0: 0.00\n\t\tX1: 0.10\n\t\tY1: 1.00"))};
+    return !ret;
+}
+
+REGISTER_TEST_FN(test)

hyprtester/src/tests/main/colors.cpp

@@ -0,0 +1,27 @@
+#include "tests.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include "../shared.hpp"
+
+static int  ret = 0;
+
+static bool test() {
+    NLog::log("{}Testing hyprctl monitors", Colors::GREEN);
+
+    std::string monitorsSpec = getFromSocket("j/monitors");
+    EXPECT_CONTAINS(monitorsSpec, R"("colorManagementPreset": "srgb")");
+
+    EXPECT_CONTAINS(getFromSocket("/keyword monitor HEADLESS-2,1920x1080x60.00000,0x0,1.0,bitdepth,10,cm,wide"), "ok")
+    monitorsSpec = getFromSocket("j/monitors");
+    EXPECT_CONTAINS(monitorsSpec, R"("colorManagementPreset": "wide")");
+
+    EXPECT_CONTAINS(getFromSocket("/keyword monitor HEADLESS-2,1920x1080x60.00000,0x0,1.0,bitdepth,10,cm,srgb,sdrbrightness,1.2,sdrsaturation,0.98"), "ok")
+    monitorsSpec = getFromSocket("j/monitors");
+    EXPECT_CONTAINS(monitorsSpec, R"("colorManagementPreset": "srgb")");
+    EXPECT_CONTAINS(monitorsSpec, R"("sdrBrightness": 1.20)");
+    EXPECT_CONTAINS(monitorsSpec, R"("sdrSaturation": 0.98)");
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test)

hyprtester/src/tests/main/dwindle.cpp

@@ -0,0 +1,54 @@
+#include "../shared.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include "tests.hpp"
+
+static int  ret = 0;
+
+static void testFloatClamp() {
+    for (auto const& win : {"a", "b", "c"}) {
+        if (!Tests::spawnKitty(win)) {
+            NLog::log("{}Failed to spawn kitty with win class `{}`", Colors::RED, win);
+            ++TESTS_FAILED;
+            ret = 1;
+            return;
+        }
+    }
+
+    OK(getFromSocket("/keyword dwindle:force_split 2"));
+    OK(getFromSocket("/keyword monitor HEADLESS-2, addreserved, 0, 20, 0, 20"));
+    OK(getFromSocket("/dispatch focuswindow class:c"));
+    OK(getFromSocket("/dispatch setfloating class:c"));
+    OK(getFromSocket("/dispatch resizewindowpixel exact 1200 900,class:c"));
+    OK(getFromSocket("/dispatch settiled class:c"));
+    OK(getFromSocket("/dispatch setfloating class:c"));
+
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT_CONTAINS(str, "at: 698,158");
+        EXPECT_CONTAINS(str, "size: 1200,900");
+    }
+
+    OK(getFromSocket("/keyword dwindle:force_split 0"));
+
+    // clean up
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+}
+
+static bool test() {
+    NLog::log("{}Testing Dwindle layout", Colors::GREEN);
+
+    // test
+    NLog::log("{}Testing float clamp", Colors::GREEN);
+    testFloatClamp();
+
+    // clean up
+    NLog::log("Cleaning up", Colors::YELLOW);
+    getFromSocket("/dispatch workspace 1");
+    OK(getFromSocket("/reload"));
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test);

hyprtester/src/tests/main/exec.cpp

@@ -0,0 +1,54 @@
+#include "tests.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include <chrono>
+#include <thread>
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include "../shared.hpp"
+
+static int ret = 0;
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+#define UP CUniquePointer
+#define SP CSharedPointer
+
+static bool test() {
+    NLog::log("{}Testing process spawning", Colors::GREEN);
+
+    // Note: POSIX sleep does not support fractional seconds, so
+    // can't sleep for less than 1 second.
+    OK(getFromSocket("/dispatch exec sleep 1"));
+
+    // Ensure that sleep is our child
+    const std::string sleepPidS = Tests::execAndGet("pgrep sleep");
+    pid_t             sleepPid;
+    try {
+        sleepPid = std::stoull(sleepPidS);
+    } catch (...) {
+        NLog::log("{}Sleep was not spawned or several sleeps are running: pgrep returned '{}'", Colors::RED, sleepPidS);
+        return false;
+    }
+
+    const std::string sleepParentComm = Tests::execAndGet("cat \"/proc/$(ps -o ppid:1= -p " + sleepPidS + ")/comm\"");
+    NLog::log("{}Expecting that sleep's parent is Hyprland", Colors::YELLOW);
+    EXPECT_CONTAINS(sleepParentComm, "Hyprland");
+
+    std::this_thread::sleep_for(std::chrono::seconds(1));
+
+    // Ensure that sleep did not become a zombie
+    EXPECT(Tests::processAlive(sleepPid), false);
+
+    // kill all
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test)

hyprtester/src/tests/main/gestures.cpp

@@ -0,0 +1,203 @@
+#include "tests.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include <print>
+#include <thread>
+#include <chrono>
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include <csignal>
+#include <cerrno>
+#include "../shared.hpp"
+
+static int ret = 0;
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+#define UP CUniquePointer
+#define SP CSharedPointer
+
+static bool waitForWindowCount(int expectedWindowCnt, std::string_view expectation, int waitMillis = 100, int maxWaitCnt = 50) {
+    int counter = 0;
+    while (Tests::windowCount() != expectedWindowCnt) {
+        counter++;
+        std::this_thread::sleep_for(std::chrono::milliseconds(waitMillis));
+
+        if (counter > maxWaitCnt) {
+            NLog::log("{}Unmet expectation: {}", Colors::RED, expectation);
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool test() {
+    NLog::log("{}Testing gestures", Colors::GREEN);
+
+    EXPECT(Tests::windowCount(), 0);
+
+    // test on workspace "window"
+    NLog::log("{}Switching to workspace 1", Colors::YELLOW);
+    getFromSocket("/dispatch workspace 1"); // no OK: we might be on 1 already
+
+    Tests::spawnKitty();
+    EXPECT(Tests::windowCount(), 1);
+
+    // Give the shell a moment to initialize
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
+
+    OK(getFromSocket("/dispatch plugin:test:gesture up,5"));
+    OK(getFromSocket("/dispatch plugin:test:gesture down,5"));
+    OK(getFromSocket("/dispatch plugin:test:gesture left,5"));
+    OK(getFromSocket("/dispatch plugin:test:gesture right,5"));
+    OK(getFromSocket("/dispatch plugin:test:gesture right,4"));
+
+    EXPECT(waitForWindowCount(0, "Gesture sent paste exit + enter to kitty"), true);
+
+    EXPECT(Tests::windowCount(), 0);
+
+    OK(getFromSocket("/dispatch plugin:test:gesture left,3"));
+
+    EXPECT(waitForWindowCount(1, "Gesture spawned kitty"), true);
+
+    EXPECT(Tests::windowCount(), 1);
+
+    OK(getFromSocket("/dispatch plugin:test:gesture right,3"));
+
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT_CONTAINS(str, "floating: 1");
+    }
+
+    OK(getFromSocket("/dispatch plugin:test:gesture down,3"));
+
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT_CONTAINS(str, "fullscreen: 2");
+    }
+
+    OK(getFromSocket("/dispatch plugin:test:gesture down,3"));
+
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT_CONTAINS(str, "fullscreen: 0");
+    }
+
+    OK(getFromSocket("/dispatch plugin:test:alt 1"));
+
+    OK(getFromSocket("/dispatch plugin:test:gesture left,3"));
+
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_CONTAINS(str, "ID 2 (2)");
+    }
+
+    OK(getFromSocket("/dispatch plugin:test:gesture right,3"));
+
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_NOT_CONTAINS(str, "ID 2 (2)");
+    }
+
+    // check for crashes
+    OK(getFromSocket("/dispatch plugin:test:gesture right,3"));
+
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_NOT_CONTAINS(str, "ID 2 (2)");
+    }
+
+    OK(getFromSocket("/keyword gestures:workspace_swipe_invert 0"));
+
+    OK(getFromSocket("/dispatch plugin:test:gesture right,3"));
+
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_CONTAINS(str, "ID 2 (2)");
+    }
+
+    OK(getFromSocket("/dispatch plugin:test:gesture left,3"));
+
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_NOT_CONTAINS(str, "ID 2 (2)");
+    }
+
+    OK(getFromSocket("/keyword gestures:workspace_swipe_invert 1"));
+    OK(getFromSocket("/keyword gestures:workspace_swipe_create_new 0"));
+
+    OK(getFromSocket("/dispatch plugin:test:gesture left,3"));
+
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_NOT_CONTAINS(str, "ID 2 (2)");
+        EXPECT_CONTAINS(str, "ID 1 (1)");
+    }
+
+    OK(getFromSocket("/dispatch plugin:test:gesture down,3"));
+
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT_CONTAINS(str, "floating: 0");
+    }
+
+    OK(getFromSocket("/dispatch plugin:test:alt 0"));
+
+    OK(getFromSocket("/dispatch plugin:test:gesture up,3"));
+
+    EXPECT(waitForWindowCount(0, "Gesture closed kitty"), true);
+
+    EXPECT(Tests::windowCount(), 0);
+
+    // This test ensures that `movecursortocorner`, which expects
+    // a single-character direction argument, is parsed correctly.
+    Tests::spawnKitty();
+    OK(getFromSocket("/dispatch movecursortocorner 0"));
+    const std::string cursorPos1 = getFromSocket("/cursorpos");
+    OK(getFromSocket("/dispatch plugin:test:gesture left,4"));
+    const std::string cursorPos2 = getFromSocket("/cursorpos");
+    // The cursor should have moved because of the gesture
+    EXPECT(cursorPos1 != cursorPos2, true);
+
+    // Test that `workspace previous` works correctly after a workspace gesture.
+    {
+        OK(getFromSocket("/keyword gestures:workspace_swipe_invert 0"));
+        OK(getFromSocket("/keyword gestures:workspace_swipe_create_new 1"));
+        OK(getFromSocket("/dispatch workspace 3"));
+
+        // Come to workspace 5 from workspace 3: 5 will remember that.
+        OK(getFromSocket("/dispatch workspace 5"));
+        Tests::spawnKitty(); // Keep workspace 5 open
+
+        // Swipe from 1 to 5: 5 shall remember that.
+        OK(getFromSocket("/dispatch workspace 1"));
+        OK(getFromSocket("/dispatch plugin:test:alt 1"));
+        OK(getFromSocket("/dispatch plugin:test:gesture right,3"));
+        OK(getFromSocket("/dispatch plugin:test:alt 0"));
+        EXPECT_CONTAINS(getFromSocket("/activeworkspace"), "ID 5 (5)");
+
+        // Must return to 1 rather than 3
+        OK(getFromSocket("/dispatch workspace previous"));
+        EXPECT_CONTAINS(getFromSocket("/activeworkspace"), "ID 1 (1)");
+
+        OK(getFromSocket("/dispatch workspace previous"));
+        EXPECT_CONTAINS(getFromSocket("/activeworkspace"), "ID 5 (5)");
+
+        OK(getFromSocket("/dispatch workspace 1"));
+    }
+
+    // kill all
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+
+    // reload cfg
+    OK(getFromSocket("/reload"));
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test)

hyprtester/src/tests/main/groups.cpp

@@ -0,0 +1,179 @@
+#include "tests.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include <print>
+#include <thread>
+#include <chrono>
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include <csignal>
+#include <cerrno>
+#include "../shared.hpp"
+
+static int ret = 0;
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+#define UP CUniquePointer
+#define SP CSharedPointer
+
+static bool test() {
+    NLog::log("{}Testing groups", Colors::GREEN);
+
+    // test on workspace "window"
+    NLog::log("{}Dispatching workspace `groups`", Colors::YELLOW);
+    getFromSocket("/dispatch workspace name:groups");
+
+    NLog::log("{}Spawning kittyProcA", Colors::YELLOW);
+    auto kittyProcA = Tests::spawnKitty();
+    if (!kittyProcA) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        return false;
+    }
+
+    NLog::log("{}Expecting 1 window", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 1);
+
+    // check kitty properties. One kitty should take the entire screen, minus the gaps.
+    NLog::log("{}Check kitty dimensions", Colors::YELLOW);
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT_COUNT_STRING(str, "at: 22,22", 1);
+        EXPECT_COUNT_STRING(str, "size: 1876,1036", 1);
+        EXPECT_COUNT_STRING(str, "fullscreen: 0", 1);
+    }
+
+    // group the kitty
+    NLog::log("{}Enable group and groupbar", Colors::YELLOW);
+    OK(getFromSocket("/dispatch togglegroup"));
+    OK(getFromSocket("/keyword group:groupbar:enabled 1"));
+
+    // check the height of the window now
+    NLog::log("{}Recheck kitty dimensions", Colors::YELLOW);
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT_CONTAINS(str, "at: 22,43");
+        EXPECT_CONTAINS(str, "size: 1876,1015");
+    }
+
+    // disable the groupbar for ease of testing for now
+    NLog::log("{}Disable groupbar", Colors::YELLOW);
+    OK(getFromSocket("r/keyword group:groupbar:enabled 0"));
+
+    // kill all
+    NLog::log("{}Kill windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Spawn kitty again", Colors::YELLOW);
+    kittyProcA = Tests::spawnKitty();
+    if (!kittyProcA) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        return false;
+    }
+
+    NLog::log("{}Group kitty", Colors::YELLOW);
+    OK(getFromSocket("/dispatch togglegroup"));
+
+    // check the height of the window now
+    NLog::log("{}Check kitty dimensions 2", Colors::YELLOW);
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT_CONTAINS(str, "at: 22,22");
+        EXPECT_CONTAINS(str, "size: 1876,1036");
+    }
+
+    NLog::log("{}Spawn kittyProcB", Colors::YELLOW);
+    auto kittyProcB = Tests::spawnKitty();
+    if (!kittyProcB) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        return false;
+    }
+
+    NLog::log("{}Expecting 2 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 2);
+
+    size_t lastActiveKittyIdx = 0;
+
+    NLog::log("{}Get last active kitty id", Colors::YELLOW);
+    try {
+        auto str           = getFromSocket("/activewindow");
+        lastActiveKittyIdx = std::stoull(str.substr(7, str.find(" -> ") - 7), nullptr, 16);
+    } catch (...) {
+        NLog::log("{}Fail at getting prop", Colors::RED);
+        ret = 1;
+    }
+
+    // test cycling through
+
+    NLog::log("{}Test cycling through grouped windows", Colors::YELLOW);
+    OK(getFromSocket("/dispatch changegroupactive f"));
+
+    try {
+        auto str = getFromSocket("/activewindow");
+        EXPECT(lastActiveKittyIdx != std::stoull(str.substr(7, str.find(" -> ") - 7), nullptr, 16), true);
+    } catch (...) {
+        NLog::log("{}Fail at getting prop", Colors::RED);
+        ret = 1;
+    }
+
+    getFromSocket("/dispatch changegroupactive f");
+
+    try {
+        auto str = getFromSocket("/activewindow");
+        EXPECT(lastActiveKittyIdx, std::stoull(str.substr(7, str.find(" -> ") - 7), nullptr, 16));
+    } catch (...) {
+        NLog::log("{}Fail at getting prop", Colors::RED);
+        ret = 1;
+    }
+
+    NLog::log("{}Disable autogrouping", Colors::YELLOW);
+    OK(getFromSocket("/keyword group:auto_group false"));
+
+    NLog::log("{}Spawn kittyProcC", Colors::YELLOW);
+    auto kittyProcC = Tests::spawnKitty();
+    if (!kittyProcC) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        return false;
+    }
+
+    NLog::log("{}Expecting 3 windows 2", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 3);
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT_COUNT_STRING(str, "at: 22,22", 2);
+    }
+
+    OK(getFromSocket("/dispatch movefocus l"));
+    OK(getFromSocket("/dispatch changegroupactive 1"));
+    OK(getFromSocket("/keyword group:auto_group true"));
+    OK(getFromSocket("/keyword group:insert_after_current false"));
+
+    NLog::log("{}Spawn kittyProcD", Colors::YELLOW);
+    auto kittyProcD = Tests::spawnKitty();
+    if (!kittyProcD) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        return false;
+    }
+
+    NLog::log("{}Expecting 4 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 4);
+
+    OK(getFromSocket("/dispatch changegroupactive 3"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, std::format("pid: {}", kittyProcD->pid()));
+    }
+
+    // kill all
+    NLog::log("{}Kill windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test)

hyprtester/src/tests/main/hyprctl.cpp

@@ -0,0 +1,184 @@
+#include "tests.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include <cstdint>
+#include <print>
+#include <string>
+#include <thread>
+#include <chrono>
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include <csignal>
+#include <cerrno>
+#include "../shared.hpp"
+
+static int ret = 0;
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+#define UP CUniquePointer
+#define SP CSharedPointer
+
+static std::string getCommandStdOut(std::string command) {
+    CProcess process("bash", {"-c", command});
+    process.addEnv("HYPRLAND_INSTANCE_SIGNATURE", HIS);
+    process.runSync();
+
+    const std::string& stdOut = process.stdOut();
+
+    // Remove trailing new line
+    return stdOut.substr(0, stdOut.length() - 1);
+}
+
+static bool testDevicesActiveLayoutIndex() {
+    NLog::log("{}Testing hyprctl devices active_layout_index", Colors::GREEN);
+
+    // configure layouts
+    getFromSocket("/keyword input:kb_layout us,pl,ua");
+
+    for (uint8_t i = 0; i < 3; i++) {
+        // set layout
+        getFromSocket("/switchxkblayout all " + std::to_string(i));
+        std::string devicesJson = getFromSocket("j/devices");
+        std::string expected    = R"("active_layout_index": )" + std::to_string(i);
+        // check layout index
+        EXPECT_CONTAINS(devicesJson, expected);
+    }
+
+    return true;
+}
+
+static bool testGetprop() {
+    NLog::log("{}Testing hyprctl getprop", Colors::GREEN);
+    if (!Tests::spawnKitty()) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        return false;
+    }
+
+    // animation
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty animation"), "(unset)");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty animation -j"), R"({"animation": ""})");
+    getFromSocket("/dispatch setprop class:kitty animation teststyle");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty animation"), "teststyle");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty animation -j"), R"({"animation": "teststyle"})");
+
+    // max_size
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty max_size"), "inf inf");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty max_size -j"), R"({"max_size": [null,null]})");
+    getFromSocket("/dispatch setprop class:kitty max_size 200 150");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty max_size"), "200 150");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty max_size -j"), R"({"max_size": [200,150]})");
+
+    // min_size
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty min_size"), "20 20");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty min_size -j"), R"({"min_size": [20,20]})");
+    getFromSocket("/dispatch setprop class:kitty min_size 100 50");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty min_size"), "100 50");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty min_size -j"), R"({"min_size": [100,50]})");
+
+    // opacity
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity"), "1");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity -j"), R"({"opacity": 1})");
+    getFromSocket("/dispatch setprop class:kitty opacity 0.3");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity"), "0.3");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity -j"), R"({"opacity": 0.3})");
+
+    // opacity_inactive
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_inactive"), "1");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_inactive -j"), R"({"opacity_inactive": 1})");
+    getFromSocket("/dispatch setprop class:kitty opacity_inactive 0.5");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_inactive"), "0.5");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_inactive -j"), R"({"opacity_inactive": 0.5})");
+
+    // opacity_fullscreen
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_fullscreen"), "1");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_fullscreen -j"), R"({"opacity_fullscreen": 1})");
+    getFromSocket("/dispatch setprop class:kitty opacity_fullscreen 0.75");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_fullscreen"), "0.75");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_fullscreen -j"), R"({"opacity_fullscreen": 0.75})");
+
+    // opacity_override
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_override"), "false");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_override -j"), R"({"opacity_override": false})");
+    getFromSocket("/dispatch setprop class:kitty opacity_override true");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_override"), "true");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_override -j"), R"({"opacity_override": true})");
+
+    // opacity_inactive_override
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_inactive_override"), "false");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_inactive_override -j"), R"({"opacity_inactive_override": false})");
+    getFromSocket("/dispatch setprop class:kitty opacity_inactive_override true");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_inactive_override"), "true");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_inactive_override -j"), R"({"opacity_inactive_override": true})");
+
+    // opacity_fullscreen_override
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_fullscreen_override"), "false");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_fullscreen_override -j"), R"({"opacity_fullscreen_override": false})");
+    getFromSocket("/dispatch setprop class:kitty opacity_fullscreen_override true");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_fullscreen_override"), "true");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty opacity_fullscreen_override -j"), R"({"opacity_fullscreen_override": true})");
+
+    // active_border_color
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty active_border_color"), "ee33ccff ee00ff99 45deg");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty active_border_color -j"), R"({"active_border_color": "ee33ccff ee00ff99 45deg"})");
+    getFromSocket("/dispatch setprop class:kitty active_border_color rgb(abcdef)");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty active_border_color"), "ffabcdef 0deg");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty active_border_color -j"), R"({"active_border_color": "ffabcdef 0deg"})");
+
+    // bool window properties
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty allows_input"), "false");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty allows_input -j"), R"({"allows_input": false})");
+    getFromSocket("/dispatch setprop class:kitty allows_input true");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty allows_input"), "true");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty allows_input -j"), R"({"allows_input": true})");
+
+    // int window properties
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty rounding"), "10");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty rounding -j"), R"({"rounding": 10})");
+    getFromSocket("/dispatch setprop class:kitty rounding 4");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty rounding"), "4");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty rounding -j"), R"({"rounding": 4})");
+
+    // float window properties
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty rounding_power"), "2");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty rounding_power -j"), R"({"rounding_power": 2})");
+    getFromSocket("/dispatch setprop class:kitty rounding_power 1.25");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty rounding_power"), "1.25");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty rounding_power -j"), R"({"rounding_power": 1.25})");
+
+    // errors
+    EXPECT(getCommandStdOut("hyprctl getprop"), "not enough args");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty"), "not enough args");
+    EXPECT(getCommandStdOut("hyprctl getprop class:nonexistantclass animation"), "window not found");
+    EXPECT(getCommandStdOut("hyprctl getprop class:kitty nonexistantprop"), "prop not found");
+
+    // kill all
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+
+    return true;
+}
+
+static bool test() {
+    NLog::log("{}Testing hyprctl", Colors::GREEN);
+
+    {
+        NLog::log("{}Testing hyprctl descriptions for any json errors", Colors::GREEN);
+        CProcess jqProc("bash", {"-c", "hyprctl descriptions | jq"});
+        jqProc.addEnv("HYPRLAND_INSTANCE_SIGNATURE", HIS);
+        jqProc.runSync();
+        EXPECT(jqProc.exitCode(), 0);
+    }
+
+    testGetprop();
+    testDevicesActiveLayoutIndex();
+    getFromSocket("/reload");
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test);

hyprtester/src/tests/main/keybinds.cpp

@@ -0,0 +1,515 @@
+#include <filesystem>
+#include <linux/input-event-codes.h>
+#include <thread>
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include "../shared.hpp"
+#include "tests.hpp"
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+static int         ret      = 0;
+static std::string flagFile = "/tmp/hyprtester-keybinds.txt";
+
+// Because i don't feel like changing someone elses code.
+enum eKeyboardModifierIndex : uint8_t {
+    MOD_SHIFT = 1,
+    MOD_CAPS,
+    MOD_CTRL,
+    MOD_ALT,
+    MOD_MOD2,
+    MOD_MOD3,
+    MOD_META,
+    MOD_MOD5
+};
+
+static void clearFlag() {
+    std::filesystem::remove(flagFile);
+}
+
+static bool checkFlag() {
+    bool exists = std::filesystem::exists(flagFile);
+    clearFlag();
+    return exists;
+}
+
+static bool attemptCheckFlag(int attempts, int intervalMs) {
+    for (int i = 0; i < attempts; i++) {
+        if (checkFlag())
+            return true;
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(intervalMs));
+    }
+
+    return false;
+}
+
+static std::string readKittyOutput() {
+    std::string output = Tests::execAndGet("kitten @ --to unix:/tmp/hyprtester-kitty.sock get-text --extent all");
+    // chop off shell prompt
+    std::size_t pos = output.rfind("$");
+    if (pos != std::string::npos) {
+        pos += 1;
+        if (pos < output.size())
+            output.erase(0, pos);
+    }
+    // NLog::log("Kitty output: '{}'", output);
+    return output;
+}
+
+static void awaitKittyPrompt() {
+    // wait until we see the shell prompt, meaning it's ready for test inputs
+    for (int i = 0; i < 10; i++) {
+        std::string output = Tests::execAndGet("kitten @ --to unix:/tmp/hyprtester-kitty.sock get-text --extent all");
+        if (output.rfind("$") == std::string::npos) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(200));
+            continue;
+        }
+        return;
+    }
+    NLog::log("{}Error: timed out waiting for kitty prompt", Colors::RED);
+}
+
+static CUniquePointer<CProcess> spawnRemoteControlKitty() {
+    auto kittyProc = Tests::spawnKitty("keybinds_test", {"-o", "allow_remote_control=yes", "--listen-on", "unix:/tmp/hyprtester-kitty.sock", "--config", "NONE", "/bin/sh"});
+    // wait a bit to ensure shell prompt is sent, we are going to read the text after it
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    if (kittyProc)
+        awaitKittyPrompt();
+    return kittyProc;
+}
+
+static void testBind() {
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword bind SUPER,Y,exec,touch " + flagFile), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    // await flag
+    EXPECT(attemptCheckFlag(20, 50), true);
+    // release keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+}
+
+static void testBindKey() {
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword bind ,Y,exec,touch " + flagFile), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,0,29"));
+    // await flag
+    EXPECT(attemptCheckFlag(20, 50), true);
+    // release keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    EXPECT(getFromSocket("/keyword unbind ,Y"), "ok");
+}
+
+static void testLongPress() {
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword bindo SUPER,Y,exec,touch " + flagFile), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 100"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    // check no flag on short press
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    EXPECT(checkFlag(), false);
+    // await repeat delay
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), true);
+    // release keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+}
+
+static void testKeyLongPress() {
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword bindo ,Y,exec,touch " + flagFile), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 100"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,0,29"));
+    // check no flag on short press
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    EXPECT(checkFlag(), false);
+    // await repeat delay
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), true);
+    // release keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    EXPECT(getFromSocket("/keyword unbind ,Y"), "ok");
+}
+
+static void testLongPressRelease() {
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword bindo SUPER,Y,exec,touch " + flagFile), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 100"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    // check no flag on short press
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    EXPECT(checkFlag(), false);
+    // release keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    // await repeat delay
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+}
+
+static void testLongPressOnlyKeyRelease() {
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword bindo SUPER,Y,exec,touch " + flagFile), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 100"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    // check no flag on short press
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    EXPECT(checkFlag(), false);
+    // release key, keep modifier
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,7,29"));
+    // await repeat delay
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), false);
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+}
+
+static void testRepeat() {
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword binde SUPER,Y,exec,touch " + flagFile), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 100"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    // await flag
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), true);
+    // await repeat delay
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), true);
+    // check that it continues repeating
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), true);
+    // release keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+}
+
+static void testKeyRepeat() {
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword binde ,Y,exec,touch " + flagFile), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 100"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,0,29"));
+    // await flag
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    EXPECT(checkFlag(), true);
+    // await repeat delay
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), true);
+    // check that it continues repeating
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), true);
+    // release keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    EXPECT(getFromSocket("/keyword unbind ,Y"), "ok");
+}
+
+static void testRepeatRelease() {
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword binde SUPER,Y,exec,touch " + flagFile), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 100"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    // await flag
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    EXPECT(checkFlag(), true);
+    // release keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    // await repeat delay
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    clearFlag();
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), false);
+    // check that it is not repeating
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+}
+
+static void testRepeatOnlyKeyRelease() {
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword binde SUPER,Y,exec,touch " + flagFile), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 100"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    // await flag
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), true);
+    // release key, keep modifier
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,7,29"));
+    // await repeat delay
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    clearFlag();
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), false);
+    // check that it is not repeating
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    EXPECT(checkFlag(), false);
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+}
+
+static void testShortcutBind() {
+    auto kittyProc = spawnRemoteControlKitty();
+    if (!kittyProc) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        ret = 1;
+        return;
+    }
+    EXPECT(getFromSocket("/dispatch focuswindow class:keybinds_test"), "ok");
+    EXPECT(getFromSocket("/keyword bind SUPER,Y,sendshortcut,,q,"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    // release keybind
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    const std::string output = readKittyOutput();
+    EXPECT_COUNT_STRING(output, "y", 0);
+    EXPECT_COUNT_STRING(output, "q", 1);
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+    Tests::killAllWindows();
+}
+
+static void testShortcutBindKey() {
+    auto kittyProc = spawnRemoteControlKitty();
+    if (!kittyProc) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        ret = 1;
+        return;
+    }
+    EXPECT(getFromSocket("/dispatch focuswindow class:keybinds_test"), "ok");
+    EXPECT(getFromSocket("/keyword bind ,Y,sendshortcut,,q,"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,0,29"));
+    // release keybind
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    const std::string output = readKittyOutput();
+    EXPECT_COUNT_STRING(output, "y", 0);
+    // disabled: doesn't work in CI
+    // EXPECT_COUNT_STRING(output, "q", 1);
+    EXPECT(getFromSocket("/keyword unbind ,Y"), "ok");
+    Tests::killAllWindows();
+}
+
+static void testShortcutLongPress() {
+    auto kittyProc = spawnRemoteControlKitty();
+    if (!kittyProc) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        ret = 1;
+        return;
+    }
+    EXPECT(getFromSocket("/dispatch focuswindow class:keybinds_test"), "ok");
+    EXPECT(getFromSocket("/keyword bindo SUPER,Y,sendshortcut,,q,"), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 100"), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_rate 10"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    // await repeat delay
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    const std::string output = readKittyOutput();
+    int               yCount = Tests::countOccurrences(output, "y");
+    // sometimes 1, sometimes 2, not sure why
+    // keybind press sends 1 y immediately
+    // then repeat triggers, sending 1 y
+    // final release stop repeats, and shouldn't send any more
+    EXPECT(true, yCount == 1 || yCount == 2);
+    EXPECT_COUNT_STRING(output, "q", 1);
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+    Tests::killAllWindows();
+}
+
+static void testShortcutLongPressKeyRelease() {
+    auto kittyProc = spawnRemoteControlKitty();
+    if (!kittyProc) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        ret = 1;
+        return;
+    }
+    EXPECT(getFromSocket("/dispatch focuswindow class:keybinds_test"), "ok");
+    EXPECT(getFromSocket("/keyword bindo SUPER,Y,sendshortcut,,q,"), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 100"), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_rate 10"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    // release key, keep modifier
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,7,29"));
+    // await repeat delay
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    const std::string output = readKittyOutput();
+    // disabled: doesn't work on CI
+    // EXPECT_COUNT_STRING(output, "y", 1);
+    EXPECT_COUNT_STRING(output, "q", 0);
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+    Tests::killAllWindows();
+}
+
+static void testShortcutRepeat() {
+    auto kittyProc = spawnRemoteControlKitty();
+    if (!kittyProc) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        ret = 1;
+        return;
+    }
+    EXPECT(getFromSocket("/dispatch focuswindow class:keybinds_test"), "ok");
+    EXPECT(getFromSocket("/keyword binde SUPER,Y,sendshortcut,,q,"), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_rate 5"), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 200"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    // await repeat
+    std::this_thread::sleep_for(std::chrono::milliseconds(210));
+    // release keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    std::this_thread::sleep_for(std::chrono::milliseconds(450));
+    const std::string output = readKittyOutput();
+    EXPECT_COUNT_STRING(output, "y", 0);
+    int qCount = Tests::countOccurrences(output, "q");
+    // sometimes 2, sometimes 3, not sure why
+    // keybind press sends 1 q immediately
+    // then repeat triggers, sending 1 q
+    // final release stop repeats, and shouldn't send any more
+    EXPECT(true, qCount == 2 || qCount == 3);
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+    Tests::killAllWindows();
+}
+
+static void testShortcutRepeatKeyRelease() {
+    auto kittyProc = spawnRemoteControlKitty();
+    if (!kittyProc) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        ret = 1;
+        return;
+    }
+    EXPECT(getFromSocket("/dispatch focuswindow class:keybinds_test"), "ok");
+    EXPECT(getFromSocket("/keyword binde SUPER,Y,sendshortcut,,q,"), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_rate 5"), "ok");
+    EXPECT(getFromSocket("/keyword input:repeat_delay 200"), "ok");
+    // press keybind
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    std::this_thread::sleep_for(std::chrono::milliseconds(210));
+    // release key, keep modifier
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,7,29"));
+    // if repeat was still active, we'd get 2 more q's here
+    std::this_thread::sleep_for(std::chrono::milliseconds(450));
+    // release modifier
+    const std::string output = readKittyOutput();
+    EXPECT_COUNT_STRING(output, "y", 0);
+    int qCount = Tests::countOccurrences(output, "q");
+    // sometimes 2, sometimes 3, not sure why
+    // keybind press sends 1 q immediately
+    // then repeat triggers, sending 1 q
+    // final release stop repeats, and shouldn't send any more
+    EXPECT(true, qCount == 2 || qCount == 3);
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,0,29"));
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+    Tests::killAllWindows();
+}
+
+static void testSubmap() {
+    const auto press = [](const uint32_t key, const uint32_t mod = 0) {
+        // +8 because udev -> XKB keycode.
+        getFromSocket("/dispatch plugin:test:keybind 1," + std::to_string(mod) + "," + std::to_string(key + 8));
+        getFromSocket("/dispatch plugin:test:keybind 0," + std::to_string(mod) + "," + std::to_string(key + 8));
+    };
+
+    NLog::log("{}Testing submaps", Colors::GREEN);
+    // submap 1 no resets
+    press(KEY_U, MOD_META);
+    EXPECT_CONTAINS(getFromSocket("/submap"), "submap1");
+    press(KEY_O);
+    Tests::waitUntilWindowsN(1);
+    EXPECT_CONTAINS(getFromSocket("/submap"), "submap1");
+    // submap 2 resets to submap 1
+    press(KEY_U);
+    EXPECT_CONTAINS(getFromSocket("/submap"), "submap2");
+    press(KEY_O);
+    Tests::waitUntilWindowsN(2);
+    EXPECT_CONTAINS(getFromSocket("/submap"), "submap1");
+    // submap 3 resets to default
+    press(KEY_I);
+    EXPECT_CONTAINS(getFromSocket("/submap"), "submap3");
+    press(KEY_O);
+    Tests::waitUntilWindowsN(3);
+    EXPECT_CONTAINS(getFromSocket("/submap"), "default");
+    // submap 1 reset via keybind
+    press(KEY_U, MOD_META);
+    EXPECT_CONTAINS(getFromSocket("/submap"), "submap1");
+    press(KEY_P);
+    EXPECT_CONTAINS(getFromSocket("/submap"), "default");
+
+    Tests::killAllWindows();
+}
+
+static void testSubmapUniversal() {
+    NLog::log("{}Testing submap universal", Colors::GREEN);
+
+    EXPECT(checkFlag(), false);
+    EXPECT(getFromSocket("/keyword bindu SUPER,Y,exec,touch " + flagFile), "ok");
+    EXPECT_CONTAINS(getFromSocket("/submap"), "default");
+
+    // keybind works on default submap
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,7,29"));
+    EXPECT(attemptCheckFlag(30, 5), true);
+
+    // keybind works on submap1
+    getFromSocket("/dispatch plugin:test:keybind 1,7,30");
+    getFromSocket("/dispatch plugin:test:keybind 0,7,30");
+    EXPECT_CONTAINS(getFromSocket("/submap"), "submap1");
+    OK(getFromSocket("/dispatch plugin:test:keybind 1,7,29"));
+    OK(getFromSocket("/dispatch plugin:test:keybind 0,7,29"));
+    EXPECT(attemptCheckFlag(30, 5), true);
+
+    // reset to default submap
+    getFromSocket("/dispatch plugin:test:keybind 1,0,33");
+    getFromSocket("/dispatch plugin:test:keybind 0,0,33");
+    EXPECT_CONTAINS(getFromSocket("/submap"), "default");
+
+    EXPECT(getFromSocket("/keyword unbind SUPER,Y"), "ok");
+}
+
+static bool test() {
+    NLog::log("{}Testing keybinds", Colors::GREEN);
+
+    clearFlag();
+
+    testBind();
+    testBindKey();
+    testLongPress();
+    testKeyLongPress();
+    testLongPressRelease();
+    testLongPressOnlyKeyRelease();
+    testRepeat();
+    testKeyRepeat();
+    testRepeatRelease();
+    testRepeatOnlyKeyRelease();
+    testShortcutBind();
+    testShortcutBindKey();
+    testShortcutLongPress();
+    testShortcutLongPressKeyRelease();
+    testShortcutRepeat();
+    testShortcutRepeatKeyRelease();
+    testSubmap();
+    testSubmapUniversal();
+
+    clearFlag();
+    return !ret;
+}
+
+REGISTER_TEST_FN(test)

hyprtester/src/tests/main/master.cpp

@@ -0,0 +1,71 @@
+#include "../shared.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include "tests.hpp"
+
+static int  ret = 0;
+
+static void focusMasterPrevious() {
+    // setup
+    NLog::log("{}Spawning 1 master and 3 slave windows", Colors::YELLOW);
+    // order of windows set according to new_status = master (set in test.conf)
+    for (auto const& win : {"slave1", "slave2", "slave3", "master"}) {
+        if (!Tests::spawnKitty(win)) {
+            NLog::log("{}Failed to spawn kitty with win class `{}`", Colors::RED, win);
+            ++TESTS_FAILED;
+            ret = 1;
+            return;
+        }
+    }
+    NLog::log("{}Ensuring focus is on master before testing", Colors::YELLOW);
+    OK(getFromSocket("/dispatch layoutmsg focusmaster master"));
+    EXPECT_CONTAINS(getFromSocket("/activewindow"), "class: master");
+
+    // test
+    NLog::log("{}Testing fallback to focusmaster auto", Colors::YELLOW);
+
+    OK(getFromSocket("/dispatch layoutmsg focusmaster previous"));
+    EXPECT_CONTAINS(getFromSocket("/activewindow"), "class: slave1");
+
+    NLog::log("{}Testing focusing from slave to master", Colors::YELLOW);
+
+    OK(getFromSocket("/dispatch layoutmsg cyclenext noloop"));
+    EXPECT_CONTAINS(getFromSocket("/activewindow"), "class: slave2");
+    OK(getFromSocket("/dispatch layoutmsg focusmaster previous"));
+    EXPECT_CONTAINS(getFromSocket("/activewindow"), "class: master");
+
+    NLog::log("{}Testing focusing on previous window", Colors::YELLOW);
+
+    OK(getFromSocket("/dispatch layoutmsg focusmaster previous"));
+    EXPECT_CONTAINS(getFromSocket("/activewindow"), "class: slave2");
+
+    NLog::log("{}Testing focusing back to master", Colors::YELLOW);
+
+    OK(getFromSocket("/dispatch layoutmsg focusmaster previous"));
+    EXPECT_CONTAINS(getFromSocket("/activewindow"), "class: master");
+
+    // clean up
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+}
+
+static bool test() {
+    NLog::log("{}Testing Master layout", Colors::GREEN);
+
+    // setup
+    OK(getFromSocket("/dispatch workspace name:master"));
+    OK(getFromSocket("/keyword general:layout master"));
+
+    // test
+    NLog::log("{}Testing `focusmaster previous` layoutmsg", Colors::GREEN);
+    focusMasterPrevious();
+
+    // clean up
+    NLog::log("Cleaning up", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace 1"));
+    OK(getFromSocket("/reload"));
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test);

hyprtester/src/tests/main/misc.cpp

@@ -0,0 +1,221 @@
+#include "tests.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include <print>
+#include <thread>
+#include <chrono>
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include <csignal>
+#include <cerrno>
+#include "../shared.hpp"
+
+static int ret = 0;
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+#define UP CUniquePointer
+#define SP CSharedPointer
+
+static bool test() {
+    NLog::log("{}Testing config: misc:", Colors::GREEN);
+
+    NLog::log("{}Testing close_special_on_empty", Colors::YELLOW);
+
+    OK(getFromSocket("/keyword misc:close_special_on_empty false"));
+    OK(getFromSocket("/dispatch workspace special:test"));
+
+    Tests::spawnKitty();
+
+    {
+        auto str = getFromSocket("/monitors");
+        EXPECT_CONTAINS(str, "special workspace: -");
+    }
+
+    Tests::killAllWindows();
+
+    {
+        auto str = getFromSocket("/monitors");
+        EXPECT_CONTAINS(str, "special workspace: -");
+    }
+
+    Tests::spawnKitty();
+
+    OK(getFromSocket("/keyword misc:close_special_on_empty true"));
+
+    Tests::killAllWindows();
+
+    {
+        auto str = getFromSocket("/monitors");
+        EXPECT_NOT_CONTAINS(str, "special workspace: -");
+    }
+
+    NLog::log("{}Testing new_window_takes_over_fullscreen", Colors::YELLOW);
+
+    OK(getFromSocket("/keyword misc:on_focus_under_fullscreen 0"));
+
+    Tests::spawnKitty("kitty_A");
+
+    OK(getFromSocket("/dispatch fullscreen 0"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 2");
+        EXPECT_CONTAINS(str, "kitty_A");
+    }
+
+    Tests::spawnKitty("kitty_B");
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 2");
+        EXPECT_CONTAINS(str, "kitty_A");
+    }
+
+    OK(getFromSocket("/dispatch focuswindow class:kitty_B"));
+
+    {
+        // should be ignored as per focus_under_fullscreen 0
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 2");
+        EXPECT_CONTAINS(str, "kitty_A");
+    }
+
+    OK(getFromSocket("/keyword misc:on_focus_under_fullscreen 1"));
+
+    Tests::spawnKitty("kitty_C");
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 2");
+        EXPECT_CONTAINS(str, "kitty_C");
+    }
+
+    OK(getFromSocket("/keyword misc:on_focus_under_fullscreen 2"));
+
+    Tests::spawnKitty("kitty_D");
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 0");
+        EXPECT_CONTAINS(str, "kitty_D");
+    }
+
+    OK(getFromSocket("/keyword misc:on_focus_under_fullscreen 0"));
+
+    Tests::killAllWindows();
+
+    NLog::log("{}Testing exit_window_retains_fullscreen", Colors::YELLOW);
+
+    OK(getFromSocket("/keyword misc:exit_window_retains_fullscreen false"));
+
+    Tests::spawnKitty("kitty_A");
+    Tests::spawnKitty("kitty_B");
+
+    OK(getFromSocket("/dispatch fullscreen 0"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 2");
+    }
+
+    OK(getFromSocket("/dispatch killwindow activewindow"));
+    Tests::waitUntilWindowsN(1);
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 0");
+    }
+
+    Tests::spawnKitty("kitty_B");
+    OK(getFromSocket("/dispatch fullscreen 0"));
+    OK(getFromSocket("/keyword misc:exit_window_retains_fullscreen true"));
+
+    OK(getFromSocket("/dispatch killwindow activewindow"));
+    Tests::waitUntilWindowsN(1);
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 2");
+    }
+
+    Tests::killAllWindows();
+
+    NLog::log("{}Testing fullscreen and fullscreenstate dispatcher", Colors::YELLOW);
+
+    Tests::spawnKitty("kitty_A");
+    Tests::spawnKitty("kitty_B");
+
+    OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+    OK(getFromSocket("/dispatch fullscreen 0 set"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 2");
+    }
+
+    OK(getFromSocket("/dispatch fullscreen 0 unset"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 0");
+    }
+
+    OK(getFromSocket("/dispatch fullscreen 1 toggle"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 1");
+    }
+
+    OK(getFromSocket("/dispatch fullscreen 1 toggle"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 0");
+    }
+
+    OK(getFromSocket("/dispatch fullscreenstate 2 2 set"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 2");
+    }
+
+    OK(getFromSocket("/dispatch fullscreenstate 2 2 set"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 2");
+    }
+
+    OK(getFromSocket("/dispatch fullscreenstate 2 2 toggle"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 0");
+    }
+
+    OK(getFromSocket("/dispatch fullscreenstate 2 2 toggle"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "fullscreen: 2");
+    }
+
+    // Ensure that the process autostarted in the config does not
+    // become a zombie even if it terminates very quickly.
+    EXPECT(Tests::execAndGet("pgrep -f 'sleep 0'").empty(), true);
+
+    // kill all
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test);

hyprtester/src/tests/main/persistent.cpp

@@ -0,0 +1,85 @@
+#include "tests.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include <print>
+#include <thread>
+#include <chrono>
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include <csignal>
+#include <cerrno>
+#include "../shared.hpp"
+
+static int ret = 0;
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+#define UP CUniquePointer
+#define SP CSharedPointer
+
+static bool test() {
+    NLog::log("{}Testing persistent workspaces", Colors::GREEN);
+
+    EXPECT(Tests::windowCount(), 0);
+
+    // test on workspace "window"
+    NLog::log("{}Switching to workspace 1", Colors::YELLOW);
+    getFromSocket("/dispatch workspace 1"); // no OK: we might be on 1 already
+
+    OK(getFromSocket("/keyword workspace 5, monitor:HEADLESS-2, persistent:1"));
+    OK(getFromSocket("/keyword workspace 6, monitor:HEADLESS-PERSISTENT-TEST, persistent:1"));
+    OK(getFromSocket("/keyword workspace name:PERSIST, monitor:HEADLESS-PERSISTENT-TEST, persistent:1"));
+    OK(getFromSocket("/keyword workspace name:PERSIST-2, monitor:HEADLESS-PERSISTENT-TEST, persistent:1"));
+
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_CONTAINS(str, "ID 5 (5)");
+        EXPECT_COUNT_STRING(str, "workspace ID ", 2);
+    }
+
+    OK(getFromSocket("/output create headless HEADLESS-PERSISTENT-TEST"));
+
+    {
+        auto str = getFromSocket("/monitors");
+        EXPECT_CONTAINS(str, "HEADLESS-PERSISTENT-TEST");
+    }
+
+    OK(getFromSocket("/dispatch focusmonitor HEADLESS-PERSISTENT-TEST"));
+
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_CONTAINS(str, "ID 2 (2)"); // this should be automatically generated by hl
+        EXPECT_CONTAINS(str, "ID 5 (5)");
+        EXPECT_CONTAINS(str, "ID 6 (6)");
+        EXPECT_CONTAINS(str, "(PERSIST) on monitor");
+        EXPECT_CONTAINS(str, "(PERSIST-2) on monitor");
+        EXPECT_COUNT_STRING(str, "workspace ID ", 6);
+    }
+
+    OK(getFromSocket("/reload"));
+
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_NOT_CONTAINS(str, "ID 5 (5)");
+        EXPECT_NOT_CONTAINS(str, "ID 6 (6)");
+        EXPECT_NOT_CONTAINS(str, "(PERSIST) on monitor");
+        EXPECT_COUNT_STRING(str, "workspace ID ", 2);
+    }
+
+    OK(getFromSocket("/output remove HEADLESS-PERSISTENT-TEST"));
+
+    // kill all
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+
+    // reload cfg
+    OK(getFromSocket("/reload"));
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test)

hyprtester/src/tests/main/snap.cpp

@@ -0,0 +1,176 @@
+#include <hyprutils/math/Vector2D.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include <hyprutils/os/Process.hpp>
+
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include "../shared.hpp"
+#include "tests.hpp"
+
+using Hyprutils::Math::Vector2D;
+
+static int  ret = 0;
+
+static bool spawnFloatingKitty() {
+    if (!Tests::spawnKitty()) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        return false;
+    }
+    OK(getFromSocket("/dispatch setfloating active"));
+    OK(getFromSocket("/dispatch resizeactive exact 100 100"));
+    return true;
+}
+
+static void expectSocket(const std::string& CMD) {
+    if (const auto RESULT = getFromSocket(CMD); RESULT != "ok") {
+        NLog::log("{}Failed: {}getFromSocket({}), expected ok, got {}. Source: {}@{}.", Colors::RED, Colors::RESET, CMD, RESULT, __FILE__, __LINE__);
+        ret = 1;
+        TESTS_FAILED++;
+    } else {
+        NLog::log("{}Passed: {}getFromSocket({}). Got ok", Colors::GREEN, Colors::RESET, CMD);
+        TESTS_PASSED++;
+    }
+}
+
+static void expectSnapMove(const Vector2D FROM, const Vector2D* TO) {
+    const Vector2D& A = FROM;
+    const Vector2D& B = TO ? *TO : FROM;
+    if (TO)
+        NLog::log("{}Expecting snap to ({},{}) when window is moved to ({},{})", Colors::YELLOW, B.x, B.y, A.x, A.y);
+    else
+        NLog::log("{}Expecting no snap when window is moved to ({},{})", Colors::YELLOW, A.x, A.y);
+
+    expectSocket(std::format("/dispatch moveactive exact {} {}", A.x, A.y));
+    expectSocket("/dispatch plugin:test:snapmove");
+    EXPECT_CONTAINS(getFromSocket("/activewindow"), std::format("at: {},{}", B.x, B.y));
+}
+
+static void testWindowSnap(const bool RESPECTGAPS) {
+    const int BORDERSIZE = 2;
+    const int WINDOWSIZE = 100;
+
+    const int OTHER     = 500;
+    const int WINDOWGAP = 8;
+    const int GAPSIN    = 5;
+    const int GAP       = (RESPECTGAPS ? 2 * GAPSIN : 0) + (2 * BORDERSIZE);
+    const int END       = GAP + WINDOWSIZE;
+
+    int       x;
+    Vector2D  predict;
+
+    x = WINDOWGAP + END;
+    expectSnapMove({OTHER + x, OTHER}, nullptr);
+    expectSnapMove({OTHER - x, OTHER}, nullptr);
+    expectSnapMove({OTHER, OTHER + x}, nullptr);
+    expectSnapMove({OTHER, OTHER - x}, nullptr);
+    x -= 1;
+    expectSnapMove({OTHER + x, OTHER}, &(predict = {OTHER + END, OTHER}));
+    expectSnapMove({OTHER - x, OTHER}, &(predict = {OTHER - END, OTHER}));
+    expectSnapMove({OTHER, OTHER + x}, &(predict = {OTHER, OTHER + END}));
+    expectSnapMove({OTHER, OTHER - x}, &(predict = {OTHER, OTHER - END}));
+}
+
+static void testMonitorSnap(const bool RESPECTGAPS, const bool OVERLAP) {
+    const int BORDERSIZE = 2;
+    const int WINDOWSIZE = 100;
+
+    const int MONITORGAP = 10;
+    const int GAPSOUT    = 20;
+    const int RESP       = (RESPECTGAPS ? GAPSOUT : 0);
+    const int GAP        = RESP + (OVERLAP ? 0 : BORDERSIZE);
+    const int END        = GAP + WINDOWSIZE;
+
+    int       x;
+    Vector2D  predict;
+
+    x = MONITORGAP + GAP;
+    expectSnapMove({x, x}, nullptr);
+    x -= 1;
+    expectSnapMove({x, x}, &(predict = {GAP, GAP}));
+
+    x = MONITORGAP + END;
+    expectSnapMove({1920 - x, 1080 - x}, nullptr);
+    x -= 1;
+    expectSnapMove({1920 - x, 1080 - x}, &(predict = {1920 - END, 1080 - END}));
+
+    // test reserved area
+    const int RESERVED = 200;
+    const int RGAP     = RESERVED + RESP + BORDERSIZE;
+    const int REND     = RGAP + WINDOWSIZE;
+
+    x = MONITORGAP + RGAP;
+    expectSnapMove({x, x}, nullptr);
+    x -= 1;
+    expectSnapMove({x, x}, &(predict = {RGAP, RGAP}));
+
+    x = MONITORGAP + REND;
+    expectSnapMove({1920 - x, 1080 - x}, nullptr);
+    x -= 1;
+    expectSnapMove({1920 - x, 1080 - x}, &(predict = {1920 - REND, 1080 - REND}));
+}
+
+static bool test() {
+    NLog::log("{}Testing snap", Colors::GREEN);
+
+    // move to monitor HEADLESS-2
+    NLog::log("{}Moving to monitor HEADLESS-2", Colors::YELLOW);
+    OK(getFromSocket("/dispatch focusmonitor HEADLESS-2"));
+    NLog::log("{}Adding reserved monitor area to HEADLESS-2", Colors::YELLOW);
+    OK(getFromSocket("/keyword monitor HEADLESS-2,addreserved,200,200,200,200"));
+
+    // test on workspace "snap"
+    NLog::log("{}Dispatching workspace `snap`", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace name:snap"));
+
+    // spawn a kitty terminal and move to (500,500)
+    NLog::log("{}Spawning kittyProcA", Colors::YELLOW);
+    if (!spawnFloatingKitty())
+        return false;
+
+    NLog::log("{}Expecting 1 window", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 1);
+
+    NLog::log("{}Move the kitty window to (500,500)", Colors::YELLOW);
+    OK(getFromSocket("/dispatch moveactive exact 500 500"));
+
+    // spawn a second kitty terminal
+    NLog::log("{}Spawning kittyProcB", Colors::YELLOW);
+    if (!spawnFloatingKitty())
+        return false;
+
+    NLog::log("{}Expecting 2 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 2);
+
+    NLog::log("");
+    testWindowSnap(false);
+    testMonitorSnap(false, false);
+
+    NLog::log("\n{}Turning on respect_gaps", Colors::YELLOW);
+    OK(getFromSocket("/keyword general:snap:respect_gaps true"));
+    testWindowSnap(true);
+    testMonitorSnap(true, false);
+
+    NLog::log("\n{}Turning on border_overlap", Colors::YELLOW);
+    OK(getFromSocket("/keyword general:snap:respect_gaps false"));
+    OK(getFromSocket("/keyword general:snap:border_overlap true"));
+    testMonitorSnap(false, true);
+
+    NLog::log("\n{}Turning on both border_overlap and respect_gaps", Colors::YELLOW);
+    OK(getFromSocket("/keyword general:snap:respect_gaps true"));
+    testMonitorSnap(true, true);
+
+    // kill all
+    NLog::log("\n{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+
+    NLog::log("{}Reloading the config", Colors::YELLOW);
+    OK(getFromSocket("/reload"));
+    OK(getFromSocket("/dispatch workspace 1"));
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test)

hyprtester/src/tests/main/solitary.cpp

@@ -0,0 +1,76 @@
+#include "tests.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include <thread>
+#include <chrono>
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include "../shared.hpp"
+
+static int ret = 0;
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+#define UP CUniquePointer
+#define SP CSharedPointer
+
+static bool test() {
+    NLog::log("{}Testing solitary clients", Colors::GREEN);
+
+    OK(getFromSocket("/keyword general:allow_tearing false"));
+    OK(getFromSocket("/keyword render:direct_scanout 0"));
+    OK(getFromSocket("/keyword cursor:no_hardware_cursors 1"));
+    NLog::log("{}Expecting blocked solitary/DS/tearing", Colors::YELLOW);
+    {
+        auto str = getFromSocket("/monitors");
+        EXPECT_CONTAINS(str, "solitary: 0\n");
+        EXPECT_CONTAINS(str, "solitaryBlockedBy: windowed mode,missing candidate");
+        EXPECT_CONTAINS(str, "activelyTearing: false");
+        EXPECT_CONTAINS(str, "tearingBlockedBy: next frame is not torn,user settings,not supported by monitor,missing candidate");
+        EXPECT_CONTAINS(str, "directScanoutTo: 0\n");
+        EXPECT_CONTAINS(str, "directScanoutBlockedBy: user settings,software renders/cursors,missing candidate");
+    }
+
+    // FIXME: need a reliable client with solitary opaque surface in fullscreen. kitty doesn't work all the time
+    // NLog::log("{}Spawning kittyProcA", Colors::YELLOW);
+    // auto kittyProcA = Tests::spawnKitty();
+
+    // if (!kittyProcA) {
+    //     NLog::log("{}Error: kitty did not spawn", Colors::RED);
+    //     return false;
+    // }
+
+    // OK(getFromSocket("/keyword general:allow_tearing true"));
+    // OK(getFromSocket("/keyword render:direct_scanout 1"));
+    // NLog::log("{}", getFromSocket("/clients"));
+    // OK(getFromSocket("/dispatch fullscreen"));
+    // NLog::log("{}", getFromSocket("/clients"));
+    // std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    // NLog::log("{}Expecting kitty to almost pass for solitary/DS/tearing", Colors::YELLOW);
+    // {
+    //     auto str = getFromSocket("/monitors");
+    //     EXPECT_NOT_CONTAINS(str, "solitary: 0\n");
+    //     EXPECT_CONTAINS(str, "solitaryBlockedBy: null");
+    //     EXPECT_CONTAINS(str, "activelyTearing: false");
+    //     EXPECT_CONTAINS(str, "tearingBlockedBy: next frame is not torn,not supported by monitor,window settings");
+    // }
+
+    // OK(getFromSocket("/dispatch setprop active immediate 1"));
+    // NLog::log("{}Expecting kitty to almost pass for tearing", Colors::YELLOW);
+    // {
+    //     auto str = getFromSocket("/monitors");
+    //     EXPECT_CONTAINS(str, "tearingBlockedBy: next frame is not torn,not supported by monitor\n");
+    // }
+
+    // // kill all
+    // NLog::log("{}Killing all windows", Colors::YELLOW);
+    // Tests::killAllWindows();
+
+    NLog::log("{}Reloading the config", Colors::YELLOW);
+    OK(getFromSocket("/reload"));
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test)

hyprtester/src/tests/main/tags.cpp

@@ -0,0 +1,51 @@
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include "../shared.hpp"
+#include "tests.hpp"
+
+static int  ret = 0;
+
+static bool testTags() {
+    NLog::log("{}Testing tags", Colors::GREEN);
+
+    EXPECT(Tests::windowCount(), 0);
+
+    NLog::log("{}Spawning kittyProcA&B on ws 1", Colors::YELLOW);
+    auto kittyProcA = Tests::spawnKitty("tagged");
+    auto kittyProcB = Tests::spawnKitty("untagged");
+
+    if (!kittyProcA || !kittyProcB) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        return false;
+    }
+
+    NLog::log("{}Testing testTag tags", Colors::YELLOW);
+
+    OK(getFromSocket("/keyword windowrule[tag-test-1]:tag +testTag"));
+    OK(getFromSocket("/keyword windowrule[tag-test-1]:match:class tagged"));
+    OK(getFromSocket("/keyword windowrule[tag-test-2]:match:tag negative:testTag"));
+    OK(getFromSocket("/keyword windowrule[tag-test-2]:no_shadow true"));
+    OK(getFromSocket("/keyword windowrule[tag-test-3]:match:tag testTag"));
+    OK(getFromSocket("/keyword windowrule[tag-test-3]:no_dim true"));
+
+    EXPECT(Tests::windowCount(), 2);
+    OK(getFromSocket("/dispatch focuswindow class:tagged"));
+    NLog::log("{}Testing tagged window for no_dim 0 & no_shadow", Colors::YELLOW);
+    EXPECT_CONTAINS(getFromSocket("/activewindow"), "testTag");
+    EXPECT_CONTAINS(getFromSocket("/getprop activewindow no_dim"), "true");
+    EXPECT_CONTAINS(getFromSocket("/getprop activewindow no_shadow"), "false");
+    NLog::log("{}Testing untagged window for no_dim & no_shadow", Colors::YELLOW);
+    OK(getFromSocket("/dispatch focuswindow class:untagged"));
+    EXPECT_NOT_CONTAINS(getFromSocket("/activewindow"), "testTag");
+    EXPECT_CONTAINS(getFromSocket("/getprop activewindow no_shadow"), "true");
+    EXPECT_CONTAINS(getFromSocket("/getprop activewindow no_dim"), "false");
+
+    Tests::killAllWindows();
+    EXPECT(Tests::windowCount(), 0);
+
+    OK(getFromSocket("/reload"));
+
+    return ret == 0;
+}
+
+REGISTER_TEST_FN(testTags)

hyprtester/src/tests/main/tests.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <vector>
+#include <functional>
+
+inline std::vector<std::function<bool()>> testFns;
+
+#define REGISTER_TEST_FN(fn)                                                                                                                                                       \
+    static auto _register_fn = [] {                                                                                                                                                \
+        testFns.emplace_back(fn);                                                                                                                                                  \
+        return 1;                                                                                                                                                                  \
+    }();

hyprtester/src/tests/main/window.cpp

@@ -0,0 +1,760 @@
+#include <cmath>
+#include <chrono>
+#include <cstdlib>
+#include <cstring>
+#include <filesystem>
+#include <thread>
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include <hyprutils/string/VarList2.hpp>
+
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include "../shared.hpp"
+#include "tests.hpp"
+
+static int  ret = 0;
+
+static bool spawnKitty(const std::string& class_, const std::vector<std::string>& args = {}) {
+    NLog::log("{}Spawning {}", Colors::YELLOW, class_);
+    if (!Tests::spawnKitty(class_, args)) {
+        NLog::log("{}Error: {} did not spawn", Colors::RED, class_);
+        return false;
+    }
+    return true;
+}
+
+static std::string getWindowAttribute(const std::string& winInfo, const std::string& attr) {
+    auto pos = winInfo.find(attr);
+    if (pos == std::string::npos) {
+        NLog::log("{}Wrong window attribute", Colors::RED);
+        ret = 1;
+        return "Wrong window attribute";
+    }
+    auto pos2 = winInfo.find('\n', pos);
+    return winInfo.substr(pos, pos2 - pos);
+}
+
+static std::string getWindowAddress(const std::string& winInfo) {
+    auto pos  = winInfo.find("Window ");
+    auto pos2 = winInfo.find(" -> ");
+    if (pos == std::string::npos || pos2 == std::string::npos) {
+        NLog::log("{}Wrong window info", Colors::RED);
+        ret = 1;
+        return "Wrong window info";
+    }
+    return winInfo.substr(pos + 7, pos2 - pos - 7);
+}
+
+static void testSwapWindow() {
+    NLog::log("{}Testing swapwindow", Colors::GREEN);
+
+    // test on workspace "swapwindow"
+    NLog::log("{}Switching to workspace \"swapwindow\"", Colors::YELLOW);
+    getFromSocket("/dispatch workspace name:swapwindow");
+
+    if (!Tests::spawnKitty("kitty_A")) {
+        ret = 1;
+        return;
+    }
+
+    if (!Tests::spawnKitty("kitty_B")) {
+        ret = 1;
+        return;
+    }
+
+    NLog::log("{}Expecting 2 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 2);
+
+    // Test swapwindow by direction
+    {
+        getFromSocket("/dispatch focuswindow class:kitty_A");
+        auto pos = getWindowAttribute(getFromSocket("/activewindow"), "at:");
+        NLog::log("{}Testing kitty_A {}, swapwindow with direction 'l'", Colors::YELLOW, pos);
+
+        OK(getFromSocket("/dispatch swapwindow l"));
+        OK(getFromSocket("/dispatch focuswindow class:kitty_B"));
+
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), std::format("{}", pos));
+    }
+
+    // Test swapwindow by class
+    {
+        getFromSocket("/dispatch focuswindow class:kitty_A");
+        auto pos = getWindowAttribute(getFromSocket("/activewindow"), "at:");
+        NLog::log("{}Testing kitty_A {}, swapwindow with class:kitty_B", Colors::YELLOW, pos);
+
+        OK(getFromSocket("/dispatch swapwindow class:kitty_B"));
+        OK(getFromSocket("/dispatch focuswindow class:kitty_B"));
+
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), std::format("{}", pos));
+    }
+
+    // Test swapwindow by address
+    {
+        getFromSocket("/dispatch focuswindow class:kitty_B");
+        auto addr = getWindowAddress(getFromSocket("/activewindow"));
+        getFromSocket("/dispatch focuswindow class:kitty_A");
+        auto pos = getWindowAttribute(getFromSocket("/activewindow"), "at:");
+        NLog::log("{}Testing kitty_A {}, swapwindow with address:0x{}(kitty_B)", Colors::YELLOW, pos, addr);
+
+        OK(getFromSocket(std::format("/dispatch swapwindow address:0x{}", addr)));
+        OK(getFromSocket(std::format("/dispatch focuswindow address:0x{}", addr)));
+
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), std::format("{}", pos));
+    }
+
+    NLog::log("{}Testing swapwindow with fullscreen. Expecting to fail", Colors::YELLOW);
+    {
+        OK(getFromSocket("/dispatch fullscreen"));
+
+        auto str = getFromSocket("/dispatch swapwindow l");
+        EXPECT_CONTAINS(str, "Can't swap fullscreen window");
+
+        OK(getFromSocket("/dispatch fullscreen"));
+    }
+
+    NLog::log("{}Testing swapwindow with different workspace", Colors::YELLOW);
+    {
+        getFromSocket("/dispatch focuswindow class:kitty_B");
+        auto addr = getWindowAddress(getFromSocket("/activewindow"));
+        auto ws   = getWindowAttribute(getFromSocket("/activewindow"), "workspace:");
+        NLog::log("{}Sending address:0x{}(kitty_B) to workspace \"swapwindow2\"", Colors::YELLOW, addr);
+
+        OK(getFromSocket("/dispatch movetoworkspacesilent name:swapwindow2"));
+        OK(getFromSocket(std::format("/dispatch swapwindow address:0x{}", addr)));
+        getFromSocket("/dispatch focuswindow class:kitty_B");
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), std::format("{}", ws));
+    }
+
+    // kill all
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+}
+
+static void testGroupRules() {
+    NLog::log("{}Testing group window rules", Colors::YELLOW);
+
+    OK(getFromSocket("/keyword general:border_size 8"));
+    OK(getFromSocket("/keyword workspace w[tv1], bordersize:0"));
+    OK(getFromSocket("/keyword workspace f[1], bordersize:0"));
+    OK(getFromSocket("/keyword windowrule match:workspace w[tv1], border_size 0"));
+    OK(getFromSocket("/keyword windowrule match:workspace f[1], border_size 0"));
+
+    if (!Tests::spawnKitty("kitty_A")) {
+        ret = 1;
+        return;
+    }
+
+    {
+        auto str = getFromSocket("/getprop active border_size");
+        EXPECT_CONTAINS(str, "0");
+    }
+
+    if (!Tests::spawnKitty("kitty_B")) {
+        ret = 1;
+        return;
+    }
+
+    {
+        auto str = getFromSocket("/getprop active border_size");
+        EXPECT_CONTAINS(str, "8");
+    }
+
+    OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+    OK(getFromSocket("/dispatch togglegroup"));
+    OK(getFromSocket("/dispatch focuswindow class:kitty_B"));
+    OK(getFromSocket("/dispatch moveintogroup l"));
+
+    {
+        auto str = getFromSocket("/getprop active border_size");
+        EXPECT_CONTAINS(str, "0");
+    }
+
+    OK(getFromSocket("/dispatch changegroupactive f"));
+
+    {
+        auto str = getFromSocket("/getprop active border_size");
+        EXPECT_CONTAINS(str, "0");
+    }
+
+    if (!Tests::spawnKitty("kitty_C")) {
+        ret = 1;
+        return;
+    }
+
+    OK(getFromSocket("/dispatch moveoutofgroup r"));
+
+    {
+        auto str = getFromSocket("/getprop active border_size");
+        EXPECT_CONTAINS(str, "8");
+    }
+
+    OK(getFromSocket("/reload"));
+    Tests::killAllWindows();
+}
+
+static bool isActiveWindow(const std::string& class_, char fullscreen, bool log = true) {
+    std::string activeWin     = getFromSocket("/activewindow");
+    auto        winClass      = getWindowAttribute(activeWin, "class:");
+    auto        winFullscreen = getWindowAttribute(activeWin, "fullscreen:").back();
+    if (winClass.substr(strlen("class: ")) == class_ && winFullscreen == fullscreen)
+        return true;
+    else {
+        if (log)
+            NLog::log("{}Wrong active window: expected class {} fullscreen '{}', found class {}, fullscreen '{}'", Colors::RED, class_, fullscreen, winClass, winFullscreen);
+        return false;
+    }
+}
+
+static bool waitForActiveWindow(const std::string& class_, char fullscreen, int maxTries = 50) {
+    int cnt = 0;
+    while (!isActiveWindow(class_, fullscreen, false)) {
+        ++cnt;
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        if (cnt > maxTries) {
+            return isActiveWindow(class_, fullscreen, true);
+        }
+    }
+    return true;
+}
+
+/// Tests behavior of a window being focused when on that window's workspace
+/// another fullscreen window exists.
+static bool testWindowFocusOnFullscreenConflict() {
+    if (!spawnKitty("kitty_A"))
+        return false;
+    if (!spawnKitty("kitty_B"))
+        return false;
+
+    OK(getFromSocket("/keyword misc:focus_on_activate true"));
+
+    auto spawnKittyActivating = [] -> std::string {
+        // `XXXXXX` is what `mkstemp` expects to find in the string
+        std::string tmpFilename = (std::filesystem::temp_directory_path() / "XXXXXX").string();
+        int         fd          = mkstemp(tmpFilename.data());
+        if (fd < 0) {
+            NLog::log("{}Error: could not create tmp file: errno {}", Colors::RED, errno);
+            return "";
+        }
+        (void)close(fd);
+        bool ok = spawnKitty("kitty_activating",
+                             {"-o", "allow_remote_control=yes", "--", "/bin/sh", "-c", "while [ -f \"" + tmpFilename + "\" ]; do :; done; kitten @ focus-window; sleep infinity"});
+        if (!ok) {
+            NLog::log("{}Error: failed to spawn kitty", Colors::RED);
+            return "";
+        }
+        return tmpFilename;
+    };
+
+    // Unfullscreen on conflict
+    {
+        OK(getFromSocket("/keyword misc:on_focus_under_fullscreen 2"));
+
+        OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+        OK(getFromSocket("/dispatch fullscreen 0 set"));
+        EXPECT(isActiveWindow("kitty_A", '2'), true);
+
+        // Dispatch-focus the same window
+        OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+        EXPECT(isActiveWindow("kitty_A", '2'), true);
+
+        // Dispatch-focus a different window
+        OK(getFromSocket("/dispatch focuswindow class:kitty_B"));
+        EXPECT(isActiveWindow("kitty_B", '0'), true);
+
+        // Make a window that will request focus
+        const std::string removeToActivate = spawnKittyActivating();
+        if (removeToActivate.empty())
+            return false;
+        OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+        OK(getFromSocket("/dispatch fullscreen 0 set"));
+        EXPECT(isActiveWindow("kitty_A", '2'), true);
+        std::filesystem::remove(removeToActivate);
+        EXPECT(waitForActiveWindow("kitty_activating", '0'), true);
+        OK(getFromSocket("/dispatch forcekillactive"));
+        Tests::waitUntilWindowsN(2);
+    }
+
+    // Take over on conflict
+    {
+        OK(getFromSocket("/keyword misc:on_focus_under_fullscreen 1"));
+
+        OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+        OK(getFromSocket("/dispatch fullscreen 0 set"));
+        EXPECT(isActiveWindow("kitty_A", '2'), true);
+
+        // Dispatch-focus the same window
+        OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+        EXPECT(isActiveWindow("kitty_A", '2'), true);
+
+        // Dispatch-focus a different window
+        OK(getFromSocket("/dispatch focuswindow class:kitty_B"));
+        EXPECT(isActiveWindow("kitty_B", '2'), true);
+        OK(getFromSocket("/dispatch fullscreenstate 0 0"));
+
+        // Make a window that will request focus
+        const std::string removeToActivate = spawnKittyActivating();
+        if (removeToActivate.empty())
+            return false;
+        OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+        OK(getFromSocket("/dispatch fullscreen 0 set"));
+        EXPECT(isActiveWindow("kitty_A", '2'), true);
+        std::filesystem::remove(removeToActivate);
+        EXPECT(waitForActiveWindow("kitty_activating", '2'), true);
+        OK(getFromSocket("/dispatch forcekillactive"));
+        Tests::waitUntilWindowsN(2);
+    }
+
+    // Keep the old focus on conflict
+    {
+        OK(getFromSocket("/keyword misc:on_focus_under_fullscreen 0"));
+
+        OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+        OK(getFromSocket("/dispatch fullscreen 0 set"));
+        EXPECT(isActiveWindow("kitty_A", '2'), true);
+
+        // Dispatch-focus the same window
+        OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+        EXPECT(isActiveWindow("kitty_A", '2'), true);
+
+        // Make a window that will request focus - the setting is treated normally
+        const std::string removeToActivate = spawnKittyActivating();
+        if (removeToActivate.empty())
+            return false;
+        OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+        OK(getFromSocket("/dispatch fullscreen 0 set"));
+        EXPECT(isActiveWindow("kitty_A", '2'), true);
+        std::filesystem::remove(removeToActivate);
+        EXPECT(waitForActiveWindow("kitty_A", '2'), true);
+    }
+
+    NLog::log("{}Reloading config", Colors::YELLOW);
+    OK(getFromSocket("/reload"));
+
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+
+    return true;
+}
+
+static void testMaximizeSize() {
+    NLog::log("{}Testing maximize size", Colors::GREEN);
+
+    EXPECT(spawnKitty("kitty_A"), true);
+
+    // check kitty properties. Maximizing shouldnt change its size
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT(str.contains("at: 22,22"), true);
+        EXPECT(str.contains("size: 1876,1036"), true);
+        EXPECT(str.contains("fullscreen: 0"), true);
+    }
+
+    OK(getFromSocket("/dispatch fullscreen 1"));
+
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT(str.contains("at: 22,22"), true);
+        EXPECT(str.contains("size: 1876,1036"), true);
+        EXPECT(str.contains("fullscreen: 1"), true);
+    }
+
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+}
+
+static bool test() {
+    NLog::log("{}Testing windows", Colors::GREEN);
+
+    // test on workspace "window"
+    NLog::log("{}Switching to workspace `window`", Colors::YELLOW);
+    getFromSocket("/dispatch workspace name:window");
+
+    if (!spawnKitty("kitty_A"))
+        return false;
+
+    // check kitty properties. One kitty should take the entire screen, as this is smart gaps
+    NLog::log("{}Expecting kitty_A to take up the whole screen", Colors::YELLOW);
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT(str.contains("at: 0,0"), true);
+        EXPECT(str.contains("size: 1920,1080"), true);
+        EXPECT(str.contains("fullscreen: 0"), true);
+    }
+
+    NLog::log("{}Testing window split ratios", Colors::YELLOW);
+    {
+        const double INITIAL_RATIO = 1.25;
+        const int    GAPSIN        = 5;
+        const int    GAPSOUT       = 20;
+        const int    BORDERSIZE    = 2;
+        const int    BORDERS       = BORDERSIZE * 2;
+        const int    MONITOR_W     = 1920;
+        const int    MONITOR_H     = 1080;
+
+        const float  totalAvailableHeight   = MONITOR_H - (GAPSOUT * 2);
+        const int    HEIGHT                 = std::floor(totalAvailableHeight) - BORDERS;
+        const float  availableWidthForSplit = MONITOR_W - (GAPSOUT * 2) - GAPSIN;
+
+        auto         calculateFinalWidth = [&](double boxWidth, bool isLeftWindow) {
+            double gapLeft  = isLeftWindow ? GAPSOUT : GAPSIN;
+            double gapRight = isLeftWindow ? GAPSIN : GAPSOUT;
+            return std::floor(boxWidth - gapLeft - gapRight - BORDERS);
+        };
+
+        double       geomBoxWidthA_R1 = (availableWidthForSplit * INITIAL_RATIO / 2.0) + GAPSOUT + (GAPSIN / 2.0);
+        double       geomBoxWidthB_R1 = MONITOR_W - geomBoxWidthA_R1;
+        const int    WIDTH1           = calculateFinalWidth(geomBoxWidthB_R1, false);
+
+        const double INVERTED_RATIO   = 0.75;
+        double       geomBoxWidthA_R2 = (availableWidthForSplit * INVERTED_RATIO / 2.0) + GAPSOUT + (GAPSIN / 2.0);
+        double       geomBoxWidthB_R2 = MONITOR_W - geomBoxWidthA_R2;
+        const int    WIDTH2           = calculateFinalWidth(geomBoxWidthB_R2, false);
+        const int    WIDTH_A_FINAL    = calculateFinalWidth(geomBoxWidthA_R2, true);
+
+        OK(getFromSocket("/keyword dwindle:default_split_ratio 1.25"));
+
+        if (!spawnKitty("kitty_B"))
+            return false;
+
+        NLog::log("{}Expecting kitty_B size: {},{}", Colors::YELLOW, WIDTH1, HEIGHT);
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), std::format("size: {},{}", WIDTH1, HEIGHT));
+
+        OK(getFromSocket("/dispatch killwindow activewindow"));
+        Tests::waitUntilWindowsN(1);
+
+        NLog::log("{}Inverting the split ratio", Colors::YELLOW);
+        OK(getFromSocket("/keyword dwindle:default_split_ratio 0.75"));
+
+        if (!spawnKitty("kitty_B"))
+            return false;
+
+        try {
+            NLog::log("{}Expecting kitty_B size: {},{}", Colors::YELLOW, WIDTH2, HEIGHT);
+
+            {
+                auto data = getFromSocket("/activewindow");
+                data      = data.substr(data.find("size:") + 5);
+                data      = data.substr(0, data.find('\n'));
+
+                Hyprutils::String::CVarList2 sizes(std::move(data), 0, ',');
+
+                EXPECT_MAX_DELTA(std::stoi(std::string{sizes[0]}), WIDTH2, 2);
+                EXPECT_MAX_DELTA(std::stoi(std::string{sizes[1]}), HEIGHT, 2);
+            }
+
+            OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+            NLog::log("{}Expecting kitty_A size: {},{}", Colors::YELLOW, WIDTH_A_FINAL, HEIGHT);
+
+            {
+                auto data = getFromSocket("/activewindow");
+                data      = data.substr(data.find("size:") + 5);
+                data      = data.substr(0, data.find('\n'));
+
+                Hyprutils::String::CVarList2 sizes(std::move(data), 0, ',');
+
+                EXPECT_MAX_DELTA(std::stoi(std::string{sizes[0]}), WIDTH_A_FINAL, 2);
+                EXPECT_MAX_DELTA(std::stoi(std::string{sizes[1]}), HEIGHT, 2);
+            }
+
+        } catch (...) {
+            NLog::log("{}Exception thrown", Colors::RED);
+            EXPECT(false, true);
+        }
+
+        OK(getFromSocket("/keyword dwindle:default_split_ratio 1"));
+    }
+
+    // open xeyes
+    NLog::log("{}Spawning xeyes", Colors::YELLOW);
+    getFromSocket("/dispatch exec xeyes");
+
+    NLog::log("{}Keep checking if xeyes spawned", Colors::YELLOW);
+    Tests::waitUntilWindowsN(3);
+
+    NLog::log("{}Expecting 3 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 3);
+
+    NLog::log("{}Checking props of xeyes", Colors::YELLOW);
+    // check some window props of xeyes, try to tile them
+    {
+        auto str = getFromSocket("/clients");
+        EXPECT_CONTAINS(str, "floating: 1");
+        getFromSocket("/dispatch settiled class:XEyes");
+        std::this_thread::sleep_for(std::chrono::milliseconds(200));
+        str = getFromSocket("/clients");
+        EXPECT_NOT_CONTAINS(str, "floating: 1");
+    }
+
+    // kill all
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+
+    testSwapWindow();
+
+    getFromSocket("/dispatch workspace 1");
+
+    if (!testWindowFocusOnFullscreenConflict()) {
+        ret = 1;
+        return false;
+    }
+
+    NLog::log("{}Testing spawning a floating window over a fullscreen window", Colors::YELLOW);
+    {
+        if (!spawnKitty("kitty_A"))
+            return false;
+        OK(getFromSocket("/dispatch fullscreen 0 set"));
+        EXPECT(Tests::windowCount(), 1);
+
+        OK(getFromSocket("/dispatch exec [float] kitty"));
+        Tests::waitUntilWindowsN(2);
+
+        OK(getFromSocket("/dispatch focuswindow class:^kitty$"));
+        const auto focused1 = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(focused1, "class: kitty\n");
+
+        OK(getFromSocket("/dispatch killwindow activewindow"));
+        Tests::waitUntilWindowsN(1);
+
+        // The old window should be focused again
+        const auto focused2 = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(focused2, "class: kitty_A\n");
+
+        NLog::log("{}Killing all windows", Colors::YELLOW);
+        Tests::killAllWindows();
+    }
+
+    NLog::log("{}Testing minsize/maxsize rules for tiled windows", Colors::YELLOW);
+    {
+        // Enable the config for testing, test max/minsize for tiled windows and centering
+        OK(getFromSocket("/keyword misc:size_limits_tiled 1"));
+        OK(getFromSocket("/keyword windowrule[kitty-max-rule]:match:class kitty_maxsize"));
+        OK(getFromSocket("/keyword windowrule[kitty-max-rule]:max_size 1500 500"));
+        OK(getFromSocket("r/keyword windowrule[kitty-max-rule]:min_size 1200 500"));
+        if (!spawnKitty("kitty_maxsize"))
+            return false;
+
+        auto dwindle = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(dwindle, "size: 1500,500");
+        EXPECT_CONTAINS(dwindle, "at: 210,290");
+
+        if (!spawnKitty("kitty_maxsize"))
+            return false;
+
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "size: 1200,500");
+
+        Tests::killAllWindows();
+        EXPECT(Tests::windowCount(), 0);
+
+        OK(getFromSocket("/keyword general:layout master"));
+
+        if (!spawnKitty("kitty_maxsize"))
+            return false;
+
+        auto master = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(master, "size: 1500,500");
+        EXPECT_CONTAINS(master, "at: 210,290");
+
+        if (!spawnKitty("kitty_maxsize"))
+            return false;
+
+        OK(getFromSocket("/dispatch focuswindow class:kitty_maxsize"));
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "size: 1200,500")
+
+        NLog::log("{}Reloading config", Colors::YELLOW);
+        OK(getFromSocket("/reload"));
+        Tests::killAllWindows();
+        EXPECT(Tests::windowCount(), 0);
+    }
+
+    NLog::log("{}Testing window rules", Colors::YELLOW);
+    if (!spawnKitty("wr_kitty"))
+        return false;
+    {
+        auto      str  = getFromSocket("/activewindow");
+        const int SIZE = 200;
+        EXPECT_CONTAINS(str, "floating: 1");
+        EXPECT_CONTAINS(str, std::format("size: {},{}", SIZE, SIZE));
+        EXPECT_NOT_CONTAINS(str, "pinned: 1");
+    }
+
+    OK(getFromSocket("/keyword windowrule[wr-kitty-stuff]:opacity 0.5 0.5 override"));
+
+    {
+        auto str = getFromSocket("/getprop active opacity");
+        EXPECT_CONTAINS(str, "0.5");
+    }
+
+    OK(getFromSocket("/keyword windowrule[special-magic-kitty]:match:class magic_kitty"));
+    OK(getFromSocket("/keyword windowrule[special-magic-kitty]:workspace special:magic"));
+
+    if (!spawnKitty("magic_kitty"))
+        return false;
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "special:magic");
+        EXPECT_NOT_CONTAINS(str, "workspace: 9");
+    }
+
+    if (auto str = getFromSocket("/monitors"); str.contains("magic)")) {
+        OK(getFromSocket("/dispatch togglespecialworkspace magic"));
+    }
+
+    Tests::killAllWindows();
+
+    if (!spawnKitty("tag_kitty"))
+        return false;
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "floating: 1");
+    }
+
+    OK(getFromSocket("/reload"));
+    Tests::killAllWindows();
+
+    // test rules that overlap effects but don't overlap props
+    OK(getFromSocket("/keyword windowrule match:class overlap_kitty, border_size 0"));
+    OK(getFromSocket("/keyword windowrule match:fullscreen false, border_size 10"));
+
+    if (!spawnKitty("overlap_kitty"))
+        return false;
+
+    {
+        auto str = getFromSocket("/getprop active border_size");
+        EXPECT_CONTAINS(str, "10");
+    }
+
+    OK(getFromSocket("/reload"));
+    Tests::killAllWindows();
+
+    // test persistent_size between floating window launches
+    OK(getFromSocket("/keyword windowrule match:class persistent_size_kitty, persistent_size true, float true"));
+
+    if (!spawnKitty("persistent_size_kitty"))
+        return false;
+
+    OK(getFromSocket("/dispatch resizeactive exact 600 400"))
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "size: 600,400");
+        EXPECT_CONTAINS(str, "floating: 1");
+    }
+
+    Tests::killAllWindows();
+
+    if (!spawnKitty("persistent_size_kitty"))
+        return false;
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "size: 600,400");
+        EXPECT_CONTAINS(str, "floating: 1");
+    }
+
+    OK(getFromSocket("/reload"));
+    Tests::killAllWindows();
+
+    OK(getFromSocket("/keyword general:border_size 0"));
+    OK(getFromSocket("/keyword windowrule match:float true, border_size 10"));
+
+    if (!spawnKitty("border_kitty"))
+        return false;
+
+    {
+        auto str = getFromSocket("/getprop active border_size");
+        EXPECT_CONTAINS(str, "0");
+    }
+
+    OK(getFromSocket("/dispatch togglefloating"));
+
+    {
+        auto str = getFromSocket("/getprop active border_size");
+        EXPECT_CONTAINS(str, "10");
+    }
+
+    OK(getFromSocket("/dispatch togglefloating"));
+
+    {
+        auto str = getFromSocket("/getprop active border_size");
+        EXPECT_CONTAINS(str, "0");
+    }
+
+    OK(getFromSocket("/reload"));
+    Tests::killAllWindows();
+
+    // test expression rules
+    OK(getFromSocket("/keyword windowrule match:class expr_kitty, float yes, size monitor_w*0.5 monitor_h*0.5, move 20+(monitor_w*0.1) monitor_h*0.5"));
+
+    if (!spawnKitty("expr_kitty"))
+        return false;
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "floating: 1");
+        EXPECT_CONTAINS(str, "at: 212,540");
+        EXPECT_CONTAINS(str, "size: 960,540");
+    }
+
+    OK(getFromSocket("/reload"));
+    Tests::killAllWindows();
+
+    OK(getFromSocket("/dispatch plugin:test:add_rule"));
+    OK(getFromSocket("/reload"));
+
+    OK(getFromSocket("/keyword windowrule match:class plugin_kitty, plugin_rule effect"));
+
+    if (!spawnKitty("plugin_kitty"))
+        return false;
+
+    OK(getFromSocket("/dispatch plugin:test:check_rule"));
+
+    OK(getFromSocket("/reload"));
+    Tests::killAllWindows();
+
+    OK(getFromSocket("/dispatch plugin:test:add_rule"));
+    OK(getFromSocket("/reload"));
+
+    OK(getFromSocket("/keyword windowrule[test-plugin-rule]:match:class plugin_kitty"));
+    OK(getFromSocket("/keyword windowrule[test-plugin-rule]:plugin_rule effect"));
+
+    if (!spawnKitty("plugin_kitty"))
+        return false;
+
+    OK(getFromSocket("/dispatch plugin:test:check_rule"));
+
+    OK(getFromSocket("/reload"));
+    Tests::killAllWindows();
+
+    testGroupRules();
+
+    testMaximizeSize();
+
+    NLog::log("{}Reloading config", Colors::YELLOW);
+    OK(getFromSocket("/reload"));
+
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test)

hyprtester/src/tests/main/workspaces.cpp

@@ -0,0 +1,460 @@
+#include "tests.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include <print>
+#include <thread>
+#include <chrono>
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include <hyprutils/utils/ScopeGuard.hpp>
+#include <csignal>
+#include <cerrno>
+#include "../shared.hpp"
+
+static int ret = 0;
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+using namespace Hyprutils::Utils;
+
+#define UP CUniquePointer
+#define SP CSharedPointer
+
+static bool testAsymmetricGaps() {
+    NLog::log("{}Testing asymmetric gap splits", Colors::YELLOW);
+    {
+
+        CScopeGuard guard = {[&]() {
+            NLog::log("{}Cleaning up asymmetric gap test", Colors::YELLOW);
+            Tests::killAllWindows();
+            OK(getFromSocket("/reload"));
+        }};
+
+        OK(getFromSocket("/dispatch workspace name:gap_split_test"));
+        OK(getFromSocket("r/keyword general:gaps_in 0"));
+        OK(getFromSocket("r/keyword general:border_size 0"));
+        OK(getFromSocket("r/keyword dwindle:split_width_multiplier 1.0"));
+        OK(getFromSocket("r/keyword workspace name:gap_split_test,gapsout:0 1000 0 0"));
+
+        NLog::log("{}Testing default split (force_split = 0)", Colors::YELLOW);
+        OK(getFromSocket("r/keyword dwindle:force_split 0"));
+
+        if (!Tests::spawnKitty("gaps_kitty_A") || !Tests::spawnKitty("gaps_kitty_B"))
+            return false;
+
+        NLog::log("{}Expecting vertical split (B below A)", Colors::YELLOW);
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_A"));
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "at: 0,0");
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_B"));
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "at: 0,540");
+
+        Tests::killAllWindows();
+        EXPECT(Tests::windowCount(), 0);
+
+        NLog::log("{}Testing force_split = 1", Colors::YELLOW);
+        OK(getFromSocket("r/keyword dwindle:force_split 1"));
+
+        if (!Tests::spawnKitty("gaps_kitty_A") || !Tests::spawnKitty("gaps_kitty_B"))
+            return false;
+
+        NLog::log("{}Expecting vertical split (B above A)", Colors::YELLOW);
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_B"));
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "at: 0,0");
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_A"));
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "at: 0,540");
+
+        NLog::log("{}Expecting horizontal split (C left of B)", Colors::YELLOW);
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_B"));
+
+        if (!Tests::spawnKitty("gaps_kitty_C"))
+            return false;
+
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_C"));
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "at: 0,0");
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_B"));
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "at: 460,0");
+
+        Tests::killAllWindows();
+        EXPECT(Tests::windowCount(), 0);
+
+        NLog::log("{}Testing force_split = 2", Colors::YELLOW);
+        OK(getFromSocket("r/keyword dwindle:force_split 2"));
+
+        if (!Tests::spawnKitty("gaps_kitty_A") || !Tests::spawnKitty("gaps_kitty_B"))
+            return false;
+
+        NLog::log("{}Expecting vertical split (B below A)", Colors::YELLOW);
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_A"));
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "at: 0,0");
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_B"));
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "at: 0,540");
+
+        NLog::log("{}Expecting horizontal split (C right of A)", Colors::YELLOW);
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_A"));
+
+        if (!Tests::spawnKitty("gaps_kitty_C"))
+            return false;
+
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_A"));
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "at: 0,0");
+        OK(getFromSocket("/dispatch focuswindow class:gaps_kitty_C"));
+        EXPECT_CONTAINS(getFromSocket("/activewindow"), "at: 460,0");
+    }
+
+    // kill all
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    return true;
+}
+
+static bool test() {
+    NLog::log("{}Testing workspaces", Colors::GREEN);
+
+    EXPECT(Tests::windowCount(), 0);
+
+    // test on workspace "window"
+    NLog::log("{}Switching to workspace 1", Colors::YELLOW);
+    getFromSocket("/dispatch workspace 1");
+
+    NLog::log("{}Checking persistent no-mon", Colors::YELLOW);
+    OK(getFromSocket("r/keyword workspace 966,persistent:1"));
+
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_CONTAINS(str, "workspace ID 966 (966)");
+    }
+
+    OK(getFromSocket("/reload"));
+
+    NLog::log("{}Spawning kittyProc on ws 1", Colors::YELLOW);
+    auto kittyProcA = Tests::spawnKitty();
+
+    if (!kittyProcA) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        return false;
+    }
+
+    NLog::log("{}Switching to workspace 3", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace 3"));
+
+    NLog::log("{}Spawning kittyProc on ws 3", Colors::YELLOW);
+    auto kittyProcB = Tests::spawnKitty();
+
+    if (!kittyProcB) {
+        NLog::log("{}Error: kitty did not spawn", Colors::RED);
+        return false;
+    }
+
+    NLog::log("{}Switching to workspace 1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace 1"));
+
+    NLog::log("{}Switching to workspace +1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace +1"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 2 (2)");
+    }
+
+    // check if the other workspaces are alive
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_CONTAINS(str, "workspace ID 3 (3)");
+        EXPECT_CONTAINS(str, "workspace ID 1 (1)");
+    }
+
+    NLog::log("{}Switching to workspace 1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace 1"));
+
+    {
+        auto str = getFromSocket("/workspaces");
+        EXPECT_NOT_CONTAINS(str, "workspace ID 2 (2)");
+    }
+
+    NLog::log("{}Switching to workspace m+1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace m+1"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 3 (3)");
+    }
+
+    NLog::log("{}Switching to workspace -1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace -1"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 2 (2)");
+    }
+
+    NLog::log("{}Switching to workspace 1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace 1"));
+
+    NLog::log("{}Switching to workspace r+1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace r+1"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 2 (2)");
+    }
+
+    NLog::log("{}Switching to workspace r+1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace r+1"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 3 (3)");
+    }
+
+    NLog::log("{}Switching to workspace r~1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace r~1"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 1 (1)");
+    }
+
+    NLog::log("{}Switching to workspace empty", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace empty"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 2 (2)");
+    }
+
+    NLog::log("{}Switching to workspace previous", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace previous"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 1 (1)");
+    }
+
+    NLog::log("{}Switching to workspace name:TEST_WORKSPACE_NULL", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace name:TEST_WORKSPACE_NULL"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID -1337 (TEST_WORKSPACE_NULL)");
+    }
+
+    NLog::log("{}Switching to workspace 1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace 1"));
+
+    // add a new monitor
+    NLog::log("{}Adding a new monitor", Colors::YELLOW);
+    EXPECT(getFromSocket("/output create headless"), "ok")
+
+    // should take workspace 2
+    {
+        auto str = getFromSocket("/monitors");
+        EXPECT_CONTAINS(str, "active workspace: 2 (2)");
+        EXPECT_CONTAINS(str, "active workspace: 1 (1)");
+        EXPECT_CONTAINS(str, "HEADLESS-3");
+    }
+
+    // focus the first monitor
+    OK(getFromSocket("/dispatch focusmonitor 0"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 1 (1)");
+    }
+
+    NLog::log("{}Switching to workspace r+1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace r+1"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 3 (3)");
+    }
+
+    NLog::log("{}Switching to workspace r~2", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace 1"));
+    OK(getFromSocket("/dispatch workspace r~2"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 3 (3)");
+    }
+
+    NLog::log("{}Switching to workspace m+1", Colors::YELLOW);
+    OK(getFromSocket("/dispatch workspace m+1"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 1 (1)");
+    }
+
+    NLog::log("{}Switching to workspace 1", Colors::YELLOW);
+    // no OK: this will throw an error as it should
+    getFromSocket("/dispatch workspace 1");
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 1 (1)");
+    }
+
+    NLog::log("{}Testing back_and_forth", Colors::YELLOW);
+    OK(getFromSocket("/keyword binds:workspace_back_and_forth true"));
+    OK(getFromSocket("/dispatch workspace 1"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 3 (3)");
+    }
+
+    OK(getFromSocket("/keyword binds:workspace_back_and_forth false"));
+
+    NLog::log("{}Testing hide_special_on_workspace_change", Colors::YELLOW);
+    OK(getFromSocket("/keyword binds:hide_special_on_workspace_change true"));
+    OK(getFromSocket("/dispatch workspace special:HELLO"));
+
+    {
+        auto str = getFromSocket("/monitors");
+        EXPECT_CONTAINS(str, "special workspace: -");
+        EXPECT_CONTAINS(str, "special:HELLO");
+    }
+
+    // no OK: will err (it shouldn't prolly but oh well)
+    getFromSocket("/dispatch workspace 3");
+
+    {
+        auto str = getFromSocket("/monitors");
+        EXPECT_COUNT_STRING(str, "special workspace: 0 ()", 2);
+    }
+
+    OK(getFromSocket("/keyword binds:hide_special_on_workspace_change false"));
+
+    NLog::log("{}Testing allow_workspace_cycles", Colors::YELLOW);
+    OK(getFromSocket("/keyword binds:allow_workspace_cycles true"));
+
+    OK(getFromSocket("/dispatch workspace 1"));
+    OK(getFromSocket("/dispatch workspace 3"));
+    OK(getFromSocket("/dispatch workspace 1"));
+
+    OK(getFromSocket("/dispatch workspace previous"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 3 (3)");
+    }
+
+    OK(getFromSocket("/dispatch workspace previous"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 1 (1)");
+    }
+
+    OK(getFromSocket("/dispatch workspace previous"));
+
+    {
+        auto str = getFromSocket("/activeworkspace");
+        EXPECT_STARTS_WITH(str, "workspace ID 3 (3)");
+    }
+
+    OK(getFromSocket("/keyword binds:allow_workspace_cycles false"));
+
+    OK(getFromSocket("/dispatch workspace 1"));
+
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    // spawn 3 kitties
+    NLog::log("{}Testing focus_preferred_method", Colors::YELLOW);
+    OK(getFromSocket("/keyword dwindle:force_split 2"));
+    Tests::spawnKitty("kitty_A");
+    Tests::spawnKitty("kitty_B");
+    Tests::spawnKitty("kitty_C");
+    OK(getFromSocket("/keyword dwindle:force_split 0"));
+
+    // focus kitty 2: will be top right (dwindle)
+    OK(getFromSocket("/dispatch focuswindow class:kitty_B"));
+
+    // resize it to be a bit taller
+    OK(getFromSocket("/dispatch resizeactive +20 +20"));
+
+    // now we test focus methods.
+    OK(getFromSocket("/keyword binds:focus_preferred_method 0"));
+
+    OK(getFromSocket("/dispatch focuswindow class:kitty_C"));
+    OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+
+    OK(getFromSocket("/dispatch movefocus r"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "class: kitty_C");
+    }
+
+    OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+
+    OK(getFromSocket("/keyword binds:focus_preferred_method 1"));
+
+    OK(getFromSocket("/dispatch movefocus r"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "class: kitty_B");
+    }
+
+    NLog::log("{}Testing movefocus_cycles_fullscreen", Colors::YELLOW);
+    OK(getFromSocket("/dispatch focuswindow class:kitty_A"));
+    OK(getFromSocket("/dispatch focusmonitor HEADLESS-3"));
+    Tests::spawnKitty("kitty_D");
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "class: kitty_D");
+    }
+
+    OK(getFromSocket("/dispatch focusmonitor l"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "class: kitty_A");
+    }
+
+    OK(getFromSocket("/keyword binds:movefocus_cycles_fullscreen false"));
+    OK(getFromSocket("/dispatch fullscreen 0"));
+
+    OK(getFromSocket("/dispatch movefocus r"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "class: kitty_D");
+    }
+
+    OK(getFromSocket("/dispatch focusmonitor l"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "class: kitty_A");
+    }
+
+    OK(getFromSocket("/keyword binds:movefocus_cycles_fullscreen true"));
+
+    OK(getFromSocket("/dispatch movefocus r"));
+
+    {
+        auto str = getFromSocket("/activewindow");
+        EXPECT_CONTAINS(str, "class: kitty_B");
+    }
+
+    // destroy the headless output
+    OK(getFromSocket("/output remove HEADLESS-3"));
+
+    // kill all
+    NLog::log("{}Killing all windows", Colors::YELLOW);
+    Tests::killAllWindows();
+
+    testAsymmetricGaps();
+
+    NLog::log("{}Expecting 0 windows", Colors::YELLOW);
+    EXPECT(Tests::windowCount(), 0);
+
+    return !ret;
+}
+
+REGISTER_TEST_FN(test)

hyprtester/src/tests/plugin/plugin.cpp

@@ -0,0 +1,31 @@
+#include "plugin.hpp"
+#include "../../shared.hpp"
+#include "../../hyprctlCompat.hpp"
+#include <print>
+#include <thread>
+#include <chrono>
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include <csignal>
+#include <cerrno>
+#include "../shared.hpp"
+
+bool testPlugin() {
+    const auto RESPONSE = getFromSocket("/dispatch plugin:test:test");
+
+    if (RESPONSE != "ok") {
+        NLog::log("{}Plugin tests failed, plugin returned:\n{}{}", Colors::RED, Colors::RESET, RESPONSE);
+        return false;
+    }
+    return true;
+}
+
+bool testVkb() {
+    const auto RESPONSE = getFromSocket("/dispatch plugin:test:vkb");
+
+    if (RESPONSE != "ok") {
+        NLog::log("{}Vkb tests failed, tests returned:\n{}{}", Colors::RED, Colors::RESET, RESPONSE);
+        return false;
+    }
+    return true;
+}

hyprtester/src/tests/plugin/plugin.hpp

@@ -0,0 +1,4 @@
+#pragma once
+
+bool testPlugin();
+bool testVkb();

hyprtester/src/tests/shared.cpp

@@ -0,0 +1,107 @@
+#include "shared.hpp"
+#include <csignal>
+#include <cerrno>
+#include <thread>
+#include <print>
+#include "../shared.hpp"
+#include "../hyprctlCompat.hpp"
+
+using namespace Hyprutils::OS;
+using namespace Hyprutils::Memory;
+
+CUniquePointer<CProcess> Tests::spawnKitty(const std::string& class_, const std::vector<std::string> args) {
+    const auto               COUNT_BEFORE = windowCount();
+
+    std::vector<std::string> programArgs = args;
+    if (!class_.empty()) {
+        programArgs.insert(programArgs.begin(), "--class");
+        programArgs.insert(programArgs.begin() + 1, class_);
+    }
+    CUniquePointer<CProcess> kitty = makeUnique<CProcess>("kitty", programArgs);
+    kitty->addEnv("WAYLAND_DISPLAY", WLDISPLAY);
+    kitty->runAsync();
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+
+    // wait while kitty spawns
+    int counter = 0;
+    while (processAlive(kitty->pid()) && windowCount() == COUNT_BEFORE) {
+        counter++;
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+        if (counter > 50)
+            return nullptr;
+    }
+
+    if (!processAlive(kitty->pid()))
+        return nullptr;
+
+    return kitty;
+}
+
+bool Tests::processAlive(pid_t pid) {
+    errno   = 0;
+    int ret = kill(pid, 0);
+    return ret != -1 || errno != ESRCH;
+}
+
+int Tests::windowCount() {
+    return countOccurrences(getFromSocket("/clients"), "focusHistoryID: ");
+}
+
+int Tests::countOccurrences(const std::string& in, const std::string& what) {
+    int  cnt = 0;
+    auto pos = in.find(what);
+    while (pos != std::string::npos) {
+        cnt++;
+        pos = in.find(what, pos + what.length());
+    }
+
+    return cnt;
+}
+
+bool Tests::killAllWindows() {
+    auto str = getFromSocket("/clients");
+    auto pos = str.find("Window ");
+    while (pos != std::string::npos) {
+        auto pos2 = str.find(" -> ", pos);
+        getFromSocket("/dispatch killwindow address:0x" + str.substr(pos + 7, pos2 - pos - 7));
+        pos = str.find("Window ", pos + 5);
+    }
+
+    int counter = 0;
+    while (Tests::windowCount() != 0) {
+        counter++;
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+        if (counter > 50) {
+            std::println("{}Timed out waiting for windows to close", Colors::RED);
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void Tests::waitUntilWindowsN(int n) {
+    int counter = 0;
+    while (Tests::windowCount() != n) {
+        counter++;
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+        if (counter > 50) {
+            std::println("{}Timed out waiting for windows", Colors::RED);
+            return;
+        }
+    }
+}
+
+std::string Tests::execAndGet(const std::string& cmd) {
+    CProcess proc("/bin/sh", {"-c", cmd});
+
+    if (!proc.runSync()) {
+        return "error";
+    }
+
+    return proc.stdOut();
+}

hyprtester/src/tests/shared.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <hyprutils/os/Process.hpp>
+#include <hyprutils/memory/WeakPtr.hpp>
+#include <sys/types.h>
+
+#include "../Log.hpp"
+
+//NOLINTNEXTLINE
+namespace Tests {
+    Hyprutils::Memory::CUniquePointer<Hyprutils::OS::CProcess> spawnKitty(const std::string& class_ = "", const std::vector<std::string> args = {});
+    bool                                                       processAlive(pid_t pid);
+    int                                                        windowCount();
+    int                                                        countOccurrences(const std::string& in, const std::string& what);
+    bool                                                       killAllWindows();
+    void                                                       waitUntilWindowsN(int n);
+    std::string                                                execAndGet(const std::string& cmd);
+};

hyprtester/test.conf

@@ -0,0 +1,400 @@
+# This is an example Hyprland config file.
+# Refer to the wiki for more information.
+# https://wiki.hyprland.org/Configuring/
+
+# Please note not all available settings / options are set here.
+# For a full list, see the wiki
+
+# You can split this configuration into multiple files
+# Create your files separately and then link them to this file like this:
+# source = ~/.config/hypr/myColors.conf
+
+
+################
+### MONITORS ###
+################
+
+# See https://wiki.hyprland.org/Configuring/Monitors/
+
+monitor=HEADLESS-1,1920x1080@60,auto-right,1
+monitor=HEADLESS-2,1920x1080@60,auto-right,1
+monitor=HEADLESS-3,1920x1080@60,auto-right,1
+monitor=HEADLESS-4,1920x1080@60,auto-right,1
+monitor=HEADLESS-5,1920x1080@60,auto-right,1
+monitor=HEADLESS-6,1920x1080@60,auto-right,1
+monitor=HEADLESS-PERSISTENT-TEST,1920x1080@60,auto-right,1
+
+monitor=,disabled
+
+
+###################
+### MY PROGRAMS ###
+###################
+
+# See https://wiki.hyprland.org/Configuring/Keywords/
+
+# Set programs that you use
+$terminal = kitty
+$fileManager = dolphin
+$menu = wofi --show drun
+
+
+#################
+### AUTOSTART ###
+#################
+
+# Autostart necessary processes (like notifications daemons, status bars, etc.)
+# Or execute your favorite apps at launch like this:
+
+exec-once = sleep 0  # Terminates very quickly
+# exec-once = $terminal
+# exec-once = nm-applet &
+# exec-once = waybar & hyprpaper & firefox
+
+
+#############################
+### ENVIRONMENT VARIABLES ###
+#############################
+
+# See https://wiki.hyprland.org/Configuring/Environment-variables/
+
+env = XCURSOR_SIZE,24
+env = HYPRCURSOR_SIZE,24
+
+
+#####################
+### LOOK AND FEEL ###
+#####################
+
+# Refer to https://wiki.hyprland.org/Configuring/Variables/
+
+# https://wiki.hyprland.org/Configuring/Variables/#general
+general {
+    gaps_in = 5
+    gaps_out = 20
+
+    border_size = 2
+
+    snap {
+        enabled = true
+        window_gap = 8
+        monitor_gap = 10
+        respect_gaps = false
+        border_overlap = false
+    }
+
+    # https://wiki.hyprland.org/Configuring/Variables/#variable-types for info about colors
+    col.active_border = rgba(33ccffee) rgba(00ff99ee) 45deg
+    col.inactive_border = rgba(595959aa)
+
+    # Set to true enable resizing windows by clicking and dragging on borders and gaps
+    resize_on_border = false
+
+    # Please see https://wiki.hyprland.org/Configuring/Tearing/ before you turn this on
+    allow_tearing = false
+
+    layout = dwindle
+}
+
+# https://wiki.hyprland.org/Configuring/Variables/#decoration
+decoration {
+    rounding = 10
+    rounding_power = 2
+
+    # Change transparency of focused and unfocused windows
+    active_opacity = 1.0
+    inactive_opacity = 1.0
+
+    shadow {
+        enabled = true
+        range = 4
+        render_power = 3
+        color = rgba(1a1a1aee)
+    }
+
+    # https://wiki.hyprland.org/Configuring/Variables/#blur
+    blur {
+        enabled = true
+        size = 3
+        passes = 1
+
+        vibrancy = 0.1696
+    }
+}
+
+# https://wiki.hyprland.org/Configuring/Variables/#animations
+animations {
+    enabled = 0
+
+    # Default animations, see https://wiki.hyprland.org/Configuring/Animations/ for more
+
+    bezier = easeOutQuint,0.23,1,0.32,1
+    bezier = easeInOutCubic,0.65,0.05,0.36,1
+    bezier = linear,0,0,1,1
+    bezier = almostLinear,0.5,0.5,0.75,1.0
+    bezier = quick,0.15,0,0.1,1
+
+    animation = global, 1, 10, default
+    animation = border, 1, 5.39, easeOutQuint
+    animation = windows, 1, 4.79, easeOutQuint
+    animation = windowsIn, 1, 4.1, easeOutQuint, popin 87%
+    animation = windowsOut, 1, 1.49, linear, popin 87%
+    animation = fadeIn, 1, 1.73, almostLinear
+    animation = fadeOut, 1, 1.46, almostLinear
+    animation = fade, 1, 3.03, quick
+    animation = layers, 1, 3.81, easeOutQuint
+    animation = layersIn, 1, 4, easeOutQuint, fade
+    animation = layersOut, 1, 1.5, linear, fade
+    animation = fadeLayersIn, 1, 1.79, almostLinear
+    animation = fadeLayersOut, 1, 1.39, almostLinear
+    animation = workspaces, 1, 1.94, almostLinear, fade
+    animation = workspacesIn, 1, 1.21, almostLinear, fade
+    animation = workspacesOut, 1, 1.94, almostLinear, fade
+}
+
+device {
+    name = test-mouse-1
+    enabled = true
+}
+
+# Ref https://wiki.hyprland.org/Configuring/Workspace-Rules/
+# "Smart gaps" / "No gaps when only"
+# uncomment all if you wish to use that.
+# workspace = w[tv1], gapsout:0, gapsin:0
+# workspace = f[1], gapsout:0, gapsin:0
+# windowrulev2 = bordersize 0, floating:0, onworkspace:w[tv1]
+# windowrulev2 = rounding 0, floating:0, onworkspace:w[tv1]
+# windowrulev2 = bordersize 0, floating:0, onworkspace:f[1]
+# windowrulev2 = rounding 0, floating:0, onworkspace:f[1]
+
+# See https://wiki.hyprland.org/Configuring/Dwindle-Layout/ for more
+dwindle {
+    pseudotile = true # Master switch for pseudotiling. Enabling is bound to mainMod + P in the keybinds section below
+    preserve_split = true # You probably want this
+    split_bias = 1
+}
+
+# See https://wiki.hyprland.org/Configuring/Master-Layout/ for more
+master {
+    new_status = master
+}
+
+# https://wiki.hyprland.org/Configuring/Variables/#misc
+misc {
+    force_default_wallpaper = -1 # Set to 0 or 1 to disable the anime mascot wallpapers
+    disable_hyprland_logo = false # If true disables the random hyprland logo / anime girl background. :(
+}
+
+
+#############
+### INPUT ###
+#############
+
+# https://wiki.hyprland.org/Configuring/Variables/#input
+input {
+    kb_layout = us
+    kb_variant =
+    kb_model =
+    kb_options =
+    kb_rules =
+
+    follow_mouse = 1
+
+    sensitivity = 0 # -1.0 - 1.0, 0 means no modification.
+
+    touchpad {
+        natural_scroll = false
+    }
+}
+
+# https://wiki.hyprland.org/Configuring/Variables/#gestures
+gestures {
+
+}
+
+# Example per-device config
+# See https://wiki.hyprland.org/Configuring/Keywords/#per-device-input-configs for more
+device {
+    name = epic-mouse-v1
+    sensitivity = -0.5
+}
+
+debug {
+    disable_logs = false
+}
+
+
+###################
+### KEYBINDINGS ###
+###################
+
+# See https://wiki.hyprland.org/Configuring/Keywords/
+$mainMod = SUPER # Sets "Windows" key as main modifier
+
+# Example binds, see https://wiki.hyprland.org/Configuring/Binds/ for more
+bind = $mainMod, Q, exec, $terminal
+bind = $mainMod, C, killactive,
+bind = $mainMod, M, exit,
+bind = $mainMod, E, exec, $fileManager
+bind = $mainMod, V, togglefloating,
+bind = $mainMod, R, exec, $menu
+bind = $mainMod, P, pseudo, # dwindle
+bind = $mainMod, J, togglesplit, # dwindle
+
+# Move focus with mainMod + arrow keys
+bind = $mainMod, left, movefocus, l
+bind = $mainMod, right, movefocus, r
+bind = $mainMod, up, movefocus, u
+bind = $mainMod, down, movefocus, d
+
+# Switch workspaces with mainMod + [0-9]
+bind = $mainMod, 1, workspace, 1
+bind = $mainMod, 2, workspace, 2
+bind = $mainMod, 3, workspace, 3
+bind = $mainMod, 4, workspace, 4
+bind = $mainMod, 5, workspace, 5
+bind = $mainMod, 6, workspace, 6
+bind = $mainMod, 7, workspace, 7
+bind = $mainMod, 8, workspace, 8
+bind = $mainMod, 9, workspace, 9
+bind = $mainMod, 0, workspace, 10
+
+# Move active window to a workspace with mainMod + SHIFT + [0-9]
+bind = $mainMod SHIFT, 1, movetoworkspace, 1
+bind = $mainMod SHIFT, 2, movetoworkspace, 2
+bind = $mainMod SHIFT, 3, movetoworkspace, 3
+bind = $mainMod SHIFT, 4, movetoworkspace, 4
+bind = $mainMod SHIFT, 5, movetoworkspace, 5
+bind = $mainMod SHIFT, 6, movetoworkspace, 6
+bind = $mainMod SHIFT, 7, movetoworkspace, 7
+bind = $mainMod SHIFT, 8, movetoworkspace, 8
+bind = $mainMod SHIFT, 9, movetoworkspace, 9
+bind = $mainMod SHIFT, 0, movetoworkspace, 10
+
+# Example special workspace (scratchpad)
+bind = $mainMod, S, togglespecialworkspace, magic
+bind = $mainMod SHIFT, S, movetoworkspace, special:magic
+
+# Scroll through existing workspaces with mainMod + scroll
+bind = $mainMod, mouse_down, workspace, e+1
+bind = $mainMod, mouse_up, workspace, e-1
+
+# Move/resize windows with mainMod + LMB/RMB and dragging
+bindm = $mainMod, mouse:272, movewindow
+bindm = $mainMod, mouse:273, resizewindow
+
+# Laptop multimedia keys for volume and LCD brightness
+bindel = ,XF86AudioRaiseVolume, exec, wpctl set-volume -l 1 @DEFAULT_AUDIO_SINK@ 5%+
+bindel = ,XF86AudioLowerVolume, exec, wpctl set-volume @DEFAULT_AUDIO_SINK@ 5%-
+bindel = ,XF86AudioMute, exec, wpctl set-mute @DEFAULT_AUDIO_SINK@ toggle
+bindel = ,XF86AudioMicMute, exec, wpctl set-mute @DEFAULT_AUDIO_SOURCE@ toggle
+bindel = ,XF86MonBrightnessUp, exec, brightnessctl s 10%+
+bindel = ,XF86MonBrightnessDown, exec, brightnessctl s 10%-
+
+# Requires playerctl
+bindl = , XF86AudioNext, exec, playerctl next
+bindl = , XF86AudioPause, exec, playerctl play-pause
+bindl = , XF86AudioPlay, exec, playerctl play-pause
+bindl = , XF86AudioPrev, exec, playerctl previous
+
+bind = $mainMod, u, submap, submap1
+
+submap = submap1
+bind = , u, submap, submap2
+bind = , i, submap, submap3
+bind = , o, exec, $terminal
+bind = , p, submap, reset
+
+submap = submap2, submap1
+bind = , o, exec, $terminal
+
+submap = submap3, reset
+bind = , o, exec, $terminal
+
+submap = reset
+
+
+##############################
+### WINDOWS AND WORKSPACES ###
+##############################
+
+windowrule {
+    # Ignore maximize requests from apps. You'll probably like this.
+    name = suppress-maximize-events
+    match:class = .*
+
+    suppress_event = maximize
+}
+
+windowrule {
+    # Fix some dragging issues with XWayland
+    name = fix-xwayland-drags
+    match:class = ^$
+    match:title = ^$
+    match:xwayland = true
+    match:float = true
+    match:fullscreen = false
+    match:pin = false
+
+    no_focus = true
+}
+
+workspace = n[s:window] w[tv1], gapsout:0, gapsin:0
+workspace = n[s:window] f[1], gapsout:0, gapsin:0
+
+windowrule {
+    name = smart-gaps-1
+    match:float = false
+    match:workspace = n[s:window] w[tv1]
+
+    border_size = 0
+    rounding = 0
+}
+
+windowrule {
+    name = smart-gaps-2
+    match:float = false
+    match:workspace = n[s:window] f[1]
+
+    border_size = 0
+    rounding = 0
+}
+
+windowrule {
+    name = wr-kitty-stuff
+    match:class = wr_kitty
+
+    float = true
+    size = 200 200
+    pin = false
+}
+
+windowrule {
+    name = tagged-kitty-floats
+    match:tag = tag_kitty
+
+    float = true
+}
+
+windowrule {
+    name = static-kitty-tag
+    match:class = tag_kitty
+
+    tag = +tag_kitty
+}
+
+gesture = 3, left, dispatcher, exec, kitty
+gesture = 3, right, float
+gesture = 3, up, close
+gesture = 3, down, fullscreen
+
+gesture = 3, down, mod:ALT, float
+
+gesture = 3, horizontal, mod:ALT, workspace
+
+gesture = 5, up, dispatcher, sendshortcut, , e, activewindow
+gesture = 5, down, dispatcher, sendshortcut, , x, activewindow
+gesture = 5, left, dispatcher, sendshortcut, , i, activewindow
+gesture = 5, right, dispatcher, sendshortcut, , t, activewindow
+gesture = 4, right, dispatcher, sendshortcut, , return, activewindow
+gesture = 4, left, dispatcher, movecursortocorner, 1

meson.build

@@ -1,129 +0,0 @@
-project(
-  'Hyprland',
-  'cpp',
-  'c',
-  version: run_command('cat', join_paths(meson.project_source_root(), 'VERSION'), check: true).stdout().strip(),
-  default_options: [
-    'warning_level=2',
-    'default_library=static',
-    'optimization=3',
-    'buildtype=release',
-    'debug=false',
-    'cpp_std=c++26',
-  ],
-)
-
-datarootdir = '-DDATAROOTDIR="' + get_option('prefix') / get_option('datadir') + '"'
-add_project_arguments(
-  [
-    '-Wno-unused-parameter',
-    '-Wno-unused-value',
-    '-Wno-missing-field-initializers',
-    '-Wno-narrowing',
-    '-Wno-pointer-arith', datarootdir,
-    '-DHYPRLAND_VERSION="' + meson.project_version() + '"',
-  ],
-  language: 'cpp',
-)
-
-cpp_compiler = meson.get_compiler('cpp')
-if cpp_compiler.check_header('execinfo.h')
-  add_project_arguments('-DHAS_EXECINFO', language: 'cpp')
-endif
-
-aquamarine = dependency('aquamarine', version: '>=0.8.0')
-hyprcursor = dependency('hyprcursor', version: '>=0.1.7')
-hyprgraphics = dependency('hyprgraphics', version: '>= 0.1.1')
-hyprlang = dependency('hyprlang', version: '>= 0.3.2')
-hyprutils = dependency('hyprutils', version: '>= 0.7.0')
-aquamarine_version_list = aquamarine.version().split('.')
-add_project_arguments(['-DAQUAMARINE_VERSION="@0@"'.format(aquamarine.version())], language: 'cpp')
-add_project_arguments(['-DAQUAMARINE_VERSION_MAJOR=@0@'.format(aquamarine_version_list.get(0))], language: 'cpp')
-add_project_arguments(['-DAQUAMARINE_VERSION_MINOR=@0@'.format(aquamarine_version_list.get(1))], language: 'cpp')
-add_project_arguments(['-DAQUAMARINE_VERSION_PATCH=@0@'.format(aquamarine_version_list.get(2))], language: 'cpp')
-add_project_arguments(['-DHYPRCURSOR_VERSION="@0@"'.format(hyprcursor.version())], language: 'cpp')
-add_project_arguments(['-DHYPRGRAPHICS_VERSION="@0@"'.format(hyprgraphics.version())], language: 'cpp')
-add_project_arguments(['-DHYPRLANG_VERSION="@0@"'.format(hyprlang.version())], language: 'cpp')
-add_project_arguments(['-DHYPRUTILS_VERSION="@0@"'.format(hyprutils.version())], language: 'cpp')
-
-xcb_dep = dependency('xcb', required: get_option('xwayland'))
-xcb_composite_dep = dependency('xcb-composite', required: get_option('xwayland'))
-xcb_errors_dep = dependency('xcb-errors', required: get_option('xwayland'))
-xcb_icccm_dep = dependency('xcb-icccm', required: get_option('xwayland'))
-xcb_render_dep = dependency('xcb-render', required: get_option('xwayland'))
-xcb_res_dep = dependency('xcb-res', required: get_option('xwayland'))
-xcb_xfixes_dep = dependency('xcb-xfixes', required: get_option('xwayland'))
-
-gio_dep = dependency('gio-2.0', required: true)
-
-if not xcb_dep.found()
-  add_project_arguments('-DNO_XWAYLAND', language: 'cpp')
-endif
-
-backtrace_dep = cpp_compiler.find_library('execinfo', required: false)
-epoll_dep = dependency('epoll-shim', required: false) # timerfd on BSDs
-inotify_dep = dependency('libinotify', required: false) # inotify on BSDs
-
-re2 = dependency('re2', required: true)
-
-# Handle options
-systemd_option = get_option('systemd')
-systemd = dependency('systemd', required: systemd_option)
-systemd_option.enable_auto_if(systemd.found())
-
-if (systemd_option.enabled())
-  message('Enabling systemd integration')
-  add_project_arguments('-DUSES_SYSTEMD', language: 'cpp')
-  subdir('systemd')
-endif
-
-if get_option('legacy_renderer').enabled()
-  add_project_arguments('-DLEGACY_RENDERER', language: 'cpp')
-endif
-
-if get_option('buildtype') == 'debug'
-  add_project_arguments('-DHYPRLAND_DEBUG', language: 'cpp')
-endif
-
-# Generate hyprland version and populate version.h
-run_command('sh', '-c', 'scripts/generateVersion.sh', check: true)
-# Make shader files includable
-run_command('sh', '-c', 'scripts/generateShaderIncludes.sh', check: true)
-
-# Install headers
-globber = run_command('find', 'src', '-name', '*.h*', '-o', '-name', '*.inc', check: true)
-headers = globber.stdout().strip().split('\n')
-foreach file : headers
-  install_headers(file, subdir: 'hyprland', preserve_path: true)
-endforeach
-
-tracy = dependency('tracy', static: true, required: get_option('tracy_enable'))
-
-if get_option('tracy_enable') and get_option('buildtype') != 'debugoptimized'
-  warning('Profiling builds should set -- buildtype = debugoptimized')
-endif
-
-
-
-subdir('protocols')
-subdir('src')
-subdir('hyprctl')
-subdir('assets')
-subdir('example')
-subdir('docs')
-
-if get_option('hyprpm').enabled()
-  subdir('hyprpm/src')
-endif
-
-# Generate hyprland.pc
-pkg_install_dir = join_paths(get_option('datadir'), 'pkgconfig')
-
-import('pkgconfig').generate(
-  name: 'Hyprland',
-  filebase: 'hyprland',
-  url: 'https://github.com/hyprwm/Hyprland',
-  description: 'Hyprland header files',
-  install_dir: pkg_install_dir,
-  subdirs: ['', 'hyprland/protocols', 'hyprland'],
-)

meson_options.txt

@@ -1,6 +0,0 @@
-option('xwayland', type: 'feature', value: 'auto', description: 'Enable support for X11 applications')
-option('systemd', type: 'feature', value: 'auto', description: 'Enable systemd integration')
-option('uwsm', type: 'feature', value: 'enabled', description: 'Enable uwsm integration (only if systemd is enabled)')
-option('legacy_renderer', type: 'feature', value: 'disabled', description: 'Enable legacy renderer')
-option('hyprpm', type: 'feature', value: 'enabled', description: 'Enable hyprpm')
-option('tracy_enable', type: 'boolean', value: false , description: 'Enable profiling')