ci(github): update build + release workflow

This commit updates the build and release workflow to enable multi-arch builds and releases. A number of Rust-specific actions have been added, namely rust-cache to handle cargo caching and actions-rust-cross to handle cross-compilation. A release-dry-run target has been added to run on master which should help catch any issues in release workflow changes early. Releases drop goreleaser entirely in favour of action-gh-release which was already in use to add msi installers to the releases previously created by goreleaser.
2026-02-13 16:57:40 +01:00 · 2024-10-15 15:42:11 -07:00
71 changed files with 1166 additions and 2073 deletions
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -1,16 +1,8 @@
 name: Bug report
 description: File a bug report
-labels: [ bug ]
+labels: [bug]
 title: "[BUG]: "
 body:
-  - type: markdown
-    attributes:
-      value: |
-        Please **do not** open an issue for applications with invisible windows leaving ghost tiles.
-
-        You can run `komorebic visible-windows` when the ghost tile is present on your workspace to retrieve the invisible window's exe, class name and title, and then use that to [ignore the window](https://lgug2z.github.io/komorebi/common-workflows/ignore-windows.html) responsible for the ghost tile.
-
-        If it is not possible to uniquely identify the invisible window resulting in a ghost tile through a mixture of exe, title and class identifiers , then this is not a bug with komorebi but a bug with the application you are using, and should open an issue with the developer(s) of that application.
  - type: textarea
    validations:
      required: true
--- a/.github/ISSUE_TEMPLATE/feature_request.yml
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -1,5 +1,5 @@
 name: Feature request
-description: Suggest a new feature (Sponsors only)
+description: Suggest a new feature
 labels: [enhancement]
 title: "[FEAT]: "
 body:
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,7 +0,0 @@
-<!--
-  Please follow the Conventional Commits specification.
-
-  If you need to update your PR with changes from `master`, please run `git rebase master`.
-
-  By opening this PR, you confirm that you have read and understood this project's `CONTRIBUTING.md`.
-->
--- a/.github/workflows/sponsor-check.yaml
+++ b/.github/workflows/sponsor-check.yaml
@@ -1,125 +0,0 @@
-name: Feature Request Sponsor Check
-
-on:
-  issues:
-    types: [opened]
-  workflow_dispatch:
-    inputs:
-      test_username:
-        description: "Test username to check sponsorship for"
-        required: true
-        default: "octocat"
-      test_title:
-        description: "Test issue title"
-        required: true
-        default: "[FEAT] Test Feature Request"
-      test_sponsor_platform:
-        description: "Selected sponsor platform"
-        required: true
-        type: choice
-        options:
-          - "GitHub Sponsors"
-          - "Ko-fi"
-          - "Discord"
-          - "YouTube"
-
-jobs:
-  check-sponsor:
-    runs-on: ubuntu-latest
-    if: |
-      (github.event_name == 'workflow_dispatch') || (github.event_name == 'issues' &&
-       startsWith(github.event.issue.title, '[FEAT]') &&
-       github.event.issue.user.login != 'LGUG2Z' &&
-       fromJSON(github.event.issue.body).Sponsors == 'GitHub Sponsors')
-
-    steps:
-      - name: Get Issue Details
-        id: issue-details
-        run: |
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            echo "username=${{ github.event.inputs.test_username }}" >> $GITHUB_OUTPUT
-            echo "title=${{ github.event.inputs.test_title }}" >> $GITHUB_OUTPUT
-            echo "sponsor_platform=${{ github.event.inputs.test_sponsor_platform }}" >> $GITHUB_OUTPUT
-          else
-            echo "username=${{ github.event.issue.user.login }}" >> $GITHUB_OUTPUT
-            echo "title=${{ github.event.issue.title }}" >> $GITHUB_OUTPUT
-            echo "sponsor_platform=$(jq -r '.Sponsors' <<< '${{ github.event.issue.body }}')" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Get Sponsorship Status
-        id: sponsorship
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.PAT }}
-          script: |
-            const username = '${{ steps.issue-details.outputs.username }}';
-            const sponsorPlatform = '${{ steps.issue-details.outputs.sponsor_platform }}';
-
-            if (sponsorPlatform !== 'GitHub Sponsors') {
-              console.log('Sponsor platform is not GitHub Sponsors, skipping check');
-              return true;
-            }
-
-            const sponsorshipQuery = `query($user: String!) {
-              user(login: $user) {
-                ... on Sponsorable {
-                  sponsorshipForViewerAsSponsorable {
-                    tier {
-                      name
-                      monthlyPriceInDollars
-                    }
-                  }
-                }
-              }
-            }`;
-
-            try {
-              const result = await github.graphql(sponsorshipQuery, {
-                user: username
-              });
-
-              console.log(result);
-              const sponsorship = result.user.sponsorshipForViewerAsSponsorable;
-              console.log(sponsorship);
-              const amount = sponsorship?.tier?.monthlyPriceInDollars || 0;
-
-              console.log(`Sponsorship amount for ${username}: $${amount}/month`);
-              return amount >= 5;
-            } catch (error) {
-              console.log(`Error checking sponsorship: ${error.message}`);
-              return false;
-            }
-
-      - name: Print Test Results
-        if: github.event_name == 'workflow_dispatch'
-        run: |
-          echo "Test Results for ${{ steps.issue-details.outputs.username }}:"
-          echo "Title: ${{ steps.issue-details.outputs.title }}"
-          echo "Platform: ${{ steps.issue-details.outputs.sponsor_platform }}"
-          echo "Would close issue: ${{ steps.sponsorship.outputs.result == 'false' }}"
-
-      - name: Close Issue If Not Sponsor
-        if: |
-          github.event_name == 'issues' && 
-          steps.sponsorship.outputs.result == 'false'
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const issueNumber = context.issue.number;
-            const owner = context.repo.owner;
-            const repo = context.repo.repo;
-
-            await github.rest.issues.createComment({
-              owner,
-              repo,
-              issue_number: issueNumber,
-              body: 'Thank you for your feature request! This repository requires a GitHub sponsorship of at least $5/month to submit feature requests. Please consider becoming a sponsor at https://github.com/sponsors/LGUG2Z'
-            });
-
-            await github.rest.issues.update({
-              owner,
-              repo,
-              issue_number: issueNumber,
-              state: 'closed'
-            });
--- a/.github/workflows/windows.yaml
+++ b/.github/workflows/windows.yaml
@@ -15,7 +15,6 @@ on:
      - v*
  schedule:
    - cron: "30 0 * * 0" # Every day at 00:30 UTC
-  workflow_dispatch:

 jobs:
  build:
@@ -44,7 +43,6 @@ jobs:
        with:
          cache-on-failure: "true"
          cache-all-crates: "true"
-          key: ${{ matrix.platform.target }}
      - run: cargo +nightly fmt --check
      - run: cargo clippy
      - uses: houseabsolute/actions-rust-cross@v0
@@ -68,7 +66,7 @@ jobs:
    needs: build
    runs-on: windows-latest
    permissions: write-all
-    if: ${{ github.ref == 'refs/heads/master' && (github.event_name == 'schedule' || github.event_name == 'workflow_dispatch' ) }}
+    if: ${{ github.ref == 'refs/heads/master' && github.event_name == 'schedule' }}
    env:
      GH_TOKEN: ${{ github.token }}
    steps:
@@ -86,10 +84,6 @@ jobs:
          Compress-Archive -Force ./komorebi-aarch64-pc-windows-msvc-${{ github.sha }}/aarch64-pc-windows-msvc/release/*.exe komorebi-$Env:VERSION-aarch64-pc-windows-msvc.zip
          Copy-Item ./komorebi-aarch64-pc-windows-msvc-${{ github.sha }}/wix/*aarch64.msi -Destination ./komorebi-$Env:VERSION-aarch64.msi
          echo "$((Get-FileHash komorebi-$Env:VERSION-aarch64-pc-windows-msvc.zip).Hash.ToLower())  komorebi-$Env:VERSION-aarch64-pc-windows-msvc.zip" >>checksums.txt
-      - uses: Swatinem/rust-cache@v2
-        with:
-          cache-on-failure: "true"
-          cache-all-crates: "true"
      - shell: bash
        run: |
          if ! type kokai >/dev/null; then cargo install --locked kokai --force; fi
@@ -104,7 +98,7 @@ jobs:
            --target $GITHUB_SHA \
            --prerelease \
            --title "komorebi nightly (${GITHUB_SHA})" \
-            --notes-file CHANGELOG.md \
+            --notes-file CHANGELOG.md
            komorebi-nightly-x86_64-pc-windows-msvc.zip \
            komorebi-nightly-x86_64.msi \
            komorebi-nightly-aarch64-pc-windows-msvc.zip \
@@ -166,7 +160,7 @@ jobs:
          fetch-depth: 0
      - shell: bash
        run: |
-          TAG=${{ github.ref_name }}
+          TAG=${{ github.event.release.tag_name }}
          echo "VERSION=${TAG#v}" >> $GITHUB_ENV
      - uses: actions/download-artifact@v4
      - run: |
--- a/.gitignore
+++ b/.gitignore
@@ -4,5 +4,4 @@
 CHANGELOG.md
 dummy.go
 komorebic/applications.yaml
-komorebic/applications.json
 /.vs
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -38,21 +38,17 @@ windows-implement = { version = "0.58" }
 windows-interface = { version = "0.58" }
 windows-core = { version = "0.58" }
 shadow-rs = "0.35"
-which = "7"
+which = "6"

 [workspace.dependencies.windows]
 version = "0.58"
 features = [
    "implement",
-    "Foundation_Numerics",
    "Win32_System_Com",
    "Win32_UI_Shell_Common", # for IObjectArray
    "Win32_Foundation",
    "Win32_Graphics_Dwm",
    "Win32_Graphics_Gdi",
-    "Win32_Graphics_Direct2D",
-    "Win32_Graphics_Direct2D_Common",
-    "Win32_Graphics_Dxgi_Common",
    "Win32_System_LibraryLoader",
    "Win32_System_RemoteDesktop",
    "Win32_System_Threading",
--- a/README.md
+++ b/README.md
@@ -60,17 +60,13 @@ channel](https://www.youtube.com/channel/UCeai3-do-9O4MNy9_xjO6mg) where I post
 _komorebi_ development videos. If you would like to be notified of upcoming
 videos please subscribe and turn on notifications.

-There is an [Awesome List](https://github.com/LGUG2Z/awesome-komorebi) which
-showcases the many awesome projects that exist in the _komorebi_ ecosystem.
-
 _komorebi_ is a free and source-available project, and one that encourages you to
 make charitable donations if you find the software to be useful and have the
 financial means.

 I encourage you to make a charitable donation to the [Palestine Children's
-Relief Fund](https://pcrf1.app.neoncrm.com/forms/gaza-recovery) or contributing
-to a [Gaza Funds campaign](https://gazafunds.com) before you consider sponsoring
-me on GitHub.
+Relief Fund](https://pcrf1.app.neoncrm.com/forms/gaza-recovery) before you
+consider sponsoring me on GitHub.

 [GitHub Sponsors is enabled for this
 project](https://github.com/sponsors/LGUG2Z). Unfortunately I don't have
@@ -100,6 +96,7 @@ video will answer the majority of your questions.

 [![Watch the comparison video](https://img.youtube.com/vi/0LCbS_gm0RA/hqdefault.jpg)](https://www.youtube.com/watch?v=0LCbS_gm0RA)

+
 # Demonstrations

 [@amnweb](https://github.com/amnweb) showing _komorebi_ `v0.1.28` running on Windows 11 with window borders,
@@ -108,6 +105,7 @@ _komorebi_'s [Window Manager Event Subscriptions](https://github.com/LGUG2Z/komo

 https://github.com/LGUG2Z/komorebi/assets/13164844/21be8dc4-fa76-4f70-9b37-1d316f4b40c2

+
 [@haxibami](https://github.com/haxibami) showing _komorebi_ running on Windows
 11 with a terminal emulator, a web browser and a code editor. The original
 video can be viewed
@@ -196,19 +194,13 @@ required.
 `komorebi` is licensed under the [Komorebi 1.0.0 license](./LICENSE.md), which
 is a fork of the [PolyForm Strict 1.0.0
 license](https://polyformproject.org/licenses/strict/1.0.0). On a high level
-this means that you are free to do whatever you want with `komorebi` for
-personal use other than redistribution, or distribution of new works (ie.
-hard-forks) based on the software.
+this means that you are free to do whatever you want with `komorebi` other than
+redistribution, or distribution of new works (ie. hard-forks) based on the
+software.

 Anyone is free to make their own fork of `komorebi` with changes intended
 either for personal use or for integration back upstream via pull requests.

-The [Komorebi 1.0.0 License](./LICENSE.md) does not permit any kind of
-commercial use.
-
-A dedicated license and EULA will be introduced in 2025 for both commercial and
-noncommercial organizations.
-
 Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for more information about how
 code contributions to `komorebi` are licensed.

@@ -367,7 +359,7 @@ every `WindowManagerEvent` and `SocketMessage` handled by `komorebi` in a Rust c
 Below is a simple example of how to use `komorebi-client` in a basic Rust application.

 ```rust
-// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.30"}
+// komorebi-client = { git = "https://github.com/LGUG2Z/komorebi", tag = "v0.1.29"}

 use anyhow::Result;
 use komorebi_client::Notification;
--- a/docs/cli/animation-style.md
+++ b/docs/cli/animation-style.md
@@ -10,8 +10,9 @@ Options:
          Desired ease function for animation
          
          [default: linear]
-          [possible values: linear, ease-in-sine, ease-out-sine, ease-in-out-sine, ease-in-quad, ease-out-quad, ease-in-out-quad, ease-in-cubic, ease-in-out-cubic, ease-in-quart, ease-out-quart, ease-in-out-quart, ease-in-quint, ease-out-quint, ease-in-out-quint, ease-in-expo, ease-out-expo,
-          ease-in-out-expo, ease-in-circ, ease-out-circ, ease-in-out-circ, ease-in-back, ease-out-back, ease-in-out-back, ease-in-elastic, ease-out-elastic, ease-in-out-elastic, ease-in-bounce, ease-out-bounce, ease-in-out-bounce]
+          [possible values: linear, ease-in-sine, ease-out-sine, ease-in-out-sine, ease-in-quad, ease-out-quad, ease-in-out-quad, ease-in-cubic, ease-in-out-cubic, ease-in-quart,
+          ease-out-quart, ease-in-out-quart, ease-in-quint, ease-out-quint, ease-in-out-quint, ease-in-expo, ease-out-expo, ease-in-out-expo, ease-in-circ, ease-out-circ, ease-in-out-circ,
+          ease-in-back, ease-out-back, ease-in-out-back, ease-in-elastic, ease-out-elastic, ease-in-out-elastic, ease-in-bounce, ease-out-bounce, ease-in-out-bounce]

  -h, --help
          Print help
--- a/docs/cli/application-specific-configuration-schema.md
+++ b/docs/cli/application-specific-configuration-schema.md
@@ -1,7 +1,7 @@
 # application-specific-configuration-schema

 ```
-Generate a JSON Schema for applications.json
+Generate a JSON Schema for applications.yaml

 Usage: komorebic.exe application-specific-configuration-schema

--- a/docs/cli/border-colour.md
+++ b/docs/cli/border-colour.md
@@ -18,7 +18,7 @@ Arguments:
 Options:
  -w, --window-kind <WINDOW_KIND>
          [default: single]
-          [possible values: single, stack, monocle, unfocused, floating]
+          [possible values: single, stack, monocle, unfocused]

  -h, --help
          Print help
--- a/docs/cli/convert-app-specific-configuration.md
+++ b/docs/cli/convert-app-specific-configuration.md
@@ -1,16 +0,0 @@
-# convert-app-specific-configuration
-
-```
-Convert a v1 ASC YAML file to a v2 ASC JSON file
-
-Usage: komorebic.exe convert-app-specific-configuration <PATH>
-
-Arguments:
-  <PATH>
-          YAML file from which the application-specific configurations should be loaded
-
-Options:
-  -h, --help
-          Print help
-
-```
--- a/docs/cli/enable-autostart.md
+++ b/docs/cli/enable-autostart.md
@@ -9,6 +9,9 @@ Options:
  -c, --config <CONFIG>
          Path to a static configuration JSON file

+  -f, --ffm
+          Enable komorebi's custom focus-follows-mouse implementation
+
      --whkd
          Enable autostart of whkd

--- a/docs/cli/fetch-app-specific-configuration.md
+++ b/docs/cli/fetch-app-specific-configuration.md
@@ -1,7 +1,7 @@
 # fetch-app-specific-configuration

 ```
-Fetch the latest version of applications.json from komorebi-application-specific-configuration
+Fetch the latest version of applications.yaml from komorebi-application-specific-configuration

 Usage: komorebic.exe fetch-app-specific-configuration

--- a/docs/cli/ignore-rule.md
+++ b/docs/cli/ignore-rule.md
@@ -1,9 +1,9 @@
-# ignore-rule
+# float-rule

 ```
-Add a rule to ignore the specified application
+Add a rule to always float the specified application

-Usage: komorebic.exe ignore-rule <IDENTIFIER> <ID>
+Usage: komorebic.exe float-rule <IDENTIFIER> <ID>

 Arguments:
  <IDENTIFIER>
--- a/docs/cli/focus-follows-mouse.md
+++ b/docs/cli/focus-follows-mouse.md
@@ -0,0 +1,23 @@
+# focus-follows-mouse
+
+```
+Enable or disable focus follows mouse for the operating system
+
+Usage: komorebic.exe focus-follows-mouse [OPTIONS] <BOOLEAN_STATE>
+
+Arguments:
+  <BOOLEAN_STATE>
+          [possible values: enable, disable]
+
+Options:
+  -i, --implementation <IMPLEMENTATION>
+          [default: windows]
+
+          Possible values:
+          - komorebi: A custom FFM implementation (slightly more CPU-intensive)
+          - windows:  The native (legacy) Windows FFM implementation
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+```
--- a/docs/cli/format-app-specific-configuration.md
+++ b/docs/cli/format-app-specific-configuration.md
@@ -0,0 +1,16 @@
+# format-app-specific-configuration
+
+```
+Format a YAML file for use with the 'ahk-app-specific-configuration' command
+
+Usage: komorebic.exe format-app-specific-configuration <PATH>
+
+Arguments:
+  <PATH>
+          YAML file from which the application-specific configurations should be loaded
+
+Options:
+  -h, --help
+          Print help
+
+```
--- a/docs/cli/load-custom-layout.md
+++ b/docs/cli/load-custom-layout.md
@@ -0,0 +1,16 @@
+# load-custom-layout
+
+```
+Load a custom layout from file for the focused workspace
+
+Usage: komorebic.exe load-custom-layout <PATH>
+
+Arguments:
+  <PATH>
+          JSON or YAML file from which the custom layout definition should be loaded
+
+Options:
+  -h, --help
+          Print help
+
+```
--- a/docs/cli/named-workspace-custom-layout-rule.md
+++ b/docs/cli/named-workspace-custom-layout-rule.md
@@ -0,0 +1,22 @@
+# named-workspace-custom-layout-rule
+
+```
+Add a dynamic custom layout for the specified workspace
+
+Usage: komorebic.exe named-workspace-custom-layout-rule <WORKSPACE> <AT_CONTAINER_COUNT> <PATH>
+
+Arguments:
+  <WORKSPACE>
+          Target workspace name
+
+  <AT_CONTAINER_COUNT>
+          The number of window containers on-screen required to trigger this layout rule
+
+  <PATH>
+          JSON or YAML file from which the custom layout definition should be loaded
+
+Options:
+  -h, --help
+          Print help
+
+```
--- a/docs/cli/named-workspace-custom-layout.md
+++ b/docs/cli/named-workspace-custom-layout.md
@@ -0,0 +1,19 @@
+# named-workspace-custom-layout
+
+```
+Set a custom layout for the specified workspace
+
+Usage: komorebic.exe named-workspace-custom-layout <WORKSPACE> <PATH>
+
+Arguments:
+  <WORKSPACE>
+          Target workspace name
+
+  <PATH>
+          JSON or YAML file from which the custom layout definition should be loaded
+
+Options:
+  -h, --help
+          Print help
+
+```
--- a/docs/cli/start.md
+++ b/docs/cli/start.md
@@ -6,6 +6,9 @@ Start komorebi.exe as a background process
 Usage: komorebic.exe start [OPTIONS]

 Options:
+  -f, --ffm
+          Allow the use of komorebi's custom focus-follows-mouse implementation
+
  -c, --config <CONFIG>
          Path to a static configuration JSON file

--- a/docs/cli/stop.md
+++ b/docs/cli/stop.md
@@ -9,9 +9,6 @@ Options:
      --whkd
          Stop whkd if it is running as a background process

-      --ahk
-          Stop ahk if it is running as a background process
-
      --bar
          Stop komorebi-bar if it is running as a background process

--- a/docs/cli/toggle-float-override.md
+++ b/docs/cli/toggle-float-override.md
@@ -1,12 +0,0 @@
-# toggle-float-override
-
-```
-Enable or disable float override, which makes it so every new window opens in floating mode
-
-Usage: komorebic.exe toggle-float-override
-
-Options:
-  -h, --help
-          Print help
-
-```
--- a/docs/cli/toggle-focus-follows-mouse.md
+++ b/docs/cli/toggle-focus-follows-mouse.md
@@ -0,0 +1,19 @@
+# toggle-focus-follows-mouse
+
+```
+Toggle focus follows mouse for the operating system
+
+Usage: komorebic.exe toggle-focus-follows-mouse [OPTIONS]
+
+Options:
+  -i, --implementation <IMPLEMENTATION>
+          [default: windows]
+
+          Possible values:
+          - komorebi: A custom FFM implementation (slightly more CPU-intensive)
+          - windows:  The native (legacy) Windows FFM implementation
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+```
--- a/docs/cli/toggle-workspace-float-override.md
+++ b/docs/cli/toggle-workspace-float-override.md
@@ -1,12 +0,0 @@
-# toggle-workspace-float-override
-
-```
-Enable or disable float override, which makes it so every new window opens in floating mode, for the currently focused workspace. If there was no override value set for the workspace previously it takes the opposite of the global value
-
-Usage: komorebic.exe toggle-workspace-float-override
-
-Options:
-  -h, --help
-          Print help
-
-```
--- a/docs/cli/toggle-workspace-window-container-behaviour.md
+++ b/docs/cli/toggle-workspace-window-container-behaviour.md
@@ -1,12 +0,0 @@
-# toggle-workspace-window-container-behaviour
-
-```
-Toggle the behaviour for new windows (stacking or dynamic tiling) for currently focused workspace. If there was no behaviour set for the workspace previously it takes the opposite of the global value
-
-Usage: komorebic.exe toggle-workspace-window-container-behaviour
-
-Options:
-  -h, --help
-          Print help
-
-```
--- a/docs/cli/workspace-custom-layout-rule.md
+++ b/docs/cli/workspace-custom-layout-rule.md
@@ -0,0 +1,25 @@
+# workspace-custom-layout-rule
+
+```
+Add a dynamic custom layout for the specified workspace
+
+Usage: komorebic.exe workspace-custom-layout-rule <MONITOR> <WORKSPACE> <AT_CONTAINER_COUNT> <PATH>
+
+Arguments:
+  <MONITOR>
+          Monitor index (zero-indexed)
+
+  <WORKSPACE>
+          Workspace index on the specified monitor (zero-indexed)
+
+  <AT_CONTAINER_COUNT>
+          The number of window containers on-screen required to trigger this layout rule
+
+  <PATH>
+          JSON or YAML file from which the custom layout definition should be loaded
+
+Options:
+  -h, --help
+          Print help
+
+```
--- a/docs/cli/workspace-custom-layout.md
+++ b/docs/cli/workspace-custom-layout.md
@@ -0,0 +1,22 @@
+# workspace-custom-layout
+
+```
+Set a custom layout for the specified workspace
+
+Usage: komorebic.exe workspace-custom-layout <MONITOR> <WORKSPACE> <PATH>
+
+Arguments:
+  <MONITOR>
+          Monitor index (zero-indexed)
+
+  <WORKSPACE>
+          Workspace index on the specified monitor (zero-indexed)
+
+  <PATH>
+          JSON or YAML file from which the custom layout definition should be loaded
+
+Options:
+  -h, --help
+          Print help
+
+```
--- a/docs/common-workflows/autostart.md
+++ b/docs/common-workflows/autostart.md
@@ -1,29 +0,0 @@
-# Autostart
-
-If you would like to autostart `komorebi`, you can use the `komorebic enable-autostart` command to generate a shortcut
-in the `shell:startup` folder.
-
-```
-Generates the komorebi.lnk shortcut in shell:startup to autostart komorebi
-
-Usage: komorebic.exe enable-autostart [OPTIONS]
-
-Options:
-  -c, --config <CONFIG>
-          Path to a static configuration JSON file
-
-  -f, --ffm
-          Enable komorebi's custom focus-follows-mouse implementation
-
-      --whkd
-          Enable autostart of whkd
-
-      --ahk
-          Enable autostart of ahk
-
-      --bar
-          Enable autostart of komorebi-bar
-
-  -h, --help
-          Print help
-```
--- a/docs/common-workflows/custom-layouts.md
+++ b/docs/common-workflows/custom-layouts.md
@@ -0,0 +1,70 @@
+# Custom Layouts
+
+Particularly for users of ultrawide monitors, traditional tiling layouts may
+not seem like the most efficient use of screen space. If you feel this is the
+case with any of the default layouts, you are also welcome to create your own
+custom layouts and save them as JSON or YAML.
+
+If you're not comfortable writing the layouts directly in JSON or YAML, you can
+use the [komorebi Custom Layout
+Generator](https://lgug2z.github.io/komorebi-custom-layout-generator/) to
+interactively define a custom layout, and then copy the generated JSON content.
+
+Custom layouts can be loaded on the current workspace or configured for a
+specific workspace in the `komorebi.json` configuration file.
+
+```json
+{
+  "monitors": [
+    {
+      "workspaces": [
+        {
+          "name": "personal",
+          "custom_layout": "C:/Users/LGUG2Z/my-custom-layout.json"
+        },
+      ]
+    }
+  ]
+}
+```
+
+The fundamental building block of a custom _komorebi_ layout is the Column.
+
+Columns come in three variants:
+
+- **Primary**: This is where your primary focus will be on the screen most of
+  the time. There must be exactly one Primary Column in any custom layout.
+  Optionally, you can specify the percentage of the screen width that you want
+  the Primary Column to occupy.
+- **Secondary**: This is an optional column that can either be full height of
+  split horizontally into a fixed number of maximum rows. There can be any
+  number of Secondary Columns in a custom layout.
+- **Tertiary**: This is the final column where any remaining windows will be
+  split horizontally into rows as they get added.
+
+If there is only one window on the screen when a custom layout is selected,
+that window will take up the full work area of the screen.
+
+If the number of windows is equal to or less than the total number of columns
+defined in a custom layout, the windows will be arranged in an equal-width
+columns.
+
+When the number of windows is greater than the number of columns defined in the
+custom layout, the windows will begin to be arranged according to the
+constraints set on the Primary and Secondary columns of the layout.
+
+Here is an example custom layout that can be used as a starting point for your
+own:
+
+```yaml
+- column: Secondary
+  configuration: !Horizontal 2 # max number of rows
+- column: Primary
+  configuration: !WidthPercentage 50 # percentage of screen
+- column: Tertiary
+  configuration: Horizontal
+```
+
+<!-- TODO: Record a new video -->
+
+[![Watch the tutorial video](https://img.youtube.com/vi/SgmBHKEOcQ4/hqdefault.jpg)](https://www.youtube.com/watch?v=SgmBHKEOcQ4)
--- a/docs/common-workflows/floating-applications.md
+++ b/docs/common-workflows/floating-applications.md
@@ -1,16 +0,0 @@
-# Floating Windows
-
-Sometimes you will want a specific application to be managed as a floating window.
-You can add rules to enforce this behaviour in the `komorebi.json` configuration file.
-
-```json
-{
-  "floating_applications": [
-    {
-      "kind": "Title",
-      "id": "Media Player",
-      "matching_strategy": "Equals"
-    }
-  ]
-}
-```
--- a/docs/common-workflows/focus-follows-mouse.md
+++ b/docs/common-workflows/focus-follows-mouse.md
@@ -0,0 +1,34 @@
+# Focus Follows Mouse
+
+`komorebi` supports two focus-follows-mouse implementations; the native Windows
+Xmouse implementation, which treats the desktop, the task bar, and the system
+tray as windows and switches focus to them eagerly, and a custom `komorebi`
+implementation, which only considers windows managed by `komorebi` as valid
+targets to switch focus to when moving the mouse.
+
+To enable the `komorebi` implementation you must start the process with the
+`--ffm` flag to explicitly enable the feature. This is because the mouse
+tracking required for this feature significantly increases the CPU usage of the
+process (on my machine, it jumps from <1% to ~4~), and this CPU increase
+persists regardless of whether focus-follows-mouse is enabled or disabled at
+any given time via `komorebic`'s configuration commands.
+
+If the `komorebi` process has been started with the `--ffm` flag, you can
+enable focus follows mouse behaviour in the `komorebi.json` configuration file.
+
+```json
+{
+  "focus_follows_mouse": "Komorebi"
+}
+```
+
+When calling any of the `komorebic` commands related to focus-follows-mouse
+functionality, the `windows` implementation will be chosen as the default
+implementation. You can optionally specify the `komorebi` implementation by
+passing it as an argument to the `--implementation` flag:
+
+```powershell
+komorebic.exe toggle-focus-follows-mouse --implementation komorebi
+```
+
+
--- a/docs/common-workflows/ignore-windows.md
+++ b/docs/common-workflows/ignore-windows.md
@@ -5,12 +5,12 @@ applications are [already generated for
 you](https://github.com/LGUG2Z/komorebi-application-specific-configuration)

 Sometimes you will want a specific application to never be tiled, and instead
-be completely ignored. You can add rules to enforce this behaviour in the
+float all the time. You can add rules to enforce this behaviour in the
 `komorebi.json` configuration file.

 ```json
 {
-  "ignore_rules": [
+  "float_rules": [
    {
      "kind": "Title",
      "id": "Media Player",
--- a/docs/common-workflows/multiple-bar-instances.md
+++ b/docs/common-workflows/multiple-bar-instances.md
@@ -1,19 +0,0 @@
-# Multiple Bar Instances
-
-If you would like to run multiple instances of `komorebi-bar` to target different monitors, it is possible to do so
-by maintaining multiple `komorebi.bar.json` configuration files and specifying their paths in the `bar_configurations`
-array in your `komorebi.json` configuration file.
-
-```json
-{
-  "bar_configurations": [
-    "C:/Users/LGUG2Z/komorebi.bar.monitor1.json",
-    "C:/Users/LGUG2Z/komorebi.bar.monitor2.json"
-  ]
-}
-```
-
-You may also use `$Env:USERPROFILE` or `$Env:KOMOREBI_CONFIG_HOME` when specifying the paths.
-
-The main difference between different `komorebi.bar.json` files will be the value of `monitor.index` which is used to
-target the monitor for each instance of `komorebi-bar`.
--- a/docs/example-configurations.md
+++ b/docs/example-configurations.md
@@ -62,7 +62,7 @@ using `default_workspace_padding` and `default_container_padding`.

 You may have seen videos and screenshots of people using `komorebi` with a
 thick, colourful active window border. You can also enable this by setting
-`border` to `true`. However, please be warned that this feature
+`active_window_border` to `true`. However, please be warned that this feature
 is a crude hack trying to compensate for the insistence of Microsoft Windows
 design teams to make custom borders with widths that are actually visible to
 the user a thing of the past and removing this capability from the Win32 API.
@@ -162,8 +162,6 @@ If you have an ultrawide monitor, I recommend using this layout.

 If you like the `grid` layout in [LeftWM](https://github.com/leftwm/leftwm-layouts) this is almost exactly the same!

-The `grid` layout does not support resizing windows tiles.
-
 ```
 +-----+-----+   +---+---+---+   +---+---+---+   +---+---+---+
 |     |     |   |   |   |   |   |   |   |   |   |   |   |   |
@@ -179,7 +177,7 @@ The `grid` layout does not support resizing windows tiles.

 `whkd` is a fairly basic piece of software with a simple configuration format:
 key bindings go to the left of the colon, and shell commands go to the right of the
-colon.
+colon. By default, the `whkdrc` file should be located in the `$Env:USERPROFILE/.config/` directory.

 Please remember that `whkd` does not support overriding Microsoft's limitations
 on hotkey bindings that include the `Windows` key. If this is important to you,
@@ -190,25 +188,6 @@ bindings for `komorebic` commands instead.
 {% include "./whkdrc.sample" %}
 ```

-### Configuration
-
-`whkd` searches for a `whkdrc` configuration file in the following locations:
-
-* `$Env:WHKD_CONFIG_HOME`
-* `$Env:USERPROFILE/.config`
-
-It is also possible to change a hotkey behavior depending on which application has focus:
-
-```
-alt + n [
-    # ProcessName as shown by `Get-Process`
-    Firefox       : echo "hello firefox"
-    
-    # Spaces are fine, no quotes required
-    Google Chrome : echo "hello chrome"
-]
-```
-
 ### Setting .shell

 There is one special directive at the top of the file, `.shell` which can be
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -134,26 +134,6 @@ an offline machine to install.
 Once installed, proceed to get the [example configurations](example-configurations.md) (none of the commands for
 first-time set up and running komorebi require an internet connection).

-## Upgrades
-
-Before upgrading, make sure to run `komorebic stop --whkd --bar`. This is to ensure that all the current
-komorebi-related exe files can be replaced without issue.
-
-Then, depending on whether you installed via `scoop` or `winget`, you can run the appropriate command:
-
-```powershell
-# for winget
-winget upgrade LGUG2Z.komorebi
-```
-
-```powershell
-# for scoop
-scoop update komorebi
-```
-
-Once the upgrade is completed you can confirm that you have the latest version by running `komorebic --version`, and
-then start it with `komorebic start --whkd --bar`.
-
 ## Uninstallation

 Before uninstalling, first run `komorebic stop --whkd --bar` to make sure that
@@ -167,7 +147,7 @@ files created by the `quickstart` command and any other runtime files:

 ```powershell
 rm $Env:USERPROFILE\komorebi.json
-rm $Env:USERPROFILE\applications.json
+rm $Env:USERPROFILE\applications.yaml
 rm $Env:USERPROFILE\.config\whkdrc
 rm -r -Force $Env:LOCALAPPDATA\komorebi
 ```
--- a/docs/komorebi.bar.example.json
+++ b/docs/komorebi.bar.example.json
@@ -1,5 +1,5 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.30/schema.bar.json",
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.29/schema.bar.json",
  "monitor": {
    "index": 0,
    "work_area_offset": {
--- a/docs/komorebi.example.json
+++ b/docs/komorebi.example.json
@@ -1,6 +1,6 @@
 {
-  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.30/schema.json",
-  "app_specific_configuration_path": "$Env:USERPROFILE/applications.json",
+  "$schema": "https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.29/schema.json",
+  "app_specific_configuration_path": "$Env:USERPROFILE/applications.yaml",
  "window_hiding_behaviour": "Cloak",
  "cross_monitor_move_behaviour": "Insert",
  "default_workspace_padding": 20,
--- a/docs/release/v0-1-22.md
+++ b/docs/release/v0-1-22.md
@@ -0,0 +1,58 @@
+# v0.1.22
+
+In addition to the [changelog](https://github.com/LGUG2Z/komorebi/releases/tag/v0.1.22) of new features and fixes,
+please note the following changes from `v0.1.21` to adjust your configuration files accordingly.
+
+## tl;dr
+
+The way windows are sized and drawn has been improved to remove the need to manually specify and remove invisible
+borders for applications that overflow them. If you use the active window border, the first time you launch `v0.1.22`
+you may end up with a _huge_ border due to these changes.
+
+`active_window_border_width` and `active_window_border_offset` have been renamed to `border_width` and `border_offset`
+as they now also apply outside the context of the active window border.
+
+```json
+{
+  "active_window_border": true,
+  "border_width": 8,
+  "border_offset": -1
+}
+```
+
+Users of the active window border should start from these settings and read the notes below before making further
+adjustments.
+
+## Changes to `active_window_border`, and window sizing:
+
+- The border no longer creates a second drop-shadow around the active window
+- Windows are now sized to fill the layout region entirely, ignoring window decorations such as drop shadows
+- Border offset now starts exactly at the paint edge of the window on all sides
+- Windows are sized such that the border offset and border width are taken into account
+
+## Recommended patterns
+
+### Gapless
+
+- Disable "transparency effects" Personalization > Colors
+- Set the following settings in `komorebi.json`:
+```json
+{
+  "default_workspace_padding": 0,
+  "default_container_padding": 0,
+  "border_offset": -1,
+  "border_width": 0
+}
+```
+
+### 1px border
+
+A 1px border is drawn around the window edge. Users may see a gap for a single pixel, if the system theme has a
+transparent edge - this is the windows themed edge, and is not present for all applications.
+
+```json
+{
+  "border_offset": 0,
+  "border_width": 1
+}
+```
--- a/docs/troubleshooting.md
+++ b/docs/troubleshooting.md
@@ -1,15 +1,5 @@
 # Troubleshooting

-## Phantom Tiles
-
-Sometimes you may experience an application which leaves "ghost tiles" on a workspace, where there is space reserved for
-a window but no window visible.
-
-You can ignore these windows by following these steps:
-
-* Run `komorebic visible-windows` to find details about the invisible window
-* Using that information, [create a rule to ignore that window](common-workflows/ignore-windows.md)
-
 ## AutoHotKey executable not found

 If you try to start komorebi with AHK using `komorebic start --ahk`, and you have
@@ -95,10 +85,10 @@ running `komorebic stop` and `komorebic start`.

   To avoid waiting an eternity:

-    - _Control Panel_ -> _Hardware and Sound_ -> _Power Options_ -> _Edit Plan
-      Settings_
+   - _Control Panel_ -> _Hardware and Sound_ -> _Power Options_ -> _Edit Plan
+     Settings_

-      _Turn off the display: 1 minute_
+     _Turn off the display: 1 minute_

   Allow a minute for the display to reset, then once it actually shuts off
   allow for any additional time as prompted by your monitor for the cycle to
--- a/16
+++ b/16
@@ -26,17 +26,17 @@ install:
 run target:
    cargo +stable run --bin {{ target }} --locked

-warn target $RUST_LOG="warn":
-    just run {{ target }}
+warn $RUST_LOG="warn":
+    just run

-info target $RUST_LOG="info":
-    just run {{ target }}
+info $RUST_LOG="info":
+    just run

-debug target $RUST_LOG="debug":
-    just run {{ target }}
+debug $RUST_LOG="debug":
+    just run

-trace target $RUST_LOG="trace":
-    just run {{ target }}
+trace $RUST_LOG="trace":
+    just run

 deadlock $RUST_LOG="trace":
    cargo +stable run --bin komorebi --locked --features deadlock_detection
--- a/komorebi-bar/Cargo.toml
+++ b/komorebi-bar/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-bar"
-version = "0.1.31"
+version = "0.1.30"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
--- a/komorebi-bar/src/config.rs
+++ b/komorebi-bar/src/config.rs
@@ -11,12 +11,12 @@ use std::collections::HashMap;
 use std::path::PathBuf;

 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.bar.json` configuration file reference for `v0.1.31`
+/// The `komorebi.bar.json` configuration file reference for `v0.1.30`
 pub struct KomobarConfig {
    /// Bar positioning options
    #[serde(alias = "viewport")]
    pub position: Option<PositionConfig>,
-    /// Frame options (see: https://docs.rs/egui/latest/egui/containers/frame/struct.Frame.html)
+    /// Frame options (see: https://docs.rs/egui/latest/egui/containers/struct.Frame.html)
    pub frame: Option<FrameConfig>,
    /// Monitor options
    pub monitor: MonitorConfig,
@@ -136,13 +136,11 @@ impl From<Position> for Pos2 {
 pub enum KomobarTheme {
    /// A theme from catppuccin-egui
    Catppuccin {
-        /// Name of the Catppuccin theme (theme previews: https://github.com/catppuccin/catppuccin)
        name: komorebi_themes::Catppuccin,
        accent: Option<komorebi_themes::CatppuccinValue>,
    },
    /// A theme from base16-egui-themes
    Base16 {
-        /// Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)
        name: komorebi_themes::Base16,
        accent: Option<komorebi_themes::Base16Value>,
    },
--- a/komorebi-bar/src/komorebi.rs
+++ b/komorebi-bar/src/komorebi.rs
@@ -128,15 +128,13 @@ impl BarWidget for Komorebi {
        if self.workspaces.enable {
            let mut update = None;

-            for (i, (ws, should_show)) in komorebi_notification_state.workspaces.iter().enumerate()
-            {
-                if *should_show
-                    && ui
-                        .add(SelectableLabel::new(
-                            komorebi_notification_state.selected_workspace.eq(ws),
-                            ws.to_string(),
-                        ))
-                        .clicked()
+            for (i, ws) in komorebi_notification_state.workspaces.iter().enumerate() {
+                if ui
+                    .add(SelectableLabel::new(
+                        komorebi_notification_state.selected_workspace.eq(ws),
+                        ws.to_string(),
+                    ))
+                    .clicked()
                {
                    update = Some(ws.to_string());
                    let mut proceed = true;
@@ -402,7 +400,7 @@ fn img_to_texture(ctx: &Context, rgba_image: &RgbaImage) -> TextureHandle {

 #[derive(Clone, Debug)]
 pub struct KomorebiNotificationState {
-    pub workspaces: Vec<(String, bool)>,
+    pub workspaces: Vec<String>,
    pub selected_workspace: String,
    pub focused_container_information: (Vec<String>, Vec<Option<RgbaImage>>, usize),
    pub layout: KomorebiLayout,
@@ -453,23 +451,15 @@ impl KomorebiNotificationState {
                }
            },
            Ok(notification) => {
-                match notification.event {
-                    NotificationEvent::WindowManager(_) => {}
-                    NotificationEvent::Socket(message) => match message {
-                        SocketMessage::ReloadStaticConfiguration(path) => {
-                            if let Ok(config) = komorebi_client::StaticConfig::read(&path) {
-                                if let Some(theme) = config.theme {
-                                    apply_theme(ctx, KomobarTheme::from(theme), bg_color.clone());
-                                    tracing::info!("applied theme from updated komorebi.json");
-                                }
-                            }
-                        }
-                        SocketMessage::Theme(theme) => {
+                if let NotificationEvent::Socket(SocketMessage::ReloadStaticConfiguration(path)) =
+                    notification.event
+                {
+                    if let Ok(config) = komorebi_client::StaticConfig::read(&path) {
+                        if let Some(theme) = config.theme {
                            apply_theme(ctx, KomobarTheme::from(theme), bg_color);
-                            tracing::info!("applied theme from komorebi socket message");
+                            tracing::info!("applied theme from updated komorebi.json");
                        }
-                        _ => {}
-                    },
+                    }
                }

                self.mouse_follows_focus = notification.state.mouse_follows_focus;
@@ -487,16 +477,16 @@ impl KomorebiNotificationState {
                    .unwrap_or_else(|| format!("{}", focused_workspace_idx + 1));

                for (i, ws) in monitor.workspaces().iter().enumerate() {
-                    let should_show = if self.hide_empty_workspaces {
+                    let should_add = if self.hide_empty_workspaces {
                        focused_workspace_idx == i || !ws.containers().is_empty()
                    } else {
                        true
                    };

-                    workspaces.push((
-                        ws.name().to_owned().unwrap_or_else(|| format!("{}", i + 1)),
-                        should_show,
-                    ));
+                    if should_add {
+                        workspaces
+                            .push(ws.name().to_owned().unwrap_or_else(|| format!("{}", i + 1)));
+                    }
                }

                self.workspaces = workspaces;
--- a/komorebi-client/Cargo.toml
+++ b/komorebi-client/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-client"
-version = "0.1.31"
+version = "0.1.30"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
--- a/komorebi-gui/Cargo.toml
+++ b/komorebi-gui/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-gui"
-version = "0.1.31"
+version = "0.1.30"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
--- a/komorebi-themes/Cargo.toml
+++ b/komorebi-themes/Cargo.toml
@@ -1,14 +1,12 @@
 [package]
 name = "komorebi-themes"
-version = "0.1.31"
+version = "0.1.30"
 edition = "2021"

 [dependencies]
-base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "c11fbe2a3a4681485c5065b899a4c4d85fad3b04" }
-#catppuccin-egui = { git = "https://github.com/LGUG2Z/catppuccin-egui", rev = "f579847bf2f552b144361d5a78ed8cf360b55cbb" }
-catppuccin-egui = { version = "5", default-features = false, features = ["egui29"] }
+base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "57c38257cb0c6434321320d3746049bd58c34674" }
+catppuccin-egui = { git = "https://github.com/LGUG2Z/catppuccin-egui", rev = "f579847bf2f552b144361d5a78ed8cf360b55cbb" }
+#catppuccin-egui = { version = "5", default-features = false, features = ["egui28"] }
 eframe = { workspace = true }
 schemars = { workspace = true }
 serde = { workspace = true }
-serde_variant = "0.1"
-strum = "0.26"
--- a/komorebi-themes/src/lib.rs
+++ b/komorebi-themes/src/lib.rs
@@ -4,12 +4,10 @@
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
-use strum::IntoEnumIterator;

 pub use base16_egui_themes::Base16;
 pub use catppuccin_egui;
 pub use eframe::egui::Color32;
-use serde_variant::to_variant_name;

 #[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "type")]
@@ -26,28 +24,6 @@ pub enum Theme {
    },
 }

-impl Theme {
-    pub fn variant_names(&self) -> Vec<String> {
-        match self {
-            Theme::Catppuccin { .. } => {
-                vec![
-                    "Frappe".to_string(),
-                    "Latte".to_string(),
-                    "Macchiato".to_string(),
-                    "Mocha".to_string(),
-                ]
-            }
-            Theme::Base16 { .. } => Base16::iter()
-                .map(|variant| {
-                    to_variant_name(&variant)
-                        .expect("could not convert to variant name")
-                        .to_string()
-                })
-                .collect(),
-        }
-    }
-}
-
 #[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
 pub enum Base16Value {
    Base00,
--- a/komorebi/Cargo.toml
+++ b/komorebi/Cargo.toml
@@ -1,9 +1,11 @@
 [package]
 name = "komorebi"
-version = "0.1.31"
+version = "0.1.30"
+authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "A tiling window manager for Windows"
 categories = ["tiling-window-manager", "windows"]
 repository = "https://github.com/LGUG2Z/komorebi"
+license = "MIT"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
--- a/komorebi/src/border_manager/border.rs
+++ b/komorebi/src/border_manager/border.rs
@@ -3,78 +3,47 @@ use crate::border_manager::WindowKind;
 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::border_manager::FOCUS_STATE;
-use crate::border_manager::RENDER_TARGETS;
 use crate::border_manager::STYLE;
 use crate::border_manager::Z_ORDER;
-use crate::core::BorderStyle;
-use crate::core::Rect;
 use crate::windows_api;
 use crate::WindowsApi;
 use crate::WINDOWS_11;
-use std::ops::Deref;
+
+use crate::core::BorderStyle;
+use crate::core::Rect;
+
 use std::sync::atomic::Ordering;
 use std::sync::mpsc;
-use std::sync::LazyLock;
-use windows::Foundation::Numerics::Matrix3x2;
+use std::time::Duration;
+use windows::core::PCWSTR;
 use windows::Win32::Foundation::BOOL;
-use windows::Win32::Foundation::FALSE;
+use windows::Win32::Foundation::COLORREF;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::LRESULT;
-use windows::Win32::Foundation::TRUE;
 use windows::Win32::Foundation::WPARAM;
-use windows::Win32::Graphics::Direct2D::Common::D2D1_ALPHA_MODE_PREMULTIPLIED;
-use windows::Win32::Graphics::Direct2D::Common::D2D1_COLOR_F;
-use windows::Win32::Graphics::Direct2D::Common::D2D1_PIXEL_FORMAT;
-use windows::Win32::Graphics::Direct2D::Common::D2D_RECT_F;
-use windows::Win32::Graphics::Direct2D::Common::D2D_SIZE_U;
-use windows::Win32::Graphics::Direct2D::D2D1CreateFactory;
-use windows::Win32::Graphics::Direct2D::ID2D1Factory;
-use windows::Win32::Graphics::Direct2D::D2D1_ANTIALIAS_MODE_PER_PRIMITIVE;
-use windows::Win32::Graphics::Direct2D::D2D1_BRUSH_PROPERTIES;
-use windows::Win32::Graphics::Direct2D::D2D1_FACTORY_TYPE_MULTI_THREADED;
-use windows::Win32::Graphics::Direct2D::D2D1_HWND_RENDER_TARGET_PROPERTIES;
-use windows::Win32::Graphics::Direct2D::D2D1_PRESENT_OPTIONS_IMMEDIATELY;
-use windows::Win32::Graphics::Direct2D::D2D1_RENDER_TARGET_PROPERTIES;
-use windows::Win32::Graphics::Direct2D::D2D1_RENDER_TARGET_TYPE_DEFAULT;
-use windows::Win32::Graphics::Direct2D::D2D1_ROUNDED_RECT;
-use windows::Win32::Graphics::Dwm::DwmEnableBlurBehindWindow;
-use windows::Win32::Graphics::Dwm::DWM_BB_BLURREGION;
-use windows::Win32::Graphics::Dwm::DWM_BB_ENABLE;
-use windows::Win32::Graphics::Dwm::DWM_BLURBEHIND;
-use windows::Win32::Graphics::Dxgi::Common::DXGI_FORMAT_UNKNOWN;
 use windows::Win32::Graphics::Gdi::BeginPaint;
-use windows::Win32::Graphics::Gdi::CreateRectRgn;
+use windows::Win32::Graphics::Gdi::CreatePen;
+use windows::Win32::Graphics::Gdi::DeleteObject;
 use windows::Win32::Graphics::Gdi::EndPaint;
 use windows::Win32::Graphics::Gdi::InvalidateRect;
+use windows::Win32::Graphics::Gdi::Rectangle;
+use windows::Win32::Graphics::Gdi::RoundRect;
+use windows::Win32::Graphics::Gdi::SelectObject;
 use windows::Win32::Graphics::Gdi::PAINTSTRUCT;
+use windows::Win32::Graphics::Gdi::PS_INSIDEFRAME;
+use windows::Win32::Graphics::Gdi::PS_SOLID;
 use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
 use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
 use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
-use windows::Win32::UI::WindowsAndMessaging::GetSystemMetrics;
 use windows::Win32::UI::WindowsAndMessaging::PostQuitMessage;
 use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
+use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
 use windows::Win32::UI::WindowsAndMessaging::MSG;
-use windows::Win32::UI::WindowsAndMessaging::SM_CXVIRTUALSCREEN;
 use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;
-use windows::Win32::UI::WindowsAndMessaging::WM_SIZE;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
-use windows_core::PCWSTR;
-
-#[allow(clippy::expect_used)]
-static RENDER_FACTORY: LazyLock<ID2D1Factory> = unsafe {
-    LazyLock::new(|| {
-        D2D1CreateFactory::<ID2D1Factory>(D2D1_FACTORY_TYPE_MULTI_THREADED, None)
-            .expect("creating RENDER_FACTORY failed")
-    })
-};
-
-static BRUSH_PROPERTIES: LazyLock<D2D1_BRUSH_PROPERTIES> =
-    LazyLock::new(|| D2D1_BRUSH_PROPERTIES {
-        opacity: 1.0,
-        transform: Matrix3x2::identity(),
-    });

 pub extern "system" fn border_hwnds(hwnd: HWND, lparam: LPARAM) -> BOOL {
    let hwnds = unsafe { &mut *(lparam.0 as *mut Vec<isize>) };
@@ -114,6 +83,7 @@ impl Border {
        let window_class = WNDCLASSW {
            hInstance: h_module.into(),
            lpszClassName: class_name,
+            style: CS_HREDRAW | CS_VREDRAW,
            lpfnWndProc: Some(Self::callback),
            hbrBackground: WindowsApi::create_solid_brush(0),
            ..Default::default()
@@ -140,80 +110,32 @@ impl Border {
                    let _ = TranslateMessage(&msg);
                    DispatchMessageW(&msg);
                }
+
+                std::thread::sleep(Duration::from_millis(10))
            }

            Ok(())
        });

-        let hwnd = hwnd_receiver.recv()?;
-        let border = Self { hwnd };
-
-        // I have literally no idea, apparently this is to get rid of the black pixels
-        // around the edges of rounded corners? @lukeyou05 borrowed this from PowerToys
-        unsafe {
-            let pos: i32 = -GetSystemMetrics(SM_CXVIRTUALSCREEN) - 8;
-            let hrgn = CreateRectRgn(pos, 0, pos + 1, 1);
-            let mut bh: DWM_BLURBEHIND = Default::default();
-            if !hrgn.is_invalid() {
-                bh = DWM_BLURBEHIND {
-                    dwFlags: DWM_BB_ENABLE | DWM_BB_BLURREGION,
-                    fEnable: TRUE,
-                    hRgnBlur: hrgn,
-                    fTransitionOnMaximized: FALSE,
-                };
-            }
-
-            let _ = DwmEnableBlurBehindWindow(border.hwnd(), &bh);
-        }
-
-        let hwnd_render_target_properties = D2D1_HWND_RENDER_TARGET_PROPERTIES {
-            hwnd: HWND(windows_api::as_ptr!(hwnd)),
-            pixelSize: Default::default(),
-            presentOptions: D2D1_PRESENT_OPTIONS_IMMEDIATELY,
-        };
-
-        let render_target_properties = D2D1_RENDER_TARGET_PROPERTIES {
-            r#type: D2D1_RENDER_TARGET_TYPE_DEFAULT,
-            pixelFormat: D2D1_PIXEL_FORMAT {
-                format: DXGI_FORMAT_UNKNOWN,
-                alphaMode: D2D1_ALPHA_MODE_PREMULTIPLIED,
-            },
-            dpiX: 96.0,
-            dpiY: 96.0,
-            ..Default::default()
-        };
-
-        match unsafe {
-            RENDER_FACTORY
-                .CreateHwndRenderTarget(&render_target_properties, &hwnd_render_target_properties)
-        } {
-            Ok(render_target) => unsafe {
-                render_target.SetAntialiasMode(D2D1_ANTIALIAS_MODE_PER_PRIMITIVE);
-                let mut render_targets = RENDER_TARGETS.lock();
-                render_targets.insert(hwnd, render_target);
-                Ok(border)
-            },
-            Err(error) => Err(error.into()),
-        }
+        Ok(Self {
+            hwnd: hwnd_receiver.recv()?,
+        })
    }

    pub fn destroy(&self) -> color_eyre::Result<()> {
-        let mut render_targets = RENDER_TARGETS.lock();
-        render_targets.remove(&self.hwnd);
        WindowsApi::close_window(self.hwnd)
    }

-    pub fn update(&self, rect: &Rect, should_invalidate: bool) -> color_eyre::Result<()> {
+    pub fn update(&self, rect: &Rect, mut should_invalidate: bool) -> color_eyre::Result<()> {
        // Make adjustments to the border
        let mut rect = *rect;
-        rect.add_margin(BORDER_WIDTH.load(Ordering::Relaxed));
-        rect.add_padding(-BORDER_OFFSET.load(Ordering::Relaxed));
+        rect.add_margin(BORDER_WIDTH.load(Ordering::SeqCst));
+        rect.add_padding(-BORDER_OFFSET.load(Ordering::SeqCst));

        // Update the position of the border if required
-        // This effectively handles WM_MOVE
-        // Also if I remove this no borders render at all lol
        if !WindowsApi::window_rect(self.hwnd)?.eq(&rect) {
            WindowsApi::set_border_pos(self.hwnd, &rect, Z_ORDER.load().into())?;
+            should_invalidate = true;
        }

        // Invalidate the rect to trigger the callback to update colours etc.
@@ -236,104 +158,72 @@ impl Border {
    ) -> LRESULT {
        unsafe {
            match message {
-                WM_SIZE | WM_PAINT => {
-                    if let Ok(rect) = WindowsApi::window_rect(window.0 as isize) {
-                        let render_targets = RENDER_TARGETS.lock();
-                        if let Some(render_target) = render_targets.get(&(window.0 as isize)) {
-                            let pixel_size = D2D_SIZE_U {
-                                width: rect.right as u32,
-                                height: rect.bottom as u32,
+                WM_PAINT => {
+                    let mut ps = PAINTSTRUCT::default();
+                    let hdc = BeginPaint(window, &mut ps);
+
+                    // With the rect that we set in Self::update
+                    match WindowsApi::window_rect(window.0 as isize) {
+                        Ok(rect) => {
+                            // Grab the focus kind for this border
+                            let window_kind = {
+                                FOCUS_STATE
+                                    .lock()
+                                    .get(&(window.0 as isize))
+                                    .copied()
+                                    .unwrap_or(WindowKind::Unfocused)
                            };

-                            let border_width = BORDER_WIDTH.load(Ordering::SeqCst);
-                            let border_offset = BORDER_OFFSET.load(Ordering::SeqCst);
+                            // Set up the brush to draw the border
+                            let hpen = CreatePen(
+                                PS_SOLID | PS_INSIDEFRAME,
+                                BORDER_WIDTH.load(Ordering::SeqCst),
+                                COLORREF(window_kind_colour(window_kind)),
+                            );

-                            let rect = D2D_RECT_F {
-                                left: (border_width / 2 - border_offset) as f32,
-                                top: (border_width / 2 - border_offset) as f32,
-                                right: (rect.right - border_width / 2 + border_offset) as f32,
-                                bottom: (rect.bottom - border_width / 2 + border_offset) as f32,
-                            };
+                            let hbrush = WindowsApi::create_solid_brush(0);

-                            let _ = render_target.Resize(&pixel_size);
-
-                            // Get window kind and color
-                            let window_kind = FOCUS_STATE
-                                .lock()
-                                .get(&(window.0 as isize))
-                                .copied()
-                                .unwrap_or(WindowKind::Unfocused);
-
-                            let color = window_kind_colour(window_kind);
-                            let color = D2D1_COLOR_F {
-                                r: ((color & 0xFF) as f32) / 255.0,
-                                g: (((color >> 8) & 0xFF) as f32) / 255.0,
-                                b: (((color >> 16) & 0xFF) as f32) / 255.0,
-                                a: 1.0,
-                            };
-
-                            if let Ok(brush) = render_target
-                                .CreateSolidColorBrush(&color, Some(BRUSH_PROPERTIES.deref()))
-                            {
-                                render_target.BeginDraw();
-                                render_target.Clear(None);
-
-                                // Calculate border radius based on style
-                                let style = match STYLE.load() {
-                                    BorderStyle::System => {
-                                        if *WINDOWS_11 {
-                                            BorderStyle::Rounded
-                                        } else {
-                                            BorderStyle::Square
-                                        }
+                            // Draw the border
+                            SelectObject(hdc, hpen);
+                            SelectObject(hdc, hbrush);
+                            // TODO(raggi): this is approximately the correct curvature for
+                            // the top left of a Windows 11 window (DWMWCP_DEFAULT), but
+                            // often the bottom right has a different shape. Furthermore if
+                            // the window was made with DWMWCP_ROUNDSMALL then this is the
+                            // wrong size.  In the future we should read the DWM properties
+                            // of windows and attempt to match appropriately.
+                            match STYLE.load() {
+                                BorderStyle::System => {
+                                    if *WINDOWS_11 {
+                                        // TODO: error handling
+                                        let _ =
+                                            RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
+                                    } else {
+                                        // TODO: error handling
+                                        let _ = Rectangle(hdc, 0, 0, rect.right, rect.bottom);
                                    }
-                                    BorderStyle::Rounded => BorderStyle::Rounded,
-                                    BorderStyle::Square => BorderStyle::Square,
-                                };
-
-                                match style {
-                                    BorderStyle::Rounded => {
-                                        let radius = 8.0 + border_width as f32 / 2.0;
-                                        let rounded_rect = D2D1_ROUNDED_RECT {
-                                            rect,
-                                            radiusX: radius,
-                                            radiusY: radius,
-                                        };
-
-                                        render_target.DrawRoundedRectangle(
-                                            &rounded_rect,
-                                            &brush,
-                                            border_width as f32,
-                                            None,
-                                        );
-                                    }
-                                    BorderStyle::Square => {
-                                        let rect = D2D_RECT_F {
-                                            left: rect.left,
-                                            top: rect.top,
-                                            right: rect.right,
-                                            bottom: rect.bottom,
-                                        };
-
-                                        render_target.DrawRectangle(
-                                            &rect,
-                                            &brush,
-                                            border_width as f32,
-                                            None,
-                                        );
-                                    }
-                                    _ => {}
                                }
-
-                                let _ = render_target.EndDraw(None, None);
-
-                                // If we don't do this we'll get spammed with WM_PAINT according to Raymond Chen
-                                // https://stackoverflow.com/questions/41783234/why-does-my-call-to-d2d1rendertargetdrawtext-result-in-a-wm-paint-being-se#comment70756781_41783234
-                                let _ = BeginPaint(window, &mut PAINTSTRUCT::default());
-                                let _ = EndPaint(window, &PAINTSTRUCT::default());
+                                BorderStyle::Rounded => {
+                                    // TODO: error handling
+                                    let _ = RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
+                                }
+                                BorderStyle::Square => {
+                                    // TODO: error handling
+                                    let _ = Rectangle(hdc, 0, 0, rect.right, rect.bottom);
+                                }
                            }
+                            // TODO: error handling
+                            let _ = DeleteObject(hpen);
+                            // TODO: error handling
+                            let _ = DeleteObject(hbrush);
+                        }
+                        Err(error) => {
+                            tracing::error!("could not get border rect: {}", error.to_string())
                        }
                    }
+
+                    // TODO: error handling
+                    let _ = EndPaint(window, &ps);
                    LRESULT(0)
                }
                WM_DESTROY => {
--- a/komorebi/src/border_manager/mod.rs
+++ b/komorebi/src/border_manager/mod.rs
@@ -1,6 +1,7 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]

 mod border;
+
 use crate::core::BorderImplementation;
 use crate::core::BorderStyle;
 use crate::core::WindowKind;
@@ -29,10 +30,6 @@ use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::sync::OnceLock;
-use windows::Win32::Graphics::Direct2D::ID2D1HwndRenderTarget;
-use windows::Win32::System::Threading::GetCurrentThread;
-use windows::Win32::System::Threading::SetThreadPriority;
-use windows::Win32::System::Threading::THREAD_PRIORITY_TIME_CRITICAL;

 pub static BORDER_WIDTH: AtomicI32 = AtomicI32::new(8);
 pub static BORDER_OFFSET: AtomicI32 = AtomicI32::new(-1);
@@ -60,8 +57,6 @@ lazy_static! {
    static ref BORDERS_MONITORS: Mutex<HashMap<String, usize>> = Mutex::new(HashMap::new());
    static ref BORDER_STATE: Mutex<HashMap<String, Border>> = Mutex::new(HashMap::new());
    static ref FOCUS_STATE: Mutex<HashMap<isize, WindowKind>> = Mutex::new(HashMap::new());
-    static ref RENDER_TARGETS: Mutex<HashMap<isize, ID2D1HwndRenderTarget>> =
-        Mutex::new(HashMap::new());
 }

 pub struct Notification(pub Option<isize>);
@@ -94,13 +89,12 @@ pub fn destroy_all_borders() -> color_eyre::Result<()> {
    );

    for (_, border) in borders.iter() {
-        let _ = border.destroy();
+        border.destroy()?;
    }

    borders.clear();
    BORDERS_MONITORS.lock().clear();
    FOCUS_STATE.lock().clear();
-    RENDER_TARGETS.lock().clear();

    let mut remaining_hwnds = vec![];

@@ -113,7 +107,7 @@ pub fn destroy_all_borders() -> color_eyre::Result<()> {
        tracing::info!("purging unknown borders: {:?}", remaining_hwnds);

        for hwnd in remaining_hwnds {
-            let _ = Border::from(hwnd).destroy();
+            Border::from(hwnd).destroy()?;
        }
    }

@@ -131,22 +125,13 @@ fn window_kind_colour(focus_kind: WindowKind) -> u32 {
 }

 pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || {
-        unsafe {
-            if let Err(error) = SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL)
-            {
-                tracing::error!("{error}");
+    std::thread::spawn(move || loop {
+        match handle_notifications(wm.clone()) {
+            Ok(()) => {
+                tracing::warn!("restarting finished thread");
            }
-        }
-
-        loop {
-            match handle_notifications(wm.clone()) {
-                Ok(()) => {
-                    tracing::warn!("restarting finished thread");
-                }
-                Err(error) => {
-                    tracing::warn!("restarting failed thread: {}", error);
-                }
+            Err(error) => {
+                tracing::warn!("restarting failed thread: {}", error);
            }
        }
    });
@@ -172,8 +157,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
        let focused_workspace_idx =
            state.monitors.elements()[focused_monitor_idx].focused_workspace_idx();
        let monitors = state.monitors.clone();
-        let weak_pending_move_op = Arc::downgrade(&state.pending_move_op);
-        let pending_move_op = *state.pending_move_op;
+        let pending_move_op = state.pending_move_op;
        let floating_window_hwnds = state.monitors.elements()[focused_monitor_idx].workspaces()
            [focused_workspace_idx]
            .floating_windows()
@@ -429,19 +413,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                    c.focused_window().copied().unwrap_or_default().hwnd,
                                )?;

-                                // We create a new variable to track the actual pending move op so
-                                // that the other variable `pending_move_op` still holds the
-                                // pending move info so that when the move ends we know on the next
-                                // notification that the previous pending move and pending move are
-                                // different (because a move just finished) and still handle the
-                                // notification. If otherwise we updated the pending_move_op here
-                                // directly then the next pending move after finish would be the
-                                // same because we had already updated it here.
-                                let mut sync_pending_move_op =
-                                    weak_pending_move_op.upgrade().and_then(|p| *p);
-                                while sync_pending_move_op.is_some() {
-                                    sync_pending_move_op =
-                                        weak_pending_move_op.upgrade().and_then(|p| *p);
+                                while WindowsApi::lbutton_is_pressed() {
                                    let border = match borders.entry(c.id().clone()) {
                                        Entry::Occupied(entry) => entry.into_mut(),
                                        Entry::Vacant(entry) => {
@@ -459,7 +431,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result

                                    if rect != new_rect {
                                        rect = new_rect;
-                                        border.update(&rect, false)?;
+                                        border.update(&rect, true)?;
                                    }
                                }

@@ -524,12 +496,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                if pending_move_op.is_some() && hwnd == notification_hwnd {
                                    let mut rect = WindowsApi::window_rect(hwnd)?;

-                                    // Check comment above for containers move
-                                    let mut sync_pending_move_op =
-                                        weak_pending_move_op.upgrade().and_then(|p| *p);
-                                    while sync_pending_move_op.is_some() {
-                                        sync_pending_move_op =
-                                            weak_pending_move_op.upgrade().and_then(|p| *p);
+                                    while WindowsApi::lbutton_is_pressed() {
                                        let border = match borders.entry(hwnd.to_string()) {
                                            Entry::Occupied(entry) => entry.into_mut(),
                                            Entry::Vacant(entry) => {
--- a/komorebi/src/core/mod.rs
+++ b/komorebi/src/core/mod.rs
@@ -14,7 +14,6 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;

-use crate::KomorebiTheme;
 pub use animation::AnimationStyle;
 pub use arrangement::Arrangement;
 pub use arrangement::Axis;
@@ -49,7 +48,6 @@ pub enum SocketMessage {
    StackWindow(OperationDirection),
    UnstackWindow,
    CycleStack(CycleDirection),
-    CycleStackIndex(CycleDirection),
    FocusStackWindow(usize),
    StackAll,
    UnstackAll,
@@ -115,7 +113,6 @@ pub enum SocketMessage {
    CycleFocusWorkspace(CycleDirection),
    FocusMonitorNumber(usize),
    FocusLastWorkspace,
-    CloseWorkspace,
    FocusWorkspaceNumber(usize),
    FocusWorkspaceNumbers(usize),
    FocusMonitorWorkspaceNumber(usize, usize),
@@ -146,7 +143,6 @@ pub enum SocketMessage {
    WatchConfiguration(bool),
    CompleteConfiguration,
    AltFocusHack(bool),
-    Theme(KomorebiTheme),
    Animation(bool),
    AnimationDuration(u64),
    AnimationFps(u64),
--- a/komorebi/src/lib.rs
+++ b/komorebi/src/lib.rs
@@ -20,7 +20,6 @@ pub mod set_window_position;
 pub mod stackbar_manager;
 pub mod static_config;
 pub mod styles;
-pub mod theme_manager;
 pub mod transparency_manager;
 pub mod window;
 pub mod window_manager;
@@ -301,12 +300,10 @@ pub struct Notification {
 }

 pub fn notify_subscribers(notification: Notification, state_has_been_modified: bool) -> Result<()> {
-    let is_override_event = matches!(
+    let is_subscription_event = matches!(
        notification.event,
        NotificationEvent::Socket(SocketMessage::AddSubscriberSocket(_))
            | NotificationEvent::Socket(SocketMessage::AddSubscriberSocketWithOptions(_, _))
-            | NotificationEvent::Socket(SocketMessage::Theme(_))
-            | NotificationEvent::Socket(SocketMessage::ReloadStaticConfiguration(_))
    );

    let notification = &serde_json::to_string(&notification)?;
@@ -321,7 +318,7 @@ pub fn notify_subscribers(notification: Notification, state_has_been_modified: b
            .unwrap_or_default()
            .filter_state_changes;

-        if !apply_state_filter || state_has_been_modified || is_override_event {
+        if !apply_state_filter || state_has_been_modified || is_subscription_event {
            match UnixStream::connect(path) {
                Ok(mut stream) => {
                    tracing::debug!("pushed notification to subscriber: {socket}");
--- a/komorebi/src/main.rs
+++ b/komorebi/src/main.rs
@@ -38,7 +38,6 @@ use komorebi::process_movement::listen_for_movements;
 use komorebi::reaper;
 use komorebi::stackbar_manager;
 use komorebi::static_config::StaticConfig;
-use komorebi::theme_manager;
 use komorebi::transparency_manager;
 use komorebi::window_manager::WindowManager;
 use komorebi::windows_api::WindowsApi;
@@ -272,7 +271,6 @@ fn main() -> Result<()> {
    monitor_reconciliator::listen_for_notifications(wm.clone())?;
    reaper::watch_for_orphans(wm.clone());
    focus_manager::listen_for_notifications(wm.clone());
-    theme_manager::listen_for_notifications();

    let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
    ctrlc::set_handler(move || {
--- a/komorebi/src/process_command.rs
+++ b/komorebi/src/process_command.rs
@@ -51,7 +51,6 @@ use crate::stackbar_manager;
 use crate::stackbar_manager::STACKBAR_FONT_FAMILY;
 use crate::stackbar_manager::STACKBAR_FONT_SIZE;
 use crate::static_config::StaticConfig;
-use crate::theme_manager;
 use crate::transparency_manager;
 use crate::window::RuleDebug;
 use crate::window::Window;
@@ -109,19 +108,10 @@ pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
            tracing::info!("listening on komorebi.sock");
            for client in listener.incoming() {
                match client {
-                    Ok(stream) => {
-                        let wm_clone = wm.clone();
-                        std::thread::spawn(move || {
-                            match stream.set_read_timeout(Some(Duration::from_secs(1))) {
-                                Ok(()) => {}
-                                Err(error) => tracing::error!("{}", error),
-                            }
-                            match read_commands_uds(&wm_clone, stream) {
-                                Ok(()) => {}
-                                Err(error) => tracing::error!("{}", error),
-                            }
-                        });
-                    }
+                    Ok(stream) => match read_commands_uds(&wm, stream) {
+                        Ok(()) => {}
+                        Err(error) => tracing::error!("{}", error),
+                    },
                    Err(error) => {
                        tracing::error!("{}", error);
                        break;
@@ -247,10 +237,6 @@ impl WindowManager {
                self.cycle_container_window_in_direction(direction)?;
                self.focused_window()?.focus(self.mouse_follows_focus)?;
            }
-            SocketMessage::CycleStackIndex(direction) => {
-                self.cycle_container_window_index_in_direction(direction)?;
-                self.focused_window()?.focus(self.mouse_follows_focus)?;
-            }
            SocketMessage::FocusStackWindow(idx) => {
                // In case you are using this command on a bar on a monitor
                // different from the currently focused one, you'd want that
@@ -774,44 +760,6 @@ impl WindowManager {

                self.focus_workspace(workspace_idx)?;
            }
-            SocketMessage::CloseWorkspace => {
-                // This is to ensure that even on an empty workspace on a secondary monitor, the
-                // secondary monitor where the cursor is focused will be used as the target for
-                // the workspace switch op
-                if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
-                    self.focus_monitor(monitor_idx)?;
-                }
-
-                let mut can_close = false;
-
-                if let Some(monitor) = self.focused_monitor_mut() {
-                    let focused_workspace_idx = monitor.focused_workspace_idx();
-                    let last_focused_workspace = monitor
-                        .last_focused_workspace()
-                        .unwrap_or(focused_workspace_idx.saturating_sub(1));
-
-                    if let Some(workspace) = monitor.focused_workspace() {
-                        if monitor.workspaces().len() > 1
-                            && workspace.containers().is_empty()
-                            && workspace.floating_windows().is_empty()
-                            && workspace.monocle_container().is_none()
-                            && workspace.maximized_window().is_none()
-                            && workspace.name().is_none()
-                        {
-                            can_close = true;
-                        }
-                    }
-
-                    if can_close
-                        && monitor
-                            .workspaces_mut()
-                            .remove(focused_workspace_idx)
-                            .is_some()
-                    {
-                        self.focus_workspace(last_focused_workspace)?;
-                    }
-                }
-            }
            SocketMessage::FocusLastWorkspace => {
                // This is to ensure that even on an empty workspace on a secondary monitor, the
                // secondary monitor where the cursor is focused will be used as the target for
@@ -1640,9 +1588,6 @@ impl WindowManager {

                reply.write_all(schema.as_bytes())?;
            }
-            SocketMessage::Theme(theme) => {
-                theme_manager::send_notification(theme);
-            }
            // Deprecated commands
            SocketMessage::AltFocusHack(_)
            | SocketMessage::IdentifyBorderOverflowApplication(_, _) => {}
--- a/komorebi/src/process_event.rs
+++ b/komorebi/src/process_event.rs
@@ -228,7 +228,8 @@ impl WindowManager {
                    .is_some();

                    if !window.is_window()
-                        || (should_act && !programmatically_hidden_hwnds.contains(&window.hwnd))
+                        || should_act
+                        || !programmatically_hidden_hwnds.contains(&window.hwnd)
                    {
                        hide = true;
                    }
@@ -278,190 +279,158 @@ impl WindowManager {
            WindowManagerEvent::Show(_, window)
            | WindowManagerEvent::Manage(window)
            | WindowManagerEvent::Uncloak(_, window) => {
-                if matches!(event, WindowManagerEvent::Uncloak(_, _))
-                    && self.uncloack_to_ignore >= 1
-                {
-                    tracing::info!("ignoring uncloak after monocle move by mouse across monitors");
-                    self.uncloack_to_ignore = self.uncloack_to_ignore.saturating_sub(1);
-                } else {
-                    let focused_monitor_idx = self.focused_monitor_idx();
-                    let focused_workspace_idx =
-                        self.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;
+                let focused_monitor_idx = self.focused_monitor_idx();
+                let focused_workspace_idx =
+                    self.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;

-                    let focused_pair = (focused_monitor_idx, focused_workspace_idx);
+                let focused_pair = (focused_monitor_idx, focused_workspace_idx);

-                    let mut needs_reconciliation = false;
+                let mut needs_reconciliation = false;

-                    for (i, monitors) in self.monitors().iter().enumerate() {
-                        for (j, workspace) in monitors.workspaces().iter().enumerate() {
-                            if workspace.contains_window(window.hwnd) && focused_pair != (i, j) {
-                                // At this point we know we are going to send a notification to the workspace reconciliator
-                                // So we get the topmost window returned by EnumWindows, which is almost always the window
-                                // that has been selected by alt-tab
-                                if let Ok(alt_tab_windows) = WindowsApi::alt_tab_windows() {
-                                    if let Some(first) =
-                                        alt_tab_windows.iter().find(|w| w.title().is_ok())
-                                    {
-                                        // If our record of this HWND hasn't been updated in over a minute
-                                        let mut instant = ALT_TAB_HWND_INSTANT.lock();
-                                        if instant.elapsed().gt(&Duration::from_secs(1)) {
-                                            // Update our record with the HWND we just found
-                                            ALT_TAB_HWND.store(Some(first.hwnd));
-                                            // Update the timestamp of our record
-                                            *instant = Instant::now();
-                                        }
-                                    }
-                                }
-
-                                workspace_reconciliator::send_notification(i, j);
-                                needs_reconciliation = true;
-                            }
-                        }
-                    }
-
-                    // There are some applications such as Firefox where, if they are focused when a
-                    // workspace switch takes place, it will fire an additional Show event, which will
-                    // result in them being associated with both the original workspace and the workspace
-                    // being switched to. This loop is to try to ensure that we don't end up with
-                    // duplicates across multiple workspaces, as it results in ghost layout tiles.
-                    let mut proceed = true;
-
-                    for (i, monitor) in self.monitors().iter().enumerate() {
-                        for (j, workspace) in monitor.workspaces().iter().enumerate() {
-                            if workspace.contains_window(window.hwnd)
-                                && i != self.focused_monitor_idx()
-                                && j != monitor.focused_workspace_idx()
-                            {
-                                tracing::debug!(
-                                    "ignoring show event for window already associated with another workspace"
-                                );
-
-                                window.hide();
-                                proceed = false;
-                            }
-                        }
-                    }
-
-                    if proceed {
-                        let mut behaviour = self.window_management_behaviour(
-                            focused_monitor_idx,
-                            focused_workspace_idx,
-                        );
-                        let workspace = self.focused_workspace_mut()?;
-                        let workspace_contains_window = workspace.contains_window(window.hwnd);
-                        let monocle_container = workspace.monocle_container().clone();
-
-                        if !workspace_contains_window && !needs_reconciliation {
-                            let floating_applications = FLOATING_APPLICATIONS.lock();
-                            let regex_identifiers = REGEX_IDENTIFIERS.lock();
-                            let mut should_float = false;
-
-                            if !floating_applications.is_empty() {
-                                if let (Ok(title), Ok(exe_name), Ok(class), Ok(path)) =
-                                    (window.title(), window.exe(), window.class(), window.path())
+                for (i, monitors) in self.monitors().iter().enumerate() {
+                    for (j, workspace) in monitors.workspaces().iter().enumerate() {
+                        if workspace.contains_window(window.hwnd) && focused_pair != (i, j) {
+                            // At this point we know we are going to send a notification to the workspace reconciliator
+                            // So we get the topmost window returned by EnumWindows, which is almost always the window
+                            // that has been selected by alt-tab
+                            if let Ok(alt_tab_windows) = WindowsApi::alt_tab_windows() {
+                                if let Some(first) =
+                                    alt_tab_windows.iter().find(|w| w.title().is_ok())
                                {
-                                    should_float = should_act(
-                                        &title,
-                                        &exe_name,
-                                        &class,
-                                        &path,
-                                        &floating_applications,
-                                        &regex_identifiers,
-                                    )
-                                    .is_some();
-                                }
-                            }
-
-                            behaviour.float_override = behaviour.float_override
-                                || (should_float
-                                    && !matches!(event, WindowManagerEvent::Manage(_)));
-
-                            if behaviour.float_override {
-                                workspace.floating_windows_mut().push(window);
-                                self.update_focused_workspace(false, false)?;
-                            } else {
-                                match behaviour.current_behaviour {
-                                    WindowContainerBehaviour::Create => {
-                                        workspace.new_container_for_window(window);
-                                        self.update_focused_workspace(false, false)?;
-                                    }
-                                    WindowContainerBehaviour::Append => {
-                                        workspace
-                                            .focused_container_mut()
-                                            .ok_or_else(|| {
-                                                anyhow!("there is no focused container")
-                                            })?
-                                            .add_window(window);
-                                        self.update_focused_workspace(true, false)?;
-                                        stackbar_manager::send_notification();
+                                    // If our record of this HWND hasn't been updated in over a minute
+                                    let mut instant = ALT_TAB_HWND_INSTANT.lock();
+                                    if instant.elapsed().gt(&Duration::from_secs(1)) {
+                                        // Update our record with the HWND we just found
+                                        ALT_TAB_HWND.store(Some(first.hwnd));
+                                        // Update the timestamp of our record
+                                        *instant = Instant::now();
                                    }
                                }
                            }

-                            if (self.focused_workspace()?.containers().len() == 1
-                                && self.focused_workspace()?.floating_windows().is_empty())
-                                || (self.focused_workspace()?.containers().is_empty()
-                                    && self.focused_workspace()?.floating_windows().len() == 1)
+                            workspace_reconciliator::send_notification(i, j);
+                            needs_reconciliation = true;
+                        }
+                    }
+                }
+
+                // There are some applications such as Firefox where, if they are focused when a
+                // workspace switch takes place, it will fire an additional Show event, which will
+                // result in them being associated with both the original workspace and the workspace
+                // being switched to. This loop is to try to ensure that we don't end up with
+                // duplicates across multiple workspaces, as it results in ghost layout tiles.
+                let mut proceed = true;
+
+                for (i, monitor) in self.monitors().iter().enumerate() {
+                    for (j, workspace) in monitor.workspaces().iter().enumerate() {
+                        if workspace.container_for_window(window.hwnd).is_some()
+                            && i != self.focused_monitor_idx()
+                            && j != monitor.focused_workspace_idx()
+                        {
+                            tracing::debug!(
+                                "ignoring show event for window already associated with another workspace"
+                            );
+
+                            window.hide();
+                            proceed = false;
+                        }
+                    }
+                }
+
+                if proceed {
+                    let mut behaviour = self
+                        .window_management_behaviour(focused_monitor_idx, focused_workspace_idx);
+                    let workspace = self.focused_workspace_mut()?;
+                    let workspace_contains_window = workspace.contains_window(window.hwnd);
+                    let monocle_container = workspace.monocle_container().clone();
+
+                    if !workspace_contains_window && !needs_reconciliation {
+                        let floating_applications = FLOATING_APPLICATIONS.lock();
+                        let regex_identifiers = REGEX_IDENTIFIERS.lock();
+                        let mut should_float = false;
+
+                        if !floating_applications.is_empty() {
+                            if let (Ok(title), Ok(exe_name), Ok(class), Ok(path)) =
+                                (window.title(), window.exe(), window.class(), window.path())
                            {
-                                // If after adding this window the workspace only contains 1 window, it
-                                // means it was previously empty and we focused the desktop to unfocus
-                                // any previous window from other workspace, so now we need to focus
-                                // this window again. This is needed because sometimes some windows
-                                // first send the `FocusChange` event and only the `Show` event after
-                                // and we will be focusing the desktop on the `FocusChange` event since
-                                // it is still empty.
-                                window.focus(self.mouse_follows_focus)?;
+                                should_float = should_act(
+                                    &title,
+                                    &exe_name,
+                                    &class,
+                                    &path,
+                                    &floating_applications,
+                                    &regex_identifiers,
+                                )
+                                .is_some();
                            }
                        }

-                        if workspace_contains_window {
-                            let mut monocle_window_event = false;
-                            if let Some(ref monocle) = monocle_container {
-                                if let Some(monocle_window) = monocle.focused_window() {
-                                    if monocle_window.hwnd == window.hwnd {
-                                        monocle_window_event = true;
-                                    }
+                        behaviour.float_override = behaviour.float_override
+                            || (should_float && !matches!(event, WindowManagerEvent::Manage(_)));
+
+                        if behaviour.float_override {
+                            workspace.floating_windows_mut().push(window);
+                            self.update_focused_workspace(false, false)?;
+                        } else {
+                            match behaviour.current_behaviour {
+                                WindowContainerBehaviour::Create => {
+                                    workspace.new_container_for_window(window);
+                                    self.update_focused_workspace(false, false)?;
+                                }
+                                WindowContainerBehaviour::Append => {
+                                    workspace
+                                        .focused_container_mut()
+                                        .ok_or_else(|| anyhow!("there is no focused container"))?
+                                        .add_window(window);
+                                    self.update_focused_workspace(true, false)?;
+                                    stackbar_manager::send_notification();
                                }
                            }
+                        }
+                    }

-                            if !monocle_window_event && monocle_container.is_some() {
-                                window.hide();
+                    if workspace_contains_window {
+                        let mut monocle_window_event = false;
+                        if let Some(ref monocle) = monocle_container {
+                            if let Some(monocle_window) = monocle.focused_window() {
+                                if monocle_window.hwnd == window.hwnd {
+                                    monocle_window_event = true;
+                                }
                            }
                        }
+
+                        if !monocle_window_event && monocle_container.is_some() {
+                            window.hide();
+                        }
                    }
                }
            }
            WindowManagerEvent::MoveResizeStart(_, window) => {
-                let monitor_idx = self.focused_monitor_idx();
-                let workspace_idx = self
-                    .focused_monitor()
-                    .ok_or_else(|| anyhow!("there is no monitor with this idx"))?
-                    .focused_workspace_idx();
+                if *self.focused_workspace()?.tile() {
+                    let monitor_idx = self.focused_monitor_idx();
+                    let workspace_idx = self
+                        .focused_monitor()
+                        .ok_or_else(|| anyhow!("there is no monitor with this idx"))?
+                        .focused_workspace_idx();
+                    let container_idx = self
+                        .focused_monitor()
+                        .ok_or_else(|| anyhow!("there is no monitor with this idx"))?
+                        .focused_workspace()
+                        .ok_or_else(|| anyhow!("there is no workspace with this idx"))?
+                        .focused_container_idx();

-                WindowsApi::bring_window_to_top(window.hwnd)?;
+                    WindowsApi::bring_window_to_top(window.hwnd)?;

-                let pending_move_op = Arc::make_mut(&mut self.pending_move_op);
-                *pending_move_op = Option::from((monitor_idx, workspace_idx, window.hwnd));
+                    self.pending_move_op =
+                        Option::from((monitor_idx, workspace_idx, container_idx));
+                }
            }
            WindowManagerEvent::MoveResizeEnd(_, window) => {
                // We need this because if the event ends on a different monitor,
                // that monitor will already have been focused and updated in the state
-                let pending = *self.pending_move_op;
+                let pending = self.pending_move_op;
                // Always consume the pending move op whenever this event is handled
-                let pending_move_op = Arc::make_mut(&mut self.pending_move_op);
-                *pending_move_op = None;
-
-                // If the window handles don't match then something went wrong and the pending move
-                // is not related to this current move, if so abort this operation.
-                if let Some((_, _, w_hwnd)) = pending {
-                    if w_hwnd != window.hwnd {
-                        color_eyre::eyre::bail!(
-                            "window handles for move operation don't match: {} != {}",
-                            w_hwnd,
-                            window.hwnd
-                        );
-                    }
-                }
+                self.pending_move_op = None;

                let target_monitor_idx = self
                    .monitor_idx_from_current_pos()
@@ -507,7 +476,8 @@ impl WindowManager {
                                .get(origin_workspace_idx)
                                .ok_or_else(|| anyhow!("cannot get workspace idx"))?;

-                            let managed_window = origin_workspace.contains_window(window.hwnd);
+                            let managed_window =
+                                origin_workspace.contains_managed_window(window.hwnd);

                            if !managed_window {
                                moved_across_monitors = false;
@@ -537,8 +507,11 @@ impl WindowManager {
                        tracing::info!("moving with mouse");

                        if moved_across_monitors {
-                            if let Some((origin_monitor_idx, origin_workspace_idx, w_hwnd)) =
-                                pending
+                            if let Some((
+                                origin_monitor_idx,
+                                origin_workspace_idx,
+                                origin_container_idx,
+                            )) = pending
                            {
                                let target_workspace_idx = self
                                    .monitors()
@@ -558,13 +531,18 @@ impl WindowManager {
                                    // Default to 0 in the case of an empty workspace
                                    .unwrap_or(0);

-                                let origin = (origin_monitor_idx, origin_workspace_idx, w_hwnd);
-                                let target = (
-                                    target_monitor_idx,
-                                    target_workspace_idx,
-                                    target_container_idx,
-                                );
-                                self.transfer_window(origin, target)?;
+                                self.transfer_container(
+                                    (
+                                        origin_monitor_idx,
+                                        origin_workspace_idx,
+                                        origin_container_idx,
+                                    ),
+                                    (
+                                        target_monitor_idx,
+                                        target_workspace_idx,
+                                        target_container_idx,
+                                    ),
+                                )?;

                                // We want to make sure both the origin and target monitors are updated,
                                // so that we don't have ghost tiles until we force an interaction on
@@ -576,10 +554,9 @@ impl WindowManager {
                                self.focus_monitor(target_monitor_idx)?;
                                self.focus_workspace(target_workspace_idx)?;
                                self.update_focused_workspace(false, false)?;
-
-                                // Make sure to give focus to the moved window again
-                                window.focus(self.mouse_follows_focus)?;
                            }
+                            // Here we handle a simple move on the same monitor which is treated as
+                            // a container swap
                        } else if window_management_behaviour.float_override {
                            workspace.floating_windows_mut().push(window);
                            self.update_focused_workspace(false, false)?;
--- a/komorebi/src/static_config.rs
+++ b/komorebi/src/static_config.rs
@@ -20,7 +20,6 @@ use crate::stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
 use crate::stackbar_manager::STACKBAR_TAB_HEIGHT;
 use crate::stackbar_manager::STACKBAR_TAB_WIDTH;
 use crate::stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
-use crate::theme_manager;
 use crate::transparency_manager;
 use crate::window;
 use crate::window_manager::WindowManager;
@@ -233,7 +232,7 @@ impl From<&Monitor> for MonitorConfig {
 }

 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
-/// The `komorebi.json` static configuration file reference for `v0.1.31`
+/// The `komorebi.json` static configuration file reference for `v0.1.30`
 pub struct StaticConfig {
    /// DEPRECATED from v0.1.22: no longer required
    #[serde(skip_serializing_if = "Option::is_none")]
@@ -269,7 +268,7 @@ pub struct StaticConfig {
    /// Enable or disable mouse follows focus (default: true)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mouse_follows_focus: Option<bool>,
-    /// Path to applications.json from komorebi-application-specific-configurations (default: None)
+    /// Path to applications.yaml from komorebi-application-specific-configurations (default: None)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub app_specific_configuration_path: Option<PathBuf>,
    /// Width of the window border (default: 8)
@@ -387,7 +386,7 @@ pub struct AnimationsConfig {
 pub enum KomorebiTheme {
    /// A theme from catppuccin-egui
    Catppuccin {
-        /// Name of the Catppuccin theme (theme previews: https://github.com/catppuccin/catppuccin)
+        /// Name of the Catppuccin theme
        name: komorebi_themes::Catppuccin,
        /// Border colour when the container contains a single window (default: Blue)
        single_border: Option<komorebi_themes::CatppuccinValue>,
@@ -410,7 +409,7 @@ pub enum KomorebiTheme {
    },
    /// A theme from base16-egui-themes
    Base16 {
-        /// Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)
+        /// Name of the Base16 theme
        name: komorebi_themes::Base16,
        /// Border colour when the container contains a single window (default: Base0D)
        single_border: Option<komorebi_themes::Base16Value>,
@@ -458,7 +457,6 @@ impl StaticConfig {
            println!("\nEnd-of-life features will not receive any further bug fixes or updates; they should not be used\n")
        }
    }
-
    pub fn aliases(raw: &str) {
        let mut map = HashMap::new();
        map.insert("border", ["active_window_border"]);
@@ -466,8 +464,6 @@ impl StaticConfig {
        map.insert("border_offset", ["active_window_border_offset"]);
        map.insert("border_colours", ["active_window_border_colours"]);
        map.insert("border_style", ["active_window_border_style"]);
-        map.insert("applications.json", ["applications.yaml"]);
-        map.insert("ignore_rules", ["float_rules"]);

        let mut display = false;

@@ -819,7 +815,151 @@ impl StaticConfig {
        }

        if let Some(theme) = &self.theme {
-            theme_manager::send_notification(*theme);
+            let (
+                single_border,
+                stack_border,
+                monocle_border,
+                floating_border,
+                unfocused_border,
+                stackbar_focused_text,
+                stackbar_unfocused_text,
+                stackbar_background,
+            ) = match theme {
+                KomorebiTheme::Catppuccin {
+                    name,
+                    single_border,
+                    stack_border,
+                    monocle_border,
+                    floating_border,
+                    unfocused_border,
+                    stackbar_focused_text,
+                    stackbar_unfocused_text,
+                    stackbar_background,
+                    ..
+                } => {
+                    let single_border = single_border
+                        .unwrap_or(komorebi_themes::CatppuccinValue::Blue)
+                        .color32(name.as_theme());
+
+                    let stack_border = stack_border
+                        .unwrap_or(komorebi_themes::CatppuccinValue::Green)
+                        .color32(name.as_theme());
+
+                    let monocle_border = monocle_border
+                        .unwrap_or(komorebi_themes::CatppuccinValue::Pink)
+                        .color32(name.as_theme());
+
+                    let floating_border = floating_border
+                        .unwrap_or(komorebi_themes::CatppuccinValue::Yellow)
+                        .color32(name.as_theme());
+
+                    let unfocused_border = unfocused_border
+                        .unwrap_or(komorebi_themes::CatppuccinValue::Base)
+                        .color32(name.as_theme());
+
+                    let stackbar_focused_text = stackbar_focused_text
+                        .unwrap_or(komorebi_themes::CatppuccinValue::Green)
+                        .color32(name.as_theme());
+
+                    let stackbar_unfocused_text = stackbar_unfocused_text
+                        .unwrap_or(komorebi_themes::CatppuccinValue::Text)
+                        .color32(name.as_theme());
+
+                    let stackbar_background = stackbar_background
+                        .unwrap_or(komorebi_themes::CatppuccinValue::Base)
+                        .color32(name.as_theme());
+
+                    (
+                        single_border,
+                        stack_border,
+                        monocle_border,
+                        floating_border,
+                        unfocused_border,
+                        stackbar_focused_text,
+                        stackbar_unfocused_text,
+                        stackbar_background,
+                    )
+                }
+                KomorebiTheme::Base16 {
+                    name,
+                    single_border,
+                    stack_border,
+                    monocle_border,
+                    floating_border,
+                    unfocused_border,
+                    stackbar_focused_text,
+                    stackbar_unfocused_text,
+                    stackbar_background,
+                    ..
+                } => {
+                    let single_border = single_border
+                        .unwrap_or(komorebi_themes::Base16Value::Base0D)
+                        .color32(*name);
+
+                    let stack_border = stack_border
+                        .unwrap_or(komorebi_themes::Base16Value::Base0B)
+                        .color32(*name);
+
+                    let monocle_border = monocle_border
+                        .unwrap_or(komorebi_themes::Base16Value::Base0F)
+                        .color32(*name);
+
+                    let unfocused_border = unfocused_border
+                        .unwrap_or(komorebi_themes::Base16Value::Base01)
+                        .color32(*name);
+
+                    let floating_border = floating_border
+                        .unwrap_or(komorebi_themes::Base16Value::Base09)
+                        .color32(*name);
+
+                    let stackbar_focused_text = stackbar_focused_text
+                        .unwrap_or(komorebi_themes::Base16Value::Base0B)
+                        .color32(*name);
+
+                    let stackbar_unfocused_text = stackbar_unfocused_text
+                        .unwrap_or(komorebi_themes::Base16Value::Base05)
+                        .color32(*name);
+
+                    let stackbar_background = stackbar_background
+                        .unwrap_or(komorebi_themes::Base16Value::Base01)
+                        .color32(*name);
+
+                    (
+                        single_border,
+                        stack_border,
+                        monocle_border,
+                        floating_border,
+                        unfocused_border,
+                        stackbar_focused_text,
+                        stackbar_unfocused_text,
+                        stackbar_background,
+                    )
+                }
+            };
+
+            border_manager::FOCUSED.store(u32::from(Colour::from(single_border)), Ordering::SeqCst);
+            border_manager::MONOCLE
+                .store(u32::from(Colour::from(monocle_border)), Ordering::SeqCst);
+            border_manager::STACK.store(u32::from(Colour::from(stack_border)), Ordering::SeqCst);
+            border_manager::FLOATING
+                .store(u32::from(Colour::from(floating_border)), Ordering::SeqCst);
+            border_manager::UNFOCUSED
+                .store(u32::from(Colour::from(unfocused_border)), Ordering::SeqCst);
+
+            STACKBAR_TAB_BACKGROUND_COLOUR.store(
+                u32::from(Colour::from(stackbar_background)),
+                Ordering::SeqCst,
+            );
+
+            STACKBAR_FOCUSED_TEXT_COLOUR.store(
+                u32::from(Colour::from(stackbar_focused_text)),
+                Ordering::SeqCst,
+            );
+
+            STACKBAR_UNFOCUSED_TEXT_COLOUR.store(
+                u32::from(Colour::from(stackbar_unfocused_text)),
+                Ordering::SeqCst,
+            );
        }

        if let Some(path) = &self.app_specific_configuration_path {
@@ -1052,9 +1192,8 @@ impl StaticConfig {
            mouse_follows_focus: value.mouse_follows_focus.unwrap_or(true),
            hotwatch: Hotwatch::new()?,
            has_pending_raise_op: false,
-            pending_move_op: Arc::new(None),
+            pending_move_op: None,
            already_moved_window_handles: Arc::new(Mutex::new(HashSet::new())),
-            uncloack_to_ignore: 0,
        };

        match value.focus_follows_mouse {
@@ -1106,9 +1245,12 @@ impl StaticConfig {
                    );

                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
-                        if let Some(workspace_config) = monitor.workspaces.get(j) {
-                            ws.load_static_config(workspace_config)?;
-                        }
+                        ws.load_static_config(
+                            monitor
+                                .workspaces
+                                .get(j)
+                                .expect("no static workspace config"),
+                        )?;
                    }
                }

@@ -1166,9 +1308,12 @@ impl StaticConfig {
                    );

                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
-                        if let Some(workspace_config) = monitor.workspaces.get(j) {
-                            ws.load_static_config(workspace_config)?;
-                        }
+                        ws.load_static_config(
+                            monitor
+                                .workspaces
+                                .get(j)
+                                .expect("no static workspace config"),
+                        )?;
                    }
                }

--- a/komorebi/src/theme_manager.rs
+++ b/komorebi/src/theme_manager.rs
@@ -1,224 +0,0 @@
-#![deny(clippy::unwrap_used, clippy::expect_used)]
-
-use crate::border_manager;
-use crate::stackbar_manager;
-use crate::stackbar_manager::STACKBAR_FOCUSED_TEXT_COLOUR;
-use crate::stackbar_manager::STACKBAR_TAB_BACKGROUND_COLOUR;
-use crate::stackbar_manager::STACKBAR_UNFOCUSED_TEXT_COLOUR;
-use crate::Colour;
-use crate::KomorebiTheme;
-use crossbeam_channel::Receiver;
-use crossbeam_channel::Sender;
-use crossbeam_utils::atomic::AtomicCell;
-use std::ops::Deref;
-use std::sync::atomic::Ordering;
-use std::sync::OnceLock;
-
-pub struct Notification(KomorebiTheme);
-
-pub static CURRENT_THEME: AtomicCell<Option<KomorebiTheme>> = AtomicCell::new(None);
-
-impl Deref for Notification {
-    type Target = KomorebiTheme;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
-
-pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
-    CHANNEL.get_or_init(|| crossbeam_channel::bounded(20))
-}
-
-fn event_tx() -> Sender<Notification> {
-    channel().0.clone()
-}
-
-fn event_rx() -> Receiver<Notification> {
-    channel().1.clone()
-}
-
-// Currently this should only be used for async focus updates, such as
-// when an animation finishes and we need to focus to set the cursor
-// position if the user has mouse follows focus enabled
-pub fn send_notification(theme: KomorebiTheme) {
-    if event_tx().try_send(Notification(theme)).is_err() {
-        tracing::warn!("channel is full; dropping notification")
-    }
-}
-
-pub fn listen_for_notifications() {
-    std::thread::spawn(move || loop {
-        match handle_notifications() {
-            Ok(()) => {
-                tracing::warn!("restarting finished thread");
-            }
-            Err(error) => {
-                tracing::warn!("restarting failed thread: {}", error);
-            }
-        }
-    });
-}
-
-pub fn handle_notifications() -> color_eyre::Result<()> {
-    tracing::info!("listening");
-
-    let receiver = event_rx();
-
-    for notification in receiver {
-        let theme = &notification.0;
-
-        let (
-            single_border,
-            stack_border,
-            monocle_border,
-            floating_border,
-            unfocused_border,
-            stackbar_focused_text,
-            stackbar_unfocused_text,
-            stackbar_background,
-        ) = match theme {
-            KomorebiTheme::Catppuccin {
-                name,
-                single_border,
-                stack_border,
-                monocle_border,
-                floating_border,
-                unfocused_border,
-                stackbar_focused_text,
-                stackbar_unfocused_text,
-                stackbar_background,
-                ..
-            } => {
-                let single_border = single_border
-                    .unwrap_or(komorebi_themes::CatppuccinValue::Blue)
-                    .color32(name.as_theme());
-
-                let stack_border = stack_border
-                    .unwrap_or(komorebi_themes::CatppuccinValue::Green)
-                    .color32(name.as_theme());
-
-                let monocle_border = monocle_border
-                    .unwrap_or(komorebi_themes::CatppuccinValue::Pink)
-                    .color32(name.as_theme());
-
-                let floating_border = floating_border
-                    .unwrap_or(komorebi_themes::CatppuccinValue::Yellow)
-                    .color32(name.as_theme());
-
-                let unfocused_border = unfocused_border
-                    .unwrap_or(komorebi_themes::CatppuccinValue::Base)
-                    .color32(name.as_theme());
-
-                let stackbar_focused_text = stackbar_focused_text
-                    .unwrap_or(komorebi_themes::CatppuccinValue::Green)
-                    .color32(name.as_theme());
-
-                let stackbar_unfocused_text = stackbar_unfocused_text
-                    .unwrap_or(komorebi_themes::CatppuccinValue::Text)
-                    .color32(name.as_theme());
-
-                let stackbar_background = stackbar_background
-                    .unwrap_or(komorebi_themes::CatppuccinValue::Base)
-                    .color32(name.as_theme());
-
-                (
-                    single_border,
-                    stack_border,
-                    monocle_border,
-                    floating_border,
-                    unfocused_border,
-                    stackbar_focused_text,
-                    stackbar_unfocused_text,
-                    stackbar_background,
-                )
-            }
-            KomorebiTheme::Base16 {
-                name,
-                single_border,
-                stack_border,
-                monocle_border,
-                floating_border,
-                unfocused_border,
-                stackbar_focused_text,
-                stackbar_unfocused_text,
-                stackbar_background,
-                ..
-            } => {
-                let single_border = single_border
-                    .unwrap_or(komorebi_themes::Base16Value::Base0D)
-                    .color32(*name);
-
-                let stack_border = stack_border
-                    .unwrap_or(komorebi_themes::Base16Value::Base0B)
-                    .color32(*name);
-
-                let monocle_border = monocle_border
-                    .unwrap_or(komorebi_themes::Base16Value::Base0F)
-                    .color32(*name);
-
-                let unfocused_border = unfocused_border
-                    .unwrap_or(komorebi_themes::Base16Value::Base01)
-                    .color32(*name);
-
-                let floating_border = floating_border
-                    .unwrap_or(komorebi_themes::Base16Value::Base09)
-                    .color32(*name);
-
-                let stackbar_focused_text = stackbar_focused_text
-                    .unwrap_or(komorebi_themes::Base16Value::Base0B)
-                    .color32(*name);
-
-                let stackbar_unfocused_text = stackbar_unfocused_text
-                    .unwrap_or(komorebi_themes::Base16Value::Base05)
-                    .color32(*name);
-
-                let stackbar_background = stackbar_background
-                    .unwrap_or(komorebi_themes::Base16Value::Base01)
-                    .color32(*name);
-
-                (
-                    single_border,
-                    stack_border,
-                    monocle_border,
-                    floating_border,
-                    unfocused_border,
-                    stackbar_focused_text,
-                    stackbar_unfocused_text,
-                    stackbar_background,
-                )
-            }
-        };
-
-        border_manager::FOCUSED.store(u32::from(Colour::from(single_border)), Ordering::SeqCst);
-        border_manager::MONOCLE.store(u32::from(Colour::from(monocle_border)), Ordering::SeqCst);
-        border_manager::STACK.store(u32::from(Colour::from(stack_border)), Ordering::SeqCst);
-        border_manager::FLOATING.store(u32::from(Colour::from(floating_border)), Ordering::SeqCst);
-        border_manager::UNFOCUSED
-            .store(u32::from(Colour::from(unfocused_border)), Ordering::SeqCst);
-
-        STACKBAR_TAB_BACKGROUND_COLOUR.store(
-            u32::from(Colour::from(stackbar_background)),
-            Ordering::SeqCst,
-        );
-
-        STACKBAR_FOCUSED_TEXT_COLOUR.store(
-            u32::from(Colour::from(stackbar_focused_text)),
-            Ordering::SeqCst,
-        );
-
-        STACKBAR_UNFOCUSED_TEXT_COLOUR.store(
-            u32::from(Colour::from(stackbar_unfocused_text)),
-            Ordering::SeqCst,
-        );
-
-        CURRENT_THEME.store(Some(notification.0));
-
-        border_manager::send_notification(None);
-        stackbar_manager::send_notification();
-    }
-
-    Ok(())
-}
--- a/komorebi/src/window.rs
+++ b/komorebi/src/window.rs
@@ -41,7 +41,6 @@ use crate::styles::WindowStyle;
 use crate::transparency_manager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
-use crate::FLOATING_APPLICATIONS;
 use crate::HIDDEN_HWNDS;
 use crate::HIDING_BEHAVIOUR;
 use crate::IGNORE_IDENTIFIERS;
@@ -566,7 +565,6 @@ pub struct RuleDebug {
    pub matches_ignore_identifier: Option<MatchingRule>,
    pub matches_managed_override: Option<MatchingRule>,
    pub matches_layered_whitelist: Option<MatchingRule>,
-    pub matches_floating_applications: Option<MatchingRule>,
    pub matches_wsl2_gui: Option<String>,
    pub matches_no_titlebar: Option<String>,
 }
@@ -594,7 +592,7 @@ fn window_is_eligible(
    let regex_identifiers = REGEX_IDENTIFIERS.lock();

    let ignore_identifiers = IGNORE_IDENTIFIERS.lock();
-    let should_ignore = if let Some(rule) = should_act(
+    let should_float = if let Some(rule) = should_act(
        title,
        exe_name,
        class,
@@ -623,19 +621,7 @@ fn window_is_eligible(
        false
    };

-    let floating_identifiers = FLOATING_APPLICATIONS.lock();
-    if let Some(rule) = should_act(
-        title,
-        exe_name,
-        class,
-        path,
-        &floating_identifiers,
-        &regex_identifiers,
-    ) {
-        debug.matches_floating_applications = Some(rule);
-    }
-
-    if should_ignore && !managed_override {
+    if should_float && !managed_override {
        return false;
    }

@@ -777,7 +763,10 @@ pub fn should_act_individual(
    let mut should_act = false;

    match identifier.matching_strategy {
-        None | Some(MatchingStrategy::Legacy) => match identifier.kind {
+        None => {
+            panic!("there is no matching strategy identified for this rule");
+        }
+        Some(MatchingStrategy::Legacy) => match identifier.kind {
            ApplicationIdentifier::Title => {
                if title.starts_with(&identifier.id) || title.ends_with(&identifier.id) {
                    should_act = true;
--- a/komorebi/src/window_manager.rs
+++ b/komorebi/src/window_manager.rs
@@ -102,9 +102,8 @@ pub struct WindowManager {
    pub hotwatch: Hotwatch,
    pub virtual_desktop_id: Option<Vec<u8>>,
    pub has_pending_raise_op: bool,
-    pub pending_move_op: Arc<Option<(usize, usize, isize)>>,
+    pub pending_move_op: Option<(usize, usize, usize)>,
    pub already_moved_window_handles: Arc<Mutex<HashSet<isize>>>,
-    pub uncloack_to_ignore: usize,
 }

 #[allow(clippy::struct_excessive_bools)]
@@ -289,7 +288,6 @@ struct EnforceWorkspaceRuleOp {
    origin_workspace_idx: usize,
    target_monitor_idx: usize,
    target_workspace_idx: usize,
-    floating: bool,
 }
 impl EnforceWorkspaceRuleOp {
    const fn is_origin(&self, monitor_idx: usize, workspace_idx: usize) -> bool {
@@ -340,9 +338,8 @@ impl WindowManager {
            mouse_follows_focus: true,
            hotwatch: Hotwatch::new()?,
            has_pending_raise_op: false,
-            pending_move_op: Arc::new(None),
+            pending_move_op: None,
            already_moved_window_handles: Arc::new(Mutex::new(HashSet::new())),
-            uncloack_to_ignore: 0,
        })
    }

@@ -508,7 +505,6 @@ impl WindowManager {
        origin_workspace_idx: usize,
        target_monitor_idx: usize,
        target_workspace_idx: usize,
-        floating: bool,
        to_move: &mut Vec<EnforceWorkspaceRuleOp>,
    ) -> () {
        tracing::trace!(
@@ -525,7 +521,6 @@ impl WindowManager {
            origin_workspace_idx,
            target_monitor_idx,
            target_workspace_idx,
-            floating,
        });
    }

@@ -581,8 +576,6 @@ impl WindowManager {
                        };

                        if matched {
-                            let floating = workspace.floating_windows().contains(window);
-
                            if rule.initial_only {
                                if !already_moved_window_handles.contains(&window.hwnd) {
                                    already_moved_window_handles.insert(window.hwnd);
@@ -594,7 +587,6 @@ impl WindowManager {
                                        j,
                                        rule.monitor_index,
                                        rule.workspace_index,
-                                        floating,
                                        &mut to_move,
                                    );
                                }
@@ -606,7 +598,6 @@ impl WindowManager {
                                    j,
                                    rule.monitor_index,
                                    rule.workspace_index,
-                                    floating,
                                    &mut to_move,
                                );
                            }
@@ -625,34 +616,17 @@ impl WindowManager {

        // Parse the operation and remove any windows that are not placed according to their rules
        for op in &to_move {
-            let target_area = *self
-                .monitors_mut()
-                .get_mut(op.target_monitor_idx)
-                .ok_or_else(|| anyhow!("there is no monitor with that index"))?
-                .work_area_size();
-
-            let origin_monitor = self
+            let origin_workspace = self
                .monitors_mut()
                .get_mut(op.origin_monitor_idx)
-                .ok_or_else(|| anyhow!("there is no monitor with that index"))?;
-
-            let origin_area = *origin_monitor.work_area_size();
-
-            let origin_workspace = origin_monitor
+                .ok_or_else(|| anyhow!("there is no monitor with that index"))?
                .workspaces_mut()
                .get_mut(op.origin_workspace_idx)
                .ok_or_else(|| anyhow!("there is no workspace with that index"))?;

-            let mut window = Window::from(op.hwnd);
-
-            // If it is a floating window move it to the target area
-            if op.floating {
-                window.move_to_area(&origin_area, &target_area)?;
-            }
-
            // Hide the window we are about to remove if it is on the currently focused workspace
            if op.is_origin(focused_monitor_idx, focused_workspace_idx) {
-                window.hide();
+                Window::from(op.hwnd).hide();
                should_update_focused_workspace = true;
            }

@@ -682,21 +656,7 @@ impl WindowManager {
                .get_mut(op.target_workspace_idx)
                .ok_or_else(|| anyhow!("there is no workspace with that index"))?;

-            if op.floating {
-                target_workspace
-                    .floating_windows_mut()
-                    .push(Window::from(op.hwnd));
-            } else {
-                //TODO(alex-ds13): should this take into account the target workspace
-                //`window_container_behaviour`?
-                //In the case above a floating window should always be moved as floating,
-                //because it was set as so either manually by the user or by a
-                //`floating_applications` rule so it should stay that way. But a tiled window
-                //when moving to another workspace by a `workspace_rule` should honor that
-                //workspace `window_container_behaviour` in my opinion! Maybe this should be done
-                //on the `new_container_for_window` function instead.
-                target_workspace.new_container_for_window(Window::from(op.hwnd));
-            }
+            target_workspace.new_container_for_window(Window::from(op.hwnd));
        }

        // Only re-tile the focused workspace if we need to
@@ -821,133 +781,6 @@ impl WindowManager {
        Ok(())
    }

-    #[tracing::instrument(skip(self))]
-    pub fn transfer_window(
-        &mut self,
-        origin: (usize, usize, isize),
-        target: (usize, usize, usize),
-    ) -> Result<()> {
-        let (origin_monitor_idx, origin_workspace_idx, w_hwnd) = origin;
-        let (target_monitor_idx, target_workspace_idx, target_container_idx) = target;
-
-        let origin_workspace = self
-            .monitors_mut()
-            .get_mut(origin_monitor_idx)
-            .ok_or_else(|| anyhow!("cannot get monitor idx"))?
-            .workspaces_mut()
-            .get_mut(origin_workspace_idx)
-            .ok_or_else(|| anyhow!("cannot get workspace idx"))?;
-
-        let origin_container_idx = origin_workspace
-            .container_for_window(w_hwnd)
-            .and_then(|c| origin_workspace.containers().iter().position(|cc| cc == c));
-
-        if let Some(origin_container_idx) = origin_container_idx {
-            // Moving normal container window
-            self.transfer_container(
-                (
-                    origin_monitor_idx,
-                    origin_workspace_idx,
-                    origin_container_idx,
-                ),
-                (
-                    target_monitor_idx,
-                    target_workspace_idx,
-                    target_container_idx,
-                ),
-            )?;
-        } else if let Some(idx) = origin_workspace
-            .floating_windows()
-            .iter()
-            .position(|w| w.hwnd == w_hwnd)
-        {
-            // Moving floating window
-            // There is no need to physically move the floating window between areas with
-            // `move_to_area` because the user already did that, so we only need to transfer the
-            // window to the target `floating_windows`
-            let floating_window = origin_workspace.floating_windows_mut().remove(idx);
-
-            let target_workspace = self
-                .monitors_mut()
-                .get_mut(target_monitor_idx)
-                .ok_or_else(|| anyhow!("there is no monitor at this idx"))?
-                .focused_workspace_mut()
-                .ok_or_else(|| anyhow!("there is no focused workspace for this monitor"))?;
-
-            target_workspace
-                .floating_windows_mut()
-                .push(floating_window);
-        } else if origin_workspace
-            .monocle_container()
-            .as_ref()
-            .and_then(|monocle| monocle.focused_window().map(|w| w.hwnd == w_hwnd))
-            .unwrap_or_default()
-        {
-            // Moving monocle container
-            if let Some(monocle_idx) = origin_workspace.monocle_container_restore_idx() {
-                let origin_workspace = self
-                    .monitors_mut()
-                    .get_mut(origin_monitor_idx)
-                    .ok_or_else(|| anyhow!("there is no monitor at this idx"))?
-                    .workspaces_mut()
-                    .get_mut(origin_workspace_idx)
-                    .ok_or_else(|| anyhow!("there is no workspace for this monitor"))?;
-                let mut uncloack_amount = 0;
-                for container in origin_workspace.containers_mut() {
-                    container.restore();
-                    uncloack_amount += 1;
-                }
-                origin_workspace.reintegrate_monocle_container()?;
-
-                self.transfer_container(
-                    (origin_monitor_idx, origin_workspace_idx, monocle_idx),
-                    (
-                        target_monitor_idx,
-                        target_workspace_idx,
-                        target_container_idx,
-                    ),
-                )?;
-                // After we restore the origin workspace, some windows that were cloacked
-                // by the monocle might now be uncloacked which would trigger a workspace
-                // reconciliation since the focused monitor would be different from origin.
-                // That workspace reconciliation would focus the window on the origin monitor.
-                // So we need to ignore the uncloak events produced by the origin workspace
-                // restore to avoid that issue.
-                self.uncloack_to_ignore = uncloack_amount;
-            }
-        } else if origin_workspace
-            .maximized_window()
-            .as_ref()
-            .map(|max| max.hwnd == w_hwnd)
-            .unwrap_or_default()
-        {
-            // Moving maximized_window
-            if let Some(maximized_idx) = origin_workspace.maximized_window_restore_idx() {
-                self.focus_monitor(origin_monitor_idx)?;
-                let origin_monitor = self
-                    .focused_monitor_mut()
-                    .ok_or_else(|| anyhow!("there is no origin monitor"))?;
-                origin_monitor.focus_workspace(origin_workspace_idx)?;
-                self.unmaximize_window()?;
-                self.focus_monitor(target_monitor_idx)?;
-                let target_monitor = self
-                    .focused_monitor_mut()
-                    .ok_or_else(|| anyhow!("there is no target monitor"))?;
-                target_monitor.focus_workspace(target_workspace_idx)?;
-
-                self.transfer_container(
-                    (origin_monitor_idx, origin_workspace_idx, maximized_idx),
-                    (
-                        target_monitor_idx,
-                        target_workspace_idx,
-                        target_container_idx,
-                    ),
-                )?;
-            }
-        }
-        Ok(())
-    }
-
    #[tracing::instrument(skip(self))]
    pub fn transfer_container(
        &mut self,
@@ -1999,12 +1832,7 @@ impl WindowManager {

        tracing::info!("cycling container windows");

-        let container =
-            if let Some(container) = self.focused_workspace_mut()?.monocle_container_mut() {
-                container
-            } else {
-                self.focused_container_mut()?
-            };
+        let container = self.focused_container_mut()?;

        let len = NonZeroUsize::new(container.windows().len())
            .ok_or_else(|| anyhow!("there must be at least one window in a container"))?;
@@ -2022,51 +1850,13 @@ impl WindowManager {
        self.update_focused_workspace(self.mouse_follows_focus, true)
    }

-    #[tracing::instrument(skip(self))]
-    pub fn cycle_container_window_index_in_direction(
-        &mut self,
-        direction: CycleDirection,
-    ) -> Result<()> {
-        self.handle_unmanaged_window_behaviour()?;
-
-        tracing::info!("cycling container window index");
-
-        let container =
-            if let Some(container) = self.focused_workspace_mut()?.monocle_container_mut() {
-                container
-            } else {
-                self.focused_container_mut()?
-            };
-
-        let len = NonZeroUsize::new(container.windows().len())
-            .ok_or_else(|| anyhow!("there must be at least one window in a container"))?;
-
-        if len.get() == 1 {
-            bail!("there is only one window in this container");
-        }
-
-        let current_idx = container.focused_window_idx();
-        let next_idx = direction.next_idx(current_idx, len);
-        container.windows_mut().swap(current_idx, next_idx);
-
-        container.focus_window(next_idx);
-        container.load_focused_window();
-
-        self.update_focused_workspace(self.mouse_follows_focus, true)
-    }
-
    #[tracing::instrument(skip(self))]
    pub fn focus_container_window(&mut self, idx: usize) -> Result<()> {
        self.handle_unmanaged_window_behaviour()?;

        tracing::info!("focusing container window at index {idx}");

-        let container =
-            if let Some(container) = self.focused_workspace_mut()?.monocle_container_mut() {
-                container
-            } else {
-                self.focused_container_mut()?
-            };
+        let container = self.focused_container_mut()?;

        let len = NonZeroUsize::new(container.windows().len())
            .ok_or_else(|| anyhow!("there must be at least one window in a container"))?;
@@ -2182,16 +1972,8 @@ impl WindowManager {
                new_idx
            };

-            let mut target_container_is_stack = false;
-
-            if let Some(container) = workspace.containers().get(adjusted_new_index) {
-                if container.windows().len() > 1 {
-                    target_container_is_stack = true;
-                }
-            }
-
            if let Some(current) = workspace.focused_container() {
-                if current.windows().len() > 1 && !target_container_is_stack {
+                if current.windows().len() > 1 {
                    workspace.focus_container(adjusted_new_index);
                    workspace.move_window_to_container(current_container_idx)?;
                } else {
--- a/komorebi/src/windows_api.rs
+++ b/komorebi/src/windows_api.rs
@@ -300,21 +300,14 @@ impl WindowsApi {
                }
            }

-            if let Some(preference) = index_preference {
-                while *preference >= monitors.elements().len() {
+            if monitors.elements().is_empty() {
+                monitors.elements_mut().push_back(m);
+            } else if let Some(preference) = index_preference {
+                while *preference > monitors.elements().len() {
                    monitors.elements_mut().push_back(Monitor::placeholder());
                }

-                let current_name = monitors
-                    .elements_mut()
-                    .get(*preference)
-                    .map_or("", |m| m.name());
-                if current_name == "PLACEHOLDER" {
-                    let _ = monitors.elements_mut().remove(*preference);
-                    monitors.elements_mut().insert(*preference, m);
-                } else {
-                    monitors.elements_mut().insert(*preference, m);
-                }
+                monitors.elements_mut().insert(*preference, m);
            } else {
                monitors.elements_mut().push_back(m);
            }
--- a/komorebi/src/workspace.rs
+++ b/komorebi/src/workspace.rs
@@ -357,7 +357,21 @@ impl Workspace {
                for (i, container) in containers.iter_mut().enumerate() {
                    let window_count = container.windows().len();

-                    if let Some(layout) = layouts.get_mut(i) {
+                    if let (Some(window), Some(layout)) =
+                        (container.focused_window_mut(), layouts.get_mut(i))
+                    {
+                        if should_remove_titlebars && no_titlebar.contains(&window.exe()?) {
+                            window.remove_title_bar()?;
+                        } else if no_titlebar.contains(&window.exe()?) {
+                            window.add_title_bar()?;
+                        }
+
+                        // If a window has been unmaximized via toggle-maximize, this block
+                        // will make sure that it is unmaximized via restore_window
+                        if window.is_maximized() && !managed_maximized_window {
+                            WindowsApi::restore_window(window.hwnd);
+                        }
+
                        {
                            let border_offset = BORDER_OFFSET.load(Ordering::SeqCst);
                            layout.add_padding(border_offset);
@@ -374,25 +388,7 @@ impl Workspace {
                            layout.bottom -= total_height;
                        }

-                        for window in container.windows() {
-                            if container
-                                .focused_window()
-                                .is_some_and(|w| w.hwnd == window.hwnd)
-                            {
-                                if should_remove_titlebars && no_titlebar.contains(&window.exe()?) {
-                                    window.remove_title_bar()?;
-                                } else if no_titlebar.contains(&window.exe()?) {
-                                    window.add_title_bar()?;
-                                }
-
-                                // If a window has been unmaximized via toggle-maximize, this block
-                                // will make sure that it is unmaximized via restore_window
-                                if window.is_maximized() && !managed_maximized_window {
-                                    WindowsApi::restore_window(window.hwnd);
-                                }
-                            }
-                            window.set_position(layout, false)?;
-                        }
+                        window.set_position(layout, false)?;
                    }
                }

@@ -435,7 +431,7 @@ impl Workspace {
            }
        }

-        for window in self.visible_windows().into_iter().flatten() {
+        for window in self.visible_windows_mut().into_iter().flatten() {
            if !window.is_window() {
                hwnds.push(window.hwnd);
            }
@@ -1413,41 +1409,16 @@ impl Workspace {

    pub fn visible_windows(&self) -> Vec<Option<&Window>> {
        let mut vec = vec![];
-
-        vec.push(self.maximized_window().as_ref());
-
-        if let Some(monocle) = self.monocle_container() {
-            vec.push(monocle.focused_window());
-        }
-
        for container in self.containers() {
            vec.push(container.focused_window());
        }

-        for window in self.floating_windows() {
-            vec.push(Some(window));
-        }
-
        vec
    }

    pub fn visible_window_details(&self) -> Vec<WindowDetails> {
        let mut vec: Vec<WindowDetails> = vec![];

-        if let Some(maximized) = self.maximized_window() {
-            if let Ok(details) = (*maximized).try_into() {
-                vec.push(details);
-            }
-        }
-
-        if let Some(monocle) = self.monocle_container() {
-            if let Some(focused) = monocle.focused_window() {
-                if let Ok(details) = (*focused).try_into() {
-                    vec.push(details);
-                }
-            }
-        }
-
        for container in self.containers() {
            if let Some(focused) = container.focused_window() {
                if let Ok(details) = (*focused).try_into() {
@@ -1456,10 +1427,13 @@ impl Workspace {
            }
        }

-        for window in self.floating_windows() {
-            if let Ok(details) = (*window).try_into() {
-                vec.push(details);
-            }
+        vec
+    }
+
+    pub fn visible_windows_mut(&mut self) -> Vec<Option<&mut Window>> {
+        let mut vec = vec![];
+        for container in self.containers_mut() {
+            vec.push(container.focused_window_mut());
        }

        vec
--- a/komorebi/src/workspace_reconciliator.rs
+++ b/komorebi/src/workspace_reconciliator.rs
@@ -88,8 +88,6 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
            let mouse_follows_focus = wm.mouse_follows_focus;

            if let Some(monitor) = wm.focused_monitor_mut() {
-                let previous_idx = monitor.focused_workspace_idx();
-                monitor.set_last_focused_workspace(Option::from(previous_idx));
                monitor.focus_workspace(notification.workspace_idx)?;
                monitor.load_focused_workspace(mouse_follows_focus)?;
            }
--- a/komorebic-no-console/Cargo.toml
+++ b/komorebic-no-console/Cargo.toml
@@ -1,9 +1,11 @@
 [package]
 name = "komorebic-no-console"
-version = "0.1.31"
+version = "0.1.30"
+authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "The command-line interface (without a console) for Komorebi, a tiling window manager for Windows"
 categories = ["cli", "tiling-window-manager", "windows"]
 repository = "https://github.com/LGUG2Z/komorebi"
+license = "MIT"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
--- a/komorebic/Cargo.toml
+++ b/komorebic/Cargo.toml
@@ -1,9 +1,11 @@
 [package]
 name = "komorebic"
-version = "0.1.31"
+version = "0.1.30"
+authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
 categories = ["cli", "tiling-window-manager", "windows"]
 repository = "https://github.com/LGUG2Z/komorebi"
+license = "MIT"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -28,7 +30,7 @@ serde_json = { workspace = true }
 serde_yaml = "0.9"
 shadow-rs = { workspace = true }
 sysinfo = { workspace = true }
-thiserror = "2"
+thiserror = "1"
 uds_windows = { workspace = true }
 which = { workspace = true }
 win32-display-data = { workspace = true }
--- a/komorebic/build.rs
+++ b/komorebic/build.rs
@@ -1,9 +1,9 @@
 fn main() {
-    if std::fs::metadata("applications.json").is_err() {
-        let applications_json = reqwest::blocking::get(
-        "https://raw.githubusercontent.com/LGUG2Z/komorebi-application-specific-configuration/master/applications.json"
+    if std::fs::metadata("applications.yaml").is_err() {
+        let applications_yaml = reqwest::blocking::get(
+        "https://raw.githubusercontent.com/LGUG2Z/komorebi-application-specific-configuration/master/applications.yaml"
    ).unwrap().text().unwrap();
-        std::fs::write("applications.json", applications_json).unwrap();
+        std::fs::write("applications.yaml", applications_yaml).unwrap();
    }

    shadow_rs::new().unwrap();
--- a/komorebic/src/main.rs
+++ b/komorebic/src/main.rs
@@ -160,7 +160,6 @@ gen_enum_subcommand_args! {
    CycleMoveWorkspaceToMonitor: CycleDirection,
    Stack: OperationDirection,
    CycleStack: CycleDirection,
-    CycleStackIndex: CycleDirection,
    FlipLayout: Axis,
    ChangeLayout: DefaultLayout,
    CycleLayout: CycleDirection,
@@ -749,7 +748,6 @@ struct AnimationStyle {
 #[allow(clippy::struct_excessive_bools)]
 struct Start {
    /// Allow the use of komorebi's custom focus-follows-mouse implementation
-    #[clap(hide = true)]
    #[clap(short, long = "ffm")]
    ffm: bool,
    /// Path to a static configuration JSON file
@@ -777,9 +775,6 @@ struct Stop {
    /// Stop whkd if it is running as a background process
    #[clap(long)]
    whkd: bool,
-    /// Stop ahk if it is running as a background process
-    #[clap(long)]
-    ahk: bool,
    /// Stop komorebi-bar if it is running as a background process
    #[clap(long)]
    bar: bool,
@@ -867,7 +862,6 @@ struct EnableAutostart {
    #[clap(action, short, long)]
    config: Option<PathBuf>,
    /// Enable komorebi's custom focus-follows-mouse implementation
-    #[clap(hide = true)]
    #[clap(short, long = "ffm")]
    ffm: bool,
    /// Enable autostart of whkd
@@ -986,9 +980,6 @@ enum SubCommand {
    /// Cycle the focused stack in the specified cycle direction
    #[clap(arg_required_else_help = true)]
    CycleStack(CycleStack),
-    /// Cycle the index of the focused window in the focused stack in the specified cycle direction
-    #[clap(arg_required_else_help = true)]
-    CycleStackIndex(CycleStackIndex),
    /// Focus the specified window index in the focused stack
    #[clap(arg_required_else_help = true)]
    FocusStackWindow(FocusStackWindow),
@@ -1056,8 +1047,6 @@ enum SubCommand {
    /// Focus the specified workspace
    #[clap(arg_required_else_help = true)]
    FocusNamedWorkspace(FocusNamedWorkspace),
-    /// Close the focused workspace (must be empty and unnamed)
-    CloseWorkspace,
    /// Focus the monitor in the given cycle direction
    #[clap(arg_required_else_help = true)]
    CycleMonitor(CycleMonitor),
@@ -1106,7 +1095,6 @@ enum SubCommand {
    #[clap(arg_required_else_help = true)]
    CycleLayout(CycleLayout),
    /// Load a custom layout from file for the focused workspace
-    #[clap(hide = true)]
    #[clap(arg_required_else_help = true)]
    LoadCustomLayout(LoadCustomLayout),
    /// Flip the layout on the focused workspace (BSP only)
@@ -1151,11 +1139,9 @@ enum SubCommand {
    #[clap(arg_required_else_help = true)]
    NamedWorkspaceLayout(NamedWorkspaceLayout),
    /// Set a custom layout for the specified workspace
-    #[clap(hide = true)]
    #[clap(arg_required_else_help = true)]
    WorkspaceCustomLayout(WorkspaceCustomLayout),
    /// Set a custom layout for the specified workspace
-    #[clap(hide = true)]
    #[clap(arg_required_else_help = true)]
    NamedWorkspaceCustomLayout(NamedWorkspaceCustomLayout),
    /// Add a dynamic layout rule for the specified workspace
@@ -1165,11 +1151,9 @@ enum SubCommand {
    #[clap(arg_required_else_help = true)]
    NamedWorkspaceLayoutRule(NamedWorkspaceLayoutRule),
    /// Add a dynamic custom layout for the specified workspace
-    #[clap(hide = true)]
    #[clap(arg_required_else_help = true)]
    WorkspaceCustomLayoutRule(WorkspaceCustomLayoutRule),
    /// Add a dynamic custom layout for the specified workspace
-    #[clap(hide = true)]
    #[clap(arg_required_else_help = true)]
    NamedWorkspaceCustomLayoutRule(NamedWorkspaceCustomLayoutRule),
    /// Clear all dynamic layout rules for the specified workspace
@@ -1328,11 +1312,9 @@ enum SubCommand {
    #[clap(arg_required_else_help = true)]
    AnimationStyle(AnimationStyle),
    /// Enable or disable focus follows mouse for the operating system
-    #[clap(hide = true)]
    #[clap(arg_required_else_help = true)]
    FocusFollowsMouse(FocusFollowsMouse),
    /// Toggle focus follows mouse for the operating system
-    #[clap(hide = true)]
    #[clap(arg_required_else_help = true)]
    ToggleFocusFollowsMouse(ToggleFocusFollowsMouse),
    /// Enable or disable mouse follows focus on all workspaces
@@ -1355,12 +1337,11 @@ enum SubCommand {
    /// Format a YAML file for use with the 'app-specific-configuration' command
    #[clap(arg_required_else_help = true)]
    #[clap(alias = "fmt-asc")]
-    #[clap(hide = true)]
    FormatAppSpecificConfiguration(FormatAppSpecificConfiguration),
-    /// Fetch the latest version of applications.json from komorebi-application-specific-configuration
+    /// Fetch the latest version of applications.yaml from komorebi-application-specific-configuration
    #[clap(alias = "fetch-asc")]
    FetchAppSpecificConfiguration,
-    /// Generate a JSON Schema for applications.json
+    /// Generate a JSON Schema for applications.yaml
    #[clap(alias = "asc-schema")]
    ApplicationSpecificConfigurationSchema,
    /// Generate a JSON Schema of subscription notifications
@@ -1418,14 +1399,6 @@ fn main() -> Result<()> {
                "docgen",
                "alt-focus-hack",
                "identify-border-overflow-application",
-                "load-custom-layout",
-                "workspace-custom-layout",
-                "named-workspace-custom-layout",
-                "workspace-custom-layout-rule",
-                "named-workspace-custom-layout-rule",
-                "focus-follows-mouse",
-                "toggle-focus-follows-mouse",
-                "format-app-specific-configuration",
            ];

            for cmd in subcommands {
@@ -1458,13 +1431,13 @@ fn main() -> Result<()> {
            std::fs::write(HOME_DIR.join("komorebi.json"), komorebi_json)?;
            std::fs::write(HOME_DIR.join("komorebi.bar.json"), komorebi_bar_json)?;

-            let applications_json = include_str!("../applications.json");
-            std::fs::write(HOME_DIR.join("applications.json"), applications_json)?;
+            let applications_yaml = include_str!("../applications.yaml");
+            std::fs::write(HOME_DIR.join("applications.yaml"), applications_yaml)?;

            let whkdrc = include_str!("../../docs/whkdrc.sample");
            std::fs::write(WHKD_CONFIG_DIR.join("whkdrc"), whkdrc)?;

-            println!("Example komorebi.json, komorebi.bar.json, whkdrc and latest applications.json files created");
+            println!("Example komorebi.json, komorebi.bar.json, whkdrc and latest applications.yaml files created");
            println!("You can now run komorebic start --whkd --bar");
        }
        SubCommand::EnableAutostart(args) => {
@@ -2085,7 +2058,7 @@ if (!(Get-Process whkd -ErrorAction SilentlyContinue))
                    let mut config = StaticConfig::read(config)?;
                    if let Some(display_bar_configurations) = &mut config.bar_configurations {
                        for config_file_path in &mut *display_bar_configurations {
-                            let script = r#"Start-Process 'komorebi-bar' '--config "CONFIGFILE"' -WindowStyle hidden"#
+                            let script = r"Start-Process 'komorebi-bar' '--config CONFIGFILE' -WindowStyle hidden"
                            .replace("CONFIGFILE", &config_file_path.to_string_lossy());

                            match powershell_script::run(&script) {
@@ -2117,16 +2090,11 @@ if (!(Get-Process komorebi-bar -ErrorAction SilentlyContinue))
            }

            println!("\nThank you for using komorebi!\n");
-            println!("# Sponsorship");
-            println!("* Become a sponsor https://github.com/sponsors/LGUG2Z - $5/month makes a big difference");
-            println!("* Leave a tip https://ko-fi.com/lgug2z - An alternative to GitHub Sponsors");
+            println!("* Become a sponsor https://github.com/sponsors/LGUG2Z - Even $1/month makes a big difference");
            println!(
-                "* Subscribe to https://youtube.com/@LGUG2Z - Development videos, feature previews and release overviews"
+                "* Subscribe to https://youtube.com/@LGUG2Z - Live dev videos and feature previews"
            );
-            println!("\n# Community");
            println!("* Join the Discord https://discord.gg/mGkn66PHkx - Chat, ask questions, share your desktops");
-            println!("* Explore the Awesome Komorebi list https://github.com/LGUG2Z/awesome-komorebi - Projects in the komorebi ecosystem");
-            println!("\n# Documentation");
            println!("* Read the docs https://lgug2z.github.io/komorebi - Quickly search through all komorebic commands");

            let bar_config = arg.config.map_or_else(
@@ -2184,35 +2152,6 @@ Stop-Process -Name:komorebi-bar -ErrorAction SilentlyContinue
                }
            }

-            if arg.ahk {
-                let script = r#"
-if (Get-Command Get-CimInstance -ErrorAction SilentlyContinue) {
-    (Get-CimInstance Win32_Process | Where-Object {
-        ($_.CommandLine -like '*komorebi.ahk"') -and
-        ($_.Name -in @('AutoHotkey.exe', 'AutoHotkey64.exe', 'AutoHotkey32.exe', 'AutoHotkeyUX.exe'))
-    } | Select-Object -First 1) | ForEach-Object {
-        Stop-Process -Id $_.ProcessId -ErrorAction SilentlyContinue
-    }
-} else {
-    (Get-WmiObject Win32_Process | Where-Object {
-        ($_.CommandLine -like '*komorebi.ahk"') -and
-        ($_.Name -in @('AutoHotkey.exe', 'AutoHotkey64.exe', 'AutoHotkey32.exe', 'AutoHotkeyUX.exe'))
-    } | Select-Object -First 1) | ForEach-Object {
-        Stop-Process -Id $_.ProcessId -ErrorAction SilentlyContinue
-    }
-}
-"#;
-
-                match powershell_script::run(script) {
-                    Ok(_) => {
-                        println!("{script}");
-                    }
-                    Err(error) => {
-                        println!("Error: {error}");
-                    }
-                }
-            }
-
            send_message(&SocketMessage::Stop)?;
            let mut system = sysinfo::System::new_all();
            system.refresh_processes(ProcessesToUpdate::All);
@@ -2309,9 +2248,6 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
        SubCommand::CycleStack(arg) => {
            send_message(&SocketMessage::CycleStack(arg.cycle_direction))?;
        }
-        SubCommand::CycleStackIndex(arg) => {
-            send_message(&SocketMessage::CycleStackIndex(arg.cycle_direction))?;
-        }
        SubCommand::ChangeLayout(arg) => {
            send_message(&SocketMessage::ChangeLayout(arg.default_layout))?;
        }
@@ -2347,9 +2283,6 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
        SubCommand::FocusNamedWorkspace(arg) => {
            send_message(&SocketMessage::FocusNamedWorkspace(arg.workspace))?;
        }
-        SubCommand::CloseWorkspace => {
-            send_message(&SocketMessage::CloseWorkspace)?;
-        }
        SubCommand::CycleMonitor(arg) => {
            send_message(&SocketMessage::CycleFocusMonitor(arg.cycle_direction))?;
        }
@@ -2680,7 +2613,7 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue

            file.write_all(content.as_bytes())?;

-            println!("Latest version of applications.json from https://github.com/LGUG2Z/komorebi-application-specific-configuration downloaded\n");
+            println!("Latest version of applications.yaml from https://github.com/LGUG2Z/komorebi-application-specific-configuration downloaded\n");
            println!(
               "You can add this to your komorebi.json static configuration file like this: \n\n\"app_specific_configuration_path\": \"{}\"",
               output_file.display().to_string().replace("\\", "/")
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -57,7 +57,6 @@ nav:
      - Troubleshooting: troubleshooting.md
  - Common workflows:
      - common-workflows/komorebi-config-home.md
-      - common-workflows/autostart.md
      - common-workflows/animations.md
      - common-workflows/autohotkey.md
      - common-workflows/borders.md
@@ -65,12 +64,14 @@ nav:
      - common-workflows/remove-gaps.md
      - common-workflows/ignore-windows.md
      - common-workflows/force-manage-windows.md
-      - common-workflows/floating-applications.md
      - common-workflows/tray-and-multi-window-applications.md
+      - common-workflows/focus-follows-mouse.md
      - common-workflows/mouse-follows-focus.md
+      - common-workflows/custom-layouts.md
      - common-workflows/dynamic-layout-switching.md
      - common-workflows/set-display-index.md
-      - common-workflows/multiple-bar-instances.md
+  - Release notes:
+      - release/v0-1-22.md
  - Configuration reference: https://komorebi.lgug2z.com/schema
  - Bar reference: https://komorebi-bar.lgug2z.com/schema
  - CLI reference:
@@ -145,6 +146,7 @@ nav:
      - cli/adjust-workspace-padding.md
      - cli/change-layout.md
      - cli/cycle-layout.md
+      - cli/load-custom-layout.md
      - cli/flip-layout.md
      - cli/promote.md
      - cli/promote-focus.md
@@ -160,17 +162,18 @@ nav:
      - cli/named-workspace-padding.md
      - cli/workspace-layout.md
      - cli/named-workspace-layout.md
+      - cli/workspace-custom-layout.md
+      - cli/named-workspace-custom-layout.md
      - cli/workspace-layout-rule.md
      - cli/named-workspace-layout-rule.md
+      - cli/workspace-custom-layout-rule.md
+      - cli/named-workspace-custom-layout-rule.md
      - cli/clear-workspace-layout-rules.md
      - cli/clear-named-workspace-layout-rules.md
      - cli/workspace-tiling.md
      - cli/named-workspace-tiling.md
      - cli/workspace-name.md
      - cli/toggle-window-container-behaviour.md
-      - cli/toggle-float-override.md
-      - cli/toggle-workspace-window-container-behaviour.md
-      - cli/toggle-workspace-float-override.md
      - cli/toggle-pause.md
      - cli/toggle-tiling.md
      - cli/toggle-float.md
@@ -187,7 +190,7 @@ nav:
      - cli/cross-monitor-move-behaviour.md
      - cli/toggle-cross-monitor-move-behaviour.md
      - cli/unmanaged-window-operation-behaviour.md
-      - cli/ignore-rule.md
+      - cli/float-rule.md
      - cli/manage-rule.md
      - cli/initial-workspace-rule.md
      - cli/initial-named-workspace-rule.md
@@ -214,11 +217,13 @@ nav:
      - cli/animation-duration.md
      - cli/animation-fps.md
      - cli/animation-style.md
+      - cli/focus-follows-mouse.md
+      - cli/toggle-focus-follows-mouse.md
      - cli/mouse-follows-focus.md
      - cli/toggle-mouse-follows-focus.md
      - cli/ahk-app-specific-configuration.md
      - cli/pwsh-app-specific-configuration.md
-      - cli/convert-app-specific-configuration.md
+      - cli/format-app-specific-configuration.md
      - cli/fetch-app-specific-configuration.md
      - cli/application-specific-configuration-schema.md
      - cli/notification-schema.md
--- a/schema.bar.json
+++ b/schema.bar.json
@@ -19,7 +19,7 @@
      "format": "float"
    },
    "frame": {
-      "description": "Frame options (see: https://docs.rs/egui/latest/egui/containers/frame/struct.Frame.html)",
+      "description": "Frame options (see: https://docs.rs/egui/latest/egui/containers/struct.Frame.html)",
      "type": "object",
      "required": [
        "inner_margin"
@@ -1428,7 +1428,6 @@
              ]
            },
            "name": {
-              "description": "Name of the Catppuccin theme (theme previews: https://github.com/catppuccin/catppuccin)",
              "type": "string",
              "enum": [
                "Frappe",
@@ -1475,7 +1474,6 @@
              ]
            },
            "name": {
-              "description": "Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)",
              "type": "string",
              "enum": [
                "3024",
--- a/schema.json
+++ b/schema.json
@@ -66,7 +66,7 @@
      }
    },
    "app_specific_configuration_path": {
-      "description": "Path to applications.json from komorebi-application-specific-configurations (default: None)",
+      "description": "Path to applications.yaml from komorebi-application-specific-configurations (default: None)",
      "type": "string"
    },
    "bar_configurations": {
@@ -579,7 +579,7 @@
      }
    },
    "focus_follows_mouse": {
-      "description": "END OF LIFE FEATURE: Determine focus follows mouse implementation (default: None)",
+      "description": "Determine focus follows mouse implementation (default: None)",
      "oneOf": [
        {
          "description": "A custom FFM implementation (slightly more CPU-intensive)",
@@ -1052,11 +1052,11 @@
                  "format": "int32"
                },
                "custom_layout": {
-                  "description": "END OF LIFE FEATURE: Custom Layout (default: None)",
+                  "description": "Custom Layout (default: None)",
                  "type": "string"
                },
                "custom_layout_rules": {
-                  "description": "END OF LIFE FEATURE: Custom layout rules (default: None)",
+                  "description": "Layout rules (default: None)",
                  "type": "object",
                  "additionalProperties": {
                    "type": "string"
@@ -1751,7 +1751,7 @@
              ]
            },
            "name": {
-              "description": "Name of the Catppuccin theme (theme previews: https://github.com/catppuccin/catppuccin)",
+              "description": "Name of the Catppuccin theme",
              "type": "string",
              "enum": [
                "Frappe",
@@ -2035,7 +2035,7 @@
              ]
            },
            "name": {
-              "description": "Name of the Base16 theme (theme previews: https://tinted-theming.github.io/base16-gallery)",
+              "description": "Name of the Base16 theme",
              "type": "string",
              "enum": [
                "3024",