chore(release): v0.1.4

feat(wm): adapt to scaling and resolution changes
This commit expands the reconcile_monitors fn to also update resolution and work area sizes if they are different from what is stored in the window manager state. Another WindowManagerEvent has been added as a polling mechanism for monitor-related changes (scaling, dpi, resolution etc.), and this will now also trigger the reconcile_monitors fn in the existing event pre-processing block. resolve #36
2026-02-16 02:07:41 +01:00 · 2021-09-17 08:05:59 -07:00 · 2021-09-16 14:53:07 -07:00 · 2021-09-16 09:42:13 -07:00 · 2021-09-15 07:18:10 -07:00 · 2021-09-14 21:26:18 -07:00
34 changed files with 3063 additions and 852 deletions
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -0,0 +1,21 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    assignees:
+      - "LGUG2Z"
+    commit-message:
+      prefix: chore
+      include: scope
+
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    assignees:
+      - "LGUG2Z"
+    commit-message:
+      prefix: chore
+      include: scope
--- a/.github/workflows/windows.yaml
+++ b/.github/workflows/windows.yaml
@@ -20,6 +20,8 @@ jobs:
  build:
    name: Build
    runs-on: windows-latest
+    env:
+      RUSTFLAGS: -Ctarget-feature=+crt-static
    strategy:
      fail-fast: false
      matrix:
@@ -64,7 +66,6 @@ jobs:
          $ProgressPreference = "SilentlyContinue"
          Invoke-WebRequest https://win.rustup.rs/ -OutFile rustup-init.exe
          .\rustup-init.exe -y --default-host=x86_64-pc-windows-msvc --profile=minimal
-          del rustup-init.exe
        shell: powershell
      - name: Ensure stable toolchain is up to date
        run: rustup update stable
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -52,6 +52,9 @@ scoop:
  homepage: https://github.com/LGUG2Z/komorebi
  description: A tiling window manager for Windows
  license: MIT
+  pre_install:
+    - if (Get-Process -Name komorebi -ErrorAction SilentlyContinue) { komorebic stop }
  post_install:
-    - Write-Host "Run 'cp $original_dir\komorebi.sample.ahk $Env:UserProfile\komorebi.ahk' to get started with the sample configuration"
-    - Write-Host "Once you have a configuration file in place, you can run 'komorebic start' to start the window manager"
+    - Write-Host "`nRun 'cp $original_dir\komorebi.sample.ahk $Env:UserProfile\komorebi.ahk' to get started with the sample configuration"
+    - Write-Host "`nRun 'komorebic ahk-library' if you would like to generate an AHK helper library to use in your configuration"
+    - Write-Host "`nOnce you have a configuration file in place, you can run 'komorebic start' to start the window manager"
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -73,9 +73,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

 [[package]]
 name = "cc"
-version = "1.0.69"
+version = "1.0.70"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"
+checksum = "d26a6ce4b6a484fa3edb70f7efa6fc430fd2b87285fe8b84304fd0936faa0dc0"

 [[package]]
 name = "cfg-if"
@@ -160,6 +160,37 @@ dependencies = [
 "tracing-error",
 ]

+[[package]]
+name = "com"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a30a2b2a013da986dc5cc3eda3d19c0d59d53f835be1b2356eb8d00f000c793"
+dependencies = [
+ "com_macros",
+]
+
+[[package]]
+name = "com_macros"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7606b05842fea68ddcc89e8053b8860ebcb2a0ba8d6abfe3a148e5d5a8d3f0c1"
+dependencies = [
+ "com_macros_support",
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "com_macros_support"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97e9a6d20f4ac8830e309a455d7e9416e65c6af5a97c88c55fbb4c2012e107da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "const-sha1"
 version = "0.2.0"
@@ -226,6 +257,15 @@ dependencies = [
 "winapi 0.3.9",
 ]

+[[package]]
+name = "derive-ahk"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "dirs"
 version = "3.0.2"
@@ -274,6 +314,21 @@ dependencies = [
 "winapi 0.3.9",
 ]

+[[package]]
+name = "fixedbitset"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37ab347416e802de484e4d03c7316c48f1ecb56574dfd4a46a80f173ce1de04d"
+
+[[package]]
+name = "fs-tail"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73c8ee8694b2ad6d79aa976ad8572ca376c0450290041e6e3ae75147356b6ad2"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "fsevent"
 version = "0.4.0"
@@ -414,6 +469,15 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "instant"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee0328b1209d157ef001c94dd85b4f8f64139adb0eac2659f4b08382b2f474d"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
 [[package]]
 name = "iovec"
 version = "0.1.4"
@@ -425,9 +489,9 @@ dependencies = [

 [[package]]
 name = "itoa"
-version = "0.4.7"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
+checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4"

 [[package]]
 name = "kernel32-sys"
@@ -441,21 +505,22 @@ dependencies = [

 [[package]]
 name = "komorebi"
-version = "0.1.0"
+version = "0.1.4"
 dependencies = [
 "bindings",
 "bitflags",
+ "clap",
 "color-eyre",
 "crossbeam-channel",
 "crossbeam-utils",
 "ctrlc",
 "dirs",
- "eyre",
 "getset",
 "hotwatch",
 "komorebi-core",
 "lazy_static",
 "nanoid",
+ "parking_lot",
 "paste",
 "serde",
 "serde_json",
@@ -466,11 +531,13 @@ dependencies = [
 "tracing-subscriber",
 "uds_windows",
 "which",
+ "winput",
+ "winvd",
 ]

 [[package]]
 name = "komorebi-core"
-version = "0.1.0"
+version = "0.1.4"
 dependencies = [
 "bindings",
 "clap",
@@ -482,12 +549,15 @@ dependencies = [

 [[package]]
 name = "komorebic"
-version = "0.1.0"
+version = "0.1.4"
 dependencies = [
 "bindings",
 "clap",
 "color-eyre",
+ "derive-ahk",
 "dirs",
+ "fs-tail",
+ "heck",
 "komorebi-core",
 "paste",
 "powershell_script",
@@ -510,9 +580,18 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"

 [[package]]
 name = "libc"
-version = "0.2.99"
+version = "0.2.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7f823d141fe0a24df1e23b4af4e3c7ba9e5966ec514ea068c93024aa7deb765"
+checksum = "a2a5ac8f984bfcf3a823267e5fde638acc3325f6496633a5da6bb6eb2171e103"
+
+[[package]]
+name = "lock_api"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712a4d093c9976e24e7dbca41db895dabcbac38eb5f4045393d17a95bdfb1109"
+dependencies = [
+ "scopeguard",
+]

 [[package]]
 name = "log"
@@ -534,9 +613,9 @@ dependencies = [

 [[package]]
 name = "memchr"
-version = "2.4.0"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"

 [[package]]
 name = "memoffset"
@@ -691,9 +770,9 @@ dependencies = [

 [[package]]
 name = "object"
-version = "0.26.0"
+version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c55827317fb4c08822499848a14237d2874d6f139828893017237e7ab93eb386"
+checksum = "39f37e50073ccad23b6d09bcb5b263f4e76d3bb6038e4a3c08e52162ffa8abc2"
 dependencies = [
 "memchr",
 ]
@@ -716,12 +795,50 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2386b4ebe91c2f7f51082d4cefa145d030e33a1842a96b12e4885cc3c01f7a55"

+[[package]]
+name = "parking_lot"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+dependencies = [
+ "instant",
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216"
+dependencies = [
+ "backtrace",
+ "cfg-if 1.0.0",
+ "instant",
+ "libc",
+ "petgraph",
+ "redox_syscall",
+ "smallvec",
+ "thread-id",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "paste"
 version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "acbf547ad0c65e31259204bd90935776d1c693cec2f4ff7abb7a1bbbd40dfe58"

+[[package]]
+name = "petgraph"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "467d164a6de56270bd7c4d070df81d07beace25012d5103ced4e9ff08d6afdb7"
+dependencies = [
+ "fixedbitset",
+ "indexmap",
+]
+
 [[package]]
 name = "pin-project-lite"
 version = "0.2.7"
@@ -766,9 +883,9 @@ dependencies = [

 [[package]]
 name = "proc-macro2"
-version = "1.0.28"
+version = "1.0.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c7ed8b8c7b886ea3ed7dde405212185f423ab44682667c8c6dd14aa1d9f6612"
+checksum = "b9f5105d4fdaab20335ca9565e106a5d9b82b6219b5ba735731124ac6711d23d"
 dependencies = [
 "unicode-xid",
 ]
@@ -938,9 +1055,9 @@ dependencies = [

 [[package]]
 name = "rustc-demangle"
-version = "0.1.20"
+version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dead70b0b5e03e9c814bcb6b01e03e68f7c57a80aa48c72ec92152ab3e818d49"
+checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"

 [[package]]
 name = "ryu"
@@ -965,18 +1082,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"

 [[package]]
 name = "serde"
-version = "1.0.127"
+version = "1.0.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f03b9878abf6d14e6779d3f24f07b2cfa90352cfec4acc5aab8f1ac7f146fae8"
+checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"
 dependencies = [
 "serde_derive",
 ]

 [[package]]
 name = "serde_derive"
-version = "1.0.127"
+version = "1.0.130"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a024926d3432516606328597e0f224a51355a493b49fdd67e9209187cbe55ecc"
+checksum = "d7bc1a1ab1961464eae040d96713baa5a724a8152c1222492465b54322ec508b"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -985,9 +1102,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.66"
+version = "1.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "336b10da19a12ad094b59d870ebde26a45402e5b470add4b5fd03c5048a32127"
+checksum = "0f690853975602e1bfe1ccbf50504d67174e3bcf340f23b5ea9992e0587a52d8"
 dependencies = [
 "itoa",
 "ryu",
@@ -1044,9 +1161,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "1.0.74"
+version = "1.0.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1873d832550d4588c3dbc20f01361ab00bfe741048f71e3fecf145a7cc18b29c"
+checksum = "c6f107db402c2c2055242dbf4d2af0e69197202e9faacbef9571bbe47f5a1b84"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1055,9 +1172,9 @@ dependencies = [

 [[package]]
 name = "sysinfo"
-version = "0.20.0"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0af066e6272f2175c1783cfc2ebf3e2d8dfe2c182b00677fdeccbf8291af83fb"
+checksum = "92d77883450d697c0010e60db3d940ed130b0ed81d27485edee981621b434e52"
 dependencies = [
 "cfg-if 1.0.0",
 "core-foundation-sys",
@@ -1096,6 +1213,17 @@ dependencies = [
 "unicode-width",
 ]

+[[package]]
+name = "thread-id"
+version = "4.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fdfe0627923f7411a43ec9ec9c39c3a9b4151be313e0922042581fb6c9b717f"
+dependencies = [
+ "libc",
+ "redox_syscall",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "thread_local"
 version = "1.1.3"
@@ -1117,9 +1245,9 @@ dependencies = [

 [[package]]
 name = "tracing"
-version = "0.1.26"
+version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09adeb8c97449311ccd28a427f96fb563e7fd31aabf994189879d9da2394b89d"
+checksum = "c2ba9ab62b7d6497a8638dfda5e5c4fb3b2d5a7fca4118f2b96151c8ef1a437e"
 dependencies = [
 "cfg-if 1.0.0",
 "pin-project-lite",
@@ -1140,9 +1268,9 @@ dependencies = [

 [[package]]
 name = "tracing-attributes"
-version = "0.1.15"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c42e6fa53307c8a17e4ccd4dc81cf5ec38db9209f59b222210375b54ee40d1e2"
+checksum = "98863d0dd09fa59a1b79c6750ad80dbda6b75f4e71c437a6a1a8cb91a8bcbd77"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1151,9 +1279,9 @@ dependencies = [

 [[package]]
 name = "tracing-core"
-version = "0.1.18"
+version = "0.1.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9ff14f98b1a4b289c6248a023c1c2fa1491062964e9fed67ab29c4e4da4a052"
+checksum = "46125608c26121c81b0c6d693eab5a420e416da7e43c426d2e8f7df8da8a3acf"
 dependencies = [
 "lazy_static",
 ]
@@ -1191,9 +1319,9 @@ dependencies = [

 [[package]]
 name = "tracing-subscriber"
-version = "0.2.19"
+version = "0.2.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab69019741fca4d98be3c62d2b75254528b5432233fd8a4d2739fec20278de48"
+checksum = "56c42e73a9d277d4d2b6a88389a137ccf3c58599660b17e8f5fc39305e490669"
 dependencies = [
 "ansi_term",
 "chrono",
@@ -1229,9 +1357,9 @@ checksum = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b"

 [[package]]
 name = "unicode-width"
-version = "0.1.8"
+version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
+checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"

 [[package]]
 name = "unicode-xid"
@@ -1324,9 +1452,9 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

 [[package]]
 name = "windows"
-version = "0.18.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68088239696c06152844eadc03d262f088932cce50c67e4ace86e19d95e976fe"
+checksum = "ef84dd25f4c69a271b1bba394532bf400523b43169de21dfc715e8f8e491053d"
 dependencies = [
 "const-sha1",
 "windows_gen",
@@ -1335,18 +1463,56 @@ dependencies = [

 [[package]]
 name = "windows_gen"
-version = "0.18.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf583322dc423ee021035b358e535015f7fd163058a31e2d37b99a939141121d"
+checksum = "ac7bb21b8ff5e801232b72a6ff554b4cc0cef9ed9238188c3ca78fe3968a7e5d"
+dependencies = [
+ "windows_quote",
+ "windows_reader",
+]

 [[package]]
 name = "windows_macros"
-version = "0.18.0"
+version = "0.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58acfb8832e9f707f8997bd161e537a1c1f603e60a5bd9c3cf53484fdcc998f3"
+checksum = "5566b8c51118769e4a9094a688bf1233a3f36aacbfc78f3b15817fe0b6e0442f"
 dependencies = [
 "syn",
 "windows_gen",
+ "windows_quote",
+ "windows_reader",
+]
+
+[[package]]
+name = "windows_quote"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4af8236a9493c38855f95cdd11b38b342512a5df4ee7473cffa828b5ebb0e39c"
+
+[[package]]
+name = "windows_reader"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c8d5cf83fb08083438c5c46723e6206b2970da57ce314f80b57724439aaacab"
+
+[[package]]
+name = "winput"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd4bec39938e0ae68b300e2a4197b6437f13d53d1c146c6e297e346a71d5dde9"
+dependencies = [
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "winvd"
+version = "0.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bab2d5c745381b9c72797230150ec62244e693064fa0d654b5c4e6c75132a56"
+dependencies = [
+ "com",
+ "crossbeam-channel",
+ "once_cell",
 ]

 [[package]]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,6 +2,7 @@

 members = [
    "bindings",
+    "derive-ahk",
    "komorebi",
    "komorebi-core",
    "komorebic"
--- a/README.md
+++ b/README.md
@@ -14,6 +14,10 @@ _komorebi_ allows you to control application windows, virtual workspaces and dis
 used with third-party software such as [AutoHotKey](https://github.com/Lexikos/AutoHotkey_L) to set user-defined
 keyboard shortcuts.

+Translations of this document can be found in the project wiki:
+
+- [komorebi 中文用户指南](https://github.com/LGUG2Z/komorebi/wiki/README-zh) (by [@crosstyan](https://github.com/crosstyan))
+
 ## Description

 _komorebi_ only responds to [WinEvents](https://docs.microsoft.com/en-us/windows/win32/winauto/event-constants) and the
@@ -59,6 +63,8 @@ This means that:

 ## Getting Started

+### GitHub Releases
+
 Prebuilt binaries are available on the [releases page](https://github.com/LGUG2Z/komorebi/releases) in a `zip` archive.
 Once downloaded, you will need to move the `komorebi.exe` and `komorebic.exe` binaries to a directory in your `Path` (
 you can see these directories by running `$Env:Path.split(";")` at a PowerShell prompt).
@@ -68,6 +74,8 @@ using [`setx`](https://docs.microsoft.com/en-us/windows-server/administration/wi
 Variables pop up in System Properties Advanced (which can be launched with `SystemPropertiesAdvanced.exe` at a
 PowerShell prompt), and then move the binaries to that directory.

+### Scoop
+
 If you use the [Scoop](https://scoop.sh/) command line installer, you can run the following commands to install the
 binaries from the latest GitHub Release:

@@ -79,6 +87,8 @@ scoop install komorebi
 If you install _komorebi_ using Scoop, the binaries will automatically be added to your `Path` and a command will be
 shown for you to run in order to get started using the sample configuration file.

+### Building from Source
+
 If you prefer to compile _komorebi_ from source, you will need
 a [working Rust development environment on Windows 10](https://rustup.rs/). The `x86_64-pc-windows-msvc` toolchain is
 required, so make sure you have also installed
@@ -91,6 +101,8 @@ cargo install --path komorebi --locked
 cargo install --path komorebic --locked
 ```

+### Running
+
 Once you have either the prebuilt binaries in your `Path`, or have compiled the binaries from source (these will already
 be in your `Path` if you installed Rust with [rustup](https://rustup.rs), which you absolutely should), you can
 run `komorebic start` at a Powershell prompt, and you will see the following output:
@@ -102,17 +114,45 @@ Start-Process komorebi -WindowStyle hidden
 This means that `komorebi` is now running in the background, tiling all your windows, and listening for commands sent to
 it by `komorebic`. You can similarly stop the process by running `komorebic stop`.

+### Configuring
+
 Once `komorebi` is running, you can execute the `komorebi.sample.ahk` script to set up the default keybindings via AHK
 (the file includes comments to help you start building your own configuration).

 If you have AutoHotKey installed and a `komorebi.ahk` file in your home directory (run `$Env:UserProfile` at a
 PowerShell prompt to find your home directory), `komorebi` will automatically try to load it when starting.

-There is also tentative support for loading a AutoHotKey v2, if the file is named `komorebi.ahk2` and
+There is also tentative support for loading a AutoHotKey v2 files, if the file is named `komorebi.ahk2` and
 the `AutoHotKey64.exe` executable for AutoHotKey v2 is in your `Path`. If both `komorebi.ahk` and `komorebi.ahk2` files
 exist in your home directory, only `komorebi.ahk` will be loaded. An example of an AutoHotKey v2 configuration file
 for _komorebi_ can be found [here](https://gist.github.com/crosstyan/dafacc0778dabf693ce9236c57b201cd).

+### Common First-Time Tips
+
+#### Floating Windows
+
+Sometimes you will want a specific application to never be tiled, and instead float all the time. You add add rules to
+enforce this behaviour:
+
+```powershell
+komorebic.exe float-rule title "Control Panel"
+# komorebic.exe float-rule exe [EXE NAME]
+# komorebic.exe float-rule class [CLASS NAME]
+```
+
+#### Windows Not Getting Managed
+
+In some rare cases, a window may not automatically be registered to be managed by `komorebi`. When this happens, you can
+manually add a rule to force `komorebi` to manage it:
+
+```powershell
+komorebic.exe manage-rule exe TIM.exe
+# komorebic.exe manage-rule class [CLASS NAME]
+# komorebic.exe manage-rule title [TITLE]
+```
+
+#### Tray Applications
+
 If you are experiencing behaviour where
 [closing a window leaves a blank tile, but minimizing the same window does not](https://github.com/LGUG2Z/komorebi/issues/6)
 , you have probably enabled a 'close/minimize to tray' option for that application. You can tell _komorebi_ to handle
@@ -120,10 +160,31 @@ this application appropriately by identifying it via the executable name or the

 ```powershell
 komorebic.exe identify-tray-application exe Discord.exe
-komorebic.exe identify-tray-application exe Telegram.exe
+# komorebic.exe identify-tray-application class [CLASS NAME]
+# komorebic.exe identify-tray-application title [TITLE]
 ```

-## Configuration
+#### 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.
+
+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
+```
+
+## Configuration with `komorebic`

 As previously mentioned, this project does not handle anything related to keybindings and shortcuts directly. I
 personally use AutoHotKey to manage my window management shortcuts, and have provided a
@@ -133,6 +194,69 @@ You can run `komorebic.exe` to get a full list of the commands that you can use
 keybindings with. You can run `komorebic.exe <COMMAND> --help` to get a full explanation of the arguments required for
 each command.

+```
+start                         Start komorebi.exe as a background process
+stop                          Stop the komorebi.exe process and restore all hidden windows
+state                         Show a JSON representation of the current window manager state
+query                         Query the current window manager state
+log                           Tail komorebi.exe's process logs (cancel with Ctrl-C)
+focus                         Change focus to the window in the specified direction
+move                          Move the focused window in the specified direction
+stack                         Stack the focused window in the specified direction
+resize                        Resize the focused window in the specified direction
+unstack                       Unstack the focused window
+cycle-stack                   Cycle the focused stack in the specified cycle direction
+move-to-monitor               Move the focused window to the specified monitor
+move-to-workspace             Move the focused window to the specified workspace
+send-to-monitor               Send the focused window to the specified monitor
+send-to-workspace             Send the focused window to the specified workspace
+focus-monitor                 Focus the specified monitor
+focus-workspace               Focus the specified workspace on the focused monitor
+new-workspace                 Create and append a new workspace on the focused monitor
+invisible-borders             Set the invisible border dimensions around each window
+adjust-container-padding      Adjust container padding on the focused workspace
+adjust-workspace-padding      Adjust workspace padding on the focused workspace
+change-layout                 Set the layout on the focused workspace
+flip-layout                   Flip the layout on the focused workspace (BSP only)
+promote                       Promote the focused window to the top of the tree
+retile                        Force the retiling of all managed windows
+ensure-workspaces             Create at least this many workspaces for the specified monitor
+container-padding             Set the container padding for the specified workspace
+workspace-padding             Set the workspace padding for the specified workspace
+workspace-layout              Set the layout for the specified workspace
+workspace-tiling              Enable or disable window tiling for the specified workspace
+workspace-name                Set the workspace name for the specified workspace
+toggle-pause                  Toggle the window manager on and off across all monitors
+toggle-tiling                 Toggle window tiling on the focused workspace
+toggle-float                  Toggle floating mode for the focused window
+toggle-monocle                Toggle monocle mode for the focused container
+toggle-maximize               Toggle native maximization for the focused window
+restore-windows               Restore all hidden windows (debugging command)
+manage                        Force komorebi to manage the focused window
+unmanage                      Unmanage a window that was forcibly managed
+reload-configuration          Reload ~/komorebi.ahk (if it exists)
+watch-configuration           Enable or disable watching of ~/komorebi.ahk (if it exists)
+float-rule                    Add a rule to always float the specified application
+manage-rule                   Add a rule to always manage the specified application
+workspace-rule                Add a rule to associate an application with a workspace
+identify-tray-application     Identify an application that closes to the system tray
+identify-border-overflow      Identify an application that has overflowing borders
+focus-follows-mouse           Enable or disable focus follows mouse for the operating system
+toggle-focus-follows-mouse    Toggle focus follows mouse for the operating system
+ahk-library                   Generate a library of AutoHotKey helper functions
+help                          Print this message or the help of the given subcommand(s)
+```
+
+### AutoHotKey Helper Library for `komorebic`
+
+Additionally, you may run `komorebic.exe ahk-library` to
+generate [a helper library for AutoHotKey](komorebic.lib.sample.ahk) which wraps every `komorebic` command in a native
+AHK function.
+
+If you include the generated library at the top of your `~/komorebi.ahk` configuration file, you will be able to call
+any of the functions that it contains. A sample AHK script that shows how this library can be
+used [is available here](komorebi.sample.with.lib.ahk).
+
 ## Features

 - [x] Multi-monitor
@@ -141,8 +265,10 @@ each command.
 - [x] Cycle through stacked windows
 - [x] Change focused window by direction
 - [x] Move focused window container in direction
- [x] Move focused window container to monitor
- [x] Move focused window container to workspace
+- [x] Move focused window container to monitor and follow
+- [x] Move focused window container to workspace follow
+- [x] Send focused window container to monitor
+- [x] Send focused window container to workspace
 - [x] Mouse follows focused container
 - [x] Resize window container in direction
 - [ ] Resize child window containers by split ratio
@@ -152,19 +278,25 @@ each command.
 - [x] BSP tree layout
 - [x] Flip BSP tree layout horizontally or vertically
 - [x] Equal-width, max-height column layout
- [x] Floating rules based on exe name
- [x] Floating rules based on window title
- [x] Floating rules based on window class
- [x] Identify 'close/minimize to tray' applications
+- [x] Floating rules based on exe name, window title and class
+- [x] Workspace rules based on exe name and window class
+- [x] Additional manage rules based on exe name and window class
+- [x] Identify applications which overflow their borders by exe name and class
+- [x] Identify 'close/minimize to tray' applications by exe name and class
+- [x] Configure and compensate for the size of Windows 10's invisible borders
 - [x] Toggle floating windows
 - [x] Toggle monocle window
- [x] Toggle focus follows mouse
+- [x] Toggle native maximization
+- [x] Toggle Xmouse/Windows focus follows mouse implementation
+- [x] Toggle Komorebi focus follows mouse implementation (desktop and system tray-aware)
 - [x] Toggle automatic tiling
 - [x] Pause all window management
 - [x] Load configuration on startup
 - [x] Manually reload configuration
 - [x] Watch configuration for changes
+- [x] Helper library for AutoHotKey
 - [x] View window manager state
+- [x] Query window manager state

 ## Development

@@ -184,7 +316,7 @@ If you use IntelliJ, you should enable the following settings to ensure that cod
 the IDE for completions and navigation:

 - Set `Expand declarative macros`
-  to `Use new engine` [here](jetbrains://idea/settings?name=Languages+%26+Frameworks--Rust)
+  to `Use new engine` under "Settings > Langauges & Frameworks > Rust"
 - Enable the following experimental features:
  - `org.rust.cargo.evaluate.build.scripts`
  - `org.rust.macros.proc`
@@ -200,134 +332,25 @@ ensures that all hidden windows are restored before termination.
 If however, you ever end up with windows that are hidden and cannot be restored, a list of window handles known
 to `komorebi` are stored and continuously updated in `~/komorebi.hwnd.json`.

+### Restoring Windows
+
 Running `komorebic restore-windows` will read the list of window handles and forcibly restore them, regardless of
 whether the main `komorebi` process is running.

+### Panics and Deadlocks
+
+If `komorebi` ever stops responding, it is most likely either due to either a panic or a deadlock. In the case of a
+panic, this will be reported in the log. In the case of a deadlock, there will not be any errors in the log, but the
+process and the log will appear frozen.
+
+If you believe you have encountered a deadlock, you can compile `komorebi` with `--features deadlock_detection` and try
+reproducing the deadlock again. This will check for deadlocks every 5 seconds in the background, and if a deadlock is
+found, information about it will appear in the log which can be shared when opening an issue.
+
 ## Window Manager State and Integrations

 The current state of the window manager can be queried using the `komorebic state` command, which returns a JSON
-representation of the `WindowManager` struct.
+representation of the `State` struct, which includes the current state of `WindowManager`.

 This may also be polled to build further integrations and widgets on top of (if you ever wanted to build something
 like [Stackline](https://github.com/AdamWagner/stackline) for Windows, you could do it by polling this command).
-
-```json
-{
-  "monitors": {
-    "elements": [
-      {
-        "id": 65537,
-        "monitor_size": {
-          "left": 0,
-          "top": 0,
-          "right": 3840,
-          "bottom": 2160
-        },
-        "work_area_size": {
-          "left": 0,
-          "top": 40,
-          "right": 3840,
-          "bottom": 2120
-        },
-        "workspaces": {
-          "elements": [
-            {
-              "name": "bsp",
-              "containers": {
-                "elements": [
-                  {
-                    "windows": {
-                      "elements": [
-                        {
-                          "hwnd": 2623596,
-                          "title": "komorebi – README.md",
-                          "exe": "idea64.exe",
-                          "class": "SunAwtFrame",
-                          "rect": {
-                            "left": 8,
-                            "top": 60,
-                            "right": 1914,
-                            "bottom": 2092
-                          }
-                        }
-                      ],
-                      "focused": 0
-                    }
-                  },
-                  {
-                    "windows": {
-                      "elements": [
-                        {
-                          "hwnd": 198266,
-                          "title": "LGUG2Z/komorebi: A(nother) tiling window manager for Windows 10 based on binary space partitioning - Mozilla Firefox",
-                          "exe": "firefox.exe",
-                          "class": "MozillaWindowClass",
-                          "rect": {
-                            "left": 1918,
-                            "top": 60,
-                            "right": 1914,
-                            "bottom": 1042
-                          }
-                        }
-                      ],
-                      "focused": 0
-                    }
-                  },
-                  {
-                    "windows": {
-                      "elements": [
-                        {
-                          "hwnd": 1247352,
-                          "title": "Windows PowerShell",
-                          "exe": "WindowsTerminal.exe",
-                          "class": "CASCADIA_HOSTING_WINDOW_CLASS",
-                          "rect": {
-                            "left": 1918,
-                            "top": 1110,
-                            "right": 959,
-                            "bottom": 1042
-                          }
-                        }
-                      ],
-                      "focused": 0
-                    }
-                  },
-                  {
-                    "windows": {
-                      "elements": [
-                        {
-                          "hwnd": 395464,
-                          "title": "Signal",
-                          "exe": "Signal.exe",
-                          "class": "Chrome_WidgetWin_1",
-                          "rect": {
-                            "left": 2873,
-                            "top": 1110,
-                            "right": 959,
-                            "bottom": 1042
-                          }
-                        }
-                      ],
-                      "focused": 0
-                    }
-                  }
-                ],
-                "focused": 2
-              },
-              "monocle_container": null,
-              "floating_windows": [],
-              "layout": "BSP",
-              "layout_flip": null,
-              "workspace_padding": 10,
-              "container_padding": 10
-            }
-          ],
-          "focused": 0
-        }
-      }
-    ],
-    "focused": 0
-  },
-  "is_paused": false
-}
-```
--- a/bindings/Cargo.toml
+++ b/bindings/Cargo.toml
@@ -7,7 +7,7 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
-windows = "0.18"
+windows = "0.19"

 [build-dependencies]
-windows = "0.18"
+windows = "0.19"
--- a/derive-ahk/Cargo.toml
+++ b/derive-ahk/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "derive-ahk"
+version = "0.1.0"
+edition = "2018"
+
+[lib]
+proc-macro = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+proc-macro2 = "1.0"
+syn = "1.0"
+quote = "1.0"
--- a/derive-ahk/src/lib.rs
+++ b/derive-ahk/src/lib.rs
@@ -0,0 +1,212 @@
+#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
+#![allow(clippy::missing_errors_doc)]
+#![no_implicit_prelude]
+
+use ::std::clone::Clone;
+use ::std::convert::From;
+use ::std::convert::Into;
+use ::std::iter::Extend;
+use ::std::iter::Iterator;
+use ::std::matches;
+use ::std::option::Option::Some;
+use ::std::string::ToString;
+use ::std::unreachable;
+
+use ::quote::quote;
+use ::syn::parse_macro_input;
+use ::syn::Data;
+use ::syn::DataEnum;
+use ::syn::DeriveInput;
+use ::syn::Fields;
+use ::syn::FieldsNamed;
+use ::syn::FieldsUnnamed;
+use ::syn::Meta;
+use ::syn::NestedMeta;
+
+#[allow(clippy::too_many_lines)]
+#[proc_macro_derive(AhkFunction)]
+pub fn ahk_function(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = input.ident;
+
+    match input.data {
+        Data::Struct(s) => match s.fields {
+            Fields::Named(FieldsNamed { named, .. }) => {
+                let argument_idents = named
+                    .iter()
+                    // Filter out the flags
+                    .filter(|&f| {
+                        let mut include = true;
+                        for attribute in &f.attrs {
+                            if let ::std::result::Result::Ok(Meta::List(list)) =
+                                attribute.parse_meta()
+                            {
+                                for nested in list.nested {
+                                    if let NestedMeta::Meta(Meta::Path(path)) = nested {
+                                        if path.is_ident("long") {
+                                            include = false;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        include
+                    })
+                    .map(|f| &f.ident);
+
+                let argument_idents_clone = argument_idents.clone();
+
+                let called_arguments = quote! {#(%#argument_idents_clone%) *}
+                    .to_string()
+                    .replace(" %", "%")
+                    .replace("% ", "%")
+                    .replace("%%", "% %");
+
+                let flag_idents = named
+                    .iter()
+                    // Filter only the flags
+                    .filter(|f| {
+                        let mut include = false;
+
+                        for attribute in &f.attrs {
+                            if let ::std::result::Result::Ok(Meta::List(list)) =
+                                attribute.parse_meta()
+                            {
+                                for nested in list.nested {
+                                    if let NestedMeta::Meta(Meta::Path(path)) = nested {
+                                        // Identify them using the --long flag name
+                                        if path.is_ident("long") {
+                                            include = true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                        include
+                    })
+                    .map(|f| &f.ident);
+
+                let has_flags = flag_idents.clone().count() != 0;
+
+                if has_flags {
+                    let flag_idents_concat = flag_idents.clone();
+                    let argument_idents_concat = argument_idents.clone();
+
+                    // Concat the args and flag args if there are flags
+                    let all_arguments =
+                        quote! {#(#argument_idents_concat,) * #(#flag_idents_concat), *}
+                            .to_string();
+
+                    let flag_idents_clone = flag_idents.clone();
+                    let flags = quote! {#(--#flag_idents_clone) *}
+                        .to_string()
+                        .replace("- - ", "--");
+
+                    let called_flag_arguments = quote! {#(%#flag_idents%) *}
+                        .to_string()
+                        .replace(" %", "%")
+                        .replace("% ", "%")
+                        .replace("%%", "% %");
+
+                    quote! {
+                        impl AhkFunction for #name {
+                            fn generate_ahk_function() -> String {
+                                ::std::format!(r#"
+{}({}) {{
+    Run, komorebic.exe {} {} {} {}, , Hide
+}}"#,
+                                    ::std::stringify!(#name),
+                                    #all_arguments,
+                                    ::std::stringify!(#name).to_kebab_case(),
+                                    #called_arguments,
+                                    #flags,
+                                    #called_flag_arguments
+                                )
+                           }
+                        }
+                    }
+                } else {
+                    let arguments = quote! {#(#argument_idents), *}.to_string();
+
+                    quote! {
+                        impl AhkFunction for #name {
+                            fn generate_ahk_function() -> String {
+                                ::std::format!(r#"
+{}({}) {{
+    Run, komorebic.exe {} {}, , Hide
+}}"#, 
+                                    ::std::stringify!(#name),
+                                    #arguments,
+                                    ::std::stringify!(#name).to_kebab_case(),
+                                    #called_arguments
+                                )
+                           }
+                        }
+                    }
+                }
+            }
+            _ => unreachable!("only to be used on structs with named fields"),
+        },
+        _ => unreachable!("only to be used on structs"),
+    }
+    .into()
+}
+
+#[proc_macro_derive(AhkLibrary)]
+pub fn ahk_library(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = input.ident;
+
+    match input.data {
+        Data::Enum(DataEnum { variants, .. }) => {
+            let enums = variants.iter().filter(|&v| {
+                matches!(v.fields, Fields::Unit) || matches!(v.fields, Fields::Unnamed(..))
+            });
+
+            let mut stream = ::proc_macro2::TokenStream::new();
+
+            for variant in enums.clone() {
+                match &variant.fields {
+                    Fields::Unnamed(FieldsUnnamed { unnamed, .. }) => {
+                        for field in unnamed {
+                            stream.extend(quote! {
+                                v.push(#field::generate_ahk_function());
+                            });
+                        }
+                    }
+                    Fields::Unit => {
+                        let name = &variant.ident;
+                        stream.extend(quote! {
+                            v.push(::std::format!(r#"
+{}() {{
+    Run, komorebic.exe {}, , Hide
+}}"#, 
+                                ::std::stringify!(#name),
+                                ::std::stringify!(#name).to_kebab_case()
+                            ));
+                        });
+                    }
+                    Fields::Named(_) => {
+                        unreachable!("only to be used with unnamed and unit fields");
+                    }
+                }
+            }
+
+            quote! {
+                impl #name {
+                    fn generate_ahk_library() -> String {
+                        let mut v: Vec<String> = vec![String::from("; Generated by komorebic.exe")];
+
+                        #stream
+
+                        v.join("\n")
+                    }
+               }
+            }
+        }
+        _ => unreachable!("only to be used on enums"),
+    }
+    .into()
+}
--- a/komorebi-core/Cargo.toml
+++ b/komorebi-core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-core"
-version = "0.1.0"
+version = "0.1.4"
 edition = "2018"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
--- a/komorebi-core/src/cycle_direction.rs
+++ b/komorebi-core/src/cycle_direction.rs
@@ -12,7 +12,8 @@ pub enum CycleDirection {
 }

 impl CycleDirection {
-    pub fn next_idx(&self, idx: usize, len: usize) -> usize {
+    #[must_use]
+    pub const fn next_idx(&self, idx: usize, len: usize) -> usize {
        match self {
            CycleDirection::Previous => {
                if idx == 0 {
--- a/komorebi-core/src/layout.rs
+++ b/komorebi-core/src/layout.rs
@@ -20,13 +20,15 @@ pub enum Layout {

 #[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
 #[strum(serialize_all = "snake_case")]
-pub enum LayoutFlip {
+pub enum Flip {
    Horizontal,
    Vertical,
    HorizontalAndVertical,
 }

 impl Layout {
+    #[must_use]
+    #[allow(clippy::cast_precision_loss)]
    pub fn resize(
        &self,
        unaltered: &Rect,
@@ -35,10 +37,14 @@ impl Layout {
        sizing: Sizing,
        step: Option<i32>,
    ) -> Option<Rect> {
+        if !matches!(self, Self::BSP) {
+            return None;
+        };
+
        let max_divisor = 1.005;
        let mut r = resize.unwrap_or_default();

-        let resize_step = if let Some(step) = step { step } else { 50 };
+        let resize_step = step.unwrap_or(50);

        match edge {
            OperationDirection::Left => match sizing {
@@ -117,19 +123,21 @@ impl Layout {
            },
        };

-        if !r.eq(&Rect::default()) {
-            Option::from(r)
-        } else {
+        if r.eq(&Rect::default()) {
            None
+        } else {
+            Option::from(r)
        }
    }

+    #[must_use]
+    #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
    pub fn calculate(
        &self,
        area: &Rect,
        len: NonZeroUsize,
        container_padding: Option<i32>,
-        layout_flip: Option<LayoutFlip>,
+        layout_flip: Option<Flip>,
        resize_dimensions: &[Option<Rect>],
    ) -> Vec<Rect> {
        let len = usize::from(len);
@@ -187,24 +195,6 @@ impl Layout {
    }
 }

-impl Layout {
-    pub fn next(&mut self) {
-        match self {
-            Layout::BSP => *self = Layout::Columns,
-            Layout::Columns => *self = Layout::Rows,
-            Layout::Rows => *self = Layout::BSP,
-        }
-    }
-
-    pub fn previous(&mut self) {
-        match self {
-            Layout::BSP => *self = Layout::Rows,
-            Layout::Columns => *self = Layout::BSP,
-            Layout::Rows => *self = Layout::Columns,
-        }
-    }
-}
-
 fn calculate_resize_adjustments(resize_dimensions: &[Option<Rect>]) -> Vec<Option<Rect>> {
    let mut resize_adjustments = resize_dimensions.to_vec();

@@ -213,6 +203,7 @@ fn calculate_resize_adjustments(resize_dimensions: &[Option<Rect>]) -> Vec<Optio
        if let Some(resize_ref) = opt {
            if i > 0 {
                if resize_ref.left != 0 {
+                    #[allow(clippy::if_not_else)]
                    let range = if i == 1 {
                        0..1
                    } else if i & 1 != 0 {
@@ -291,7 +282,7 @@ fn recursive_fibonacci(
    idx: usize,
    count: usize,
    area: &Rect,
-    layout_flip: Option<LayoutFlip>,
+    layout_flip: Option<Flip>,
    resize_adjustments: Vec<Option<Rect>>,
 ) -> Vec<Rect> {
    let mut a = *area;
@@ -313,37 +304,37 @@ fn recursive_fibonacci(

    let (main_x, alt_x, alt_y, main_y);

-    match layout_flip {
-        Some(flip) => match flip {
-            LayoutFlip::Horizontal => {
+    if let Some(flip) = layout_flip {
+        match flip {
+            Flip::Horizontal => {
                main_x = resized.left + half_width + (half_width - half_resized_width);
                alt_x = resized.left;

                alt_y = resized.top + half_resized_height;
                main_y = resized.top;
            }
-            LayoutFlip::Vertical => {
+            Flip::Vertical => {
                main_y = resized.top + half_height + (half_height - half_resized_height);
                alt_y = resized.top;

                main_x = resized.left;
                alt_x = resized.left + half_resized_width;
            }
-            LayoutFlip::HorizontalAndVertical => {
+            Flip::HorizontalAndVertical => {
                main_x = resized.left + half_width + (half_width - half_resized_width);
                alt_x = resized.left;
                main_y = resized.top + half_height + (half_height - half_resized_height);
                alt_y = resized.top;
            }
-        },
-        None => {
-            main_x = resized.left;
-            alt_x = resized.left + half_resized_width;
-            main_y = resized.top;
-            alt_y = resized.top + half_resized_height;
        }
+    } else {
+        main_x = resized.left;
+        alt_x = resized.left + half_resized_width;
+        main_y = resized.top;
+        alt_y = resized.top + half_resized_height;
    }

+    #[allow(clippy::if_not_else)]
    if count == 0 {
        vec![]
    } else if count == 1 {
--- a/komorebi-core/src/lib.rs
+++ b/komorebi-core/src/lib.rs
@@ -1,3 +1,6 @@
+#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
+#![allow(clippy::missing_errors_doc)]
+
 use std::str::FromStr;

 use clap::ArgEnum;
@@ -8,8 +11,8 @@ use strum::Display;
 use strum::EnumString;

 pub use cycle_direction::CycleDirection;
+pub use layout::Flip;
 pub use layout::Layout;
-pub use layout::LayoutFlip;
 pub use operation_direction::OperationDirection;
 pub use rect::Rect;

@@ -29,14 +32,19 @@ pub enum SocketMessage {
    CycleStack(CycleDirection),
    MoveContainerToMonitorNumber(usize),
    MoveContainerToWorkspaceNumber(usize),
+    SendContainerToMonitorNumber(usize),
+    SendContainerToWorkspaceNumber(usize),
    Promote,
    ToggleFloat,
    ToggleMonocle,
+    ToggleMaximize,
    // Current Workspace Commands
+    ManageFocusedWindow,
+    UnmanageFocusedWindow,
    AdjustContainerPadding(Sizing, i32),
    AdjustWorkspacePadding(Sizing, i32),
    ChangeLayout(Layout),
-    FlipLayout(LayoutFlip),
+    FlipLayout(Flip),
    // Monitor and Workspace Commands
    EnsureWorkspaces(usize, usize),
    NewWorkspace,
@@ -54,12 +62,16 @@ pub enum SocketMessage {
    // Configuration
    ReloadConfiguration,
    WatchConfiguration(bool),
-    FloatClass(String),
-    FloatExe(String),
-    FloatTitle(String),
+    InvisibleBorders(Rect),
+    WorkspaceRule(ApplicationIdentifier, String, usize, usize),
+    FloatRule(ApplicationIdentifier, String),
+    ManageRule(ApplicationIdentifier, String),
    IdentifyTrayApplication(ApplicationIdentifier, String),
+    IdentifyBorderOverflow(ApplicationIdentifier, String),
    State,
-    FocusFollowsMouse(bool),
+    Query(StateQuery),
+    FocusFollowsMouse(FocusFollowsMouseImplementation, bool),
+    ToggleFocusFollowsMouse(FocusFollowsMouseImplementation),
 }

 impl SocketMessage {
@@ -80,6 +92,15 @@ impl FromStr for SocketMessage {
    }
 }

+#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
+#[strum(serialize_all = "snake_case")]
+pub enum StateQuery {
+    FocusedMonitorIndex,
+    FocusedWorkspaceIndex,
+    FocusedContainerIndex,
+    FocusedWindowIndex,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
 #[strum(serialize_all = "snake_case")]
 pub enum ApplicationIdentifier {
@@ -88,6 +109,13 @@ pub enum ApplicationIdentifier {
    Title,
 }

+#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
+#[strum(serialize_all = "snake_case")]
+pub enum FocusFollowsMouseImplementation {
+    Komorebi,
+    Windows,
+}
+
 #[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
 #[strum(serialize_all = "snake_case")]
 pub enum Sizing {
@@ -96,7 +124,8 @@ pub enum Sizing {
 }

 impl Sizing {
-    pub fn adjust_by(&self, value: i32, adjustment: i32) -> i32 {
+    #[must_use]
+    pub const fn adjust_by(&self, value: i32, adjustment: i32) -> i32 {
        match self {
            Sizing::Increase => value + adjustment,
            Sizing::Decrease => {
--- a/komorebi-core/src/operation_direction.rs
+++ b/komorebi-core/src/operation_direction.rs
@@ -4,8 +4,8 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;

+use crate::Flip;
 use crate::Layout;
-use crate::LayoutFlip;

 #[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
 #[strum(serialize_all = "snake_case")]
@@ -17,59 +17,46 @@ pub enum OperationDirection {
 }

 impl OperationDirection {
-    pub fn opposite(self) -> Self {
+    #[must_use]
+    pub const fn opposite(self) -> Self {
        match self {
-            OperationDirection::Left => OperationDirection::Right,
-            OperationDirection::Right => OperationDirection::Left,
-            OperationDirection::Up => OperationDirection::Down,
-            OperationDirection::Down => OperationDirection::Up,
+            Self::Left => Self::Right,
+            Self::Right => Self::Left,
+            Self::Up => Self::Down,
+            Self::Down => Self::Up,
        }
    }

-    fn flip_direction(
-        direction: &OperationDirection,
-        layout_flip: Option<LayoutFlip>,
-    ) -> OperationDirection {
-        if let Some(flip) = layout_flip {
-            match direction {
-                OperationDirection::Left => match flip {
-                    LayoutFlip::Horizontal | LayoutFlip::HorizontalAndVertical => {
-                        OperationDirection::Right
-                    }
-                    _ => *direction,
-                },
-                OperationDirection::Right => match flip {
-                    LayoutFlip::Horizontal | LayoutFlip::HorizontalAndVertical => {
-                        OperationDirection::Left
-                    }
-                    _ => *direction,
-                },
-                OperationDirection::Up => match flip {
-                    LayoutFlip::Vertical | LayoutFlip::HorizontalAndVertical => {
-                        OperationDirection::Down
-                    }
-                    _ => *direction,
-                },
-                OperationDirection::Down => match flip {
-                    LayoutFlip::Vertical | LayoutFlip::HorizontalAndVertical => {
-                        OperationDirection::Up
-                    }
-                    _ => *direction,
-                },
-            }
-        } else {
-            *direction
-        }
+    fn flip_direction(direction: Self, layout_flip: Option<Flip>) -> Self {
+        layout_flip.map_or(direction, |flip| match direction {
+            Self::Left => match flip {
+                Flip::Horizontal | Flip::HorizontalAndVertical => Self::Right,
+                Flip::Vertical => direction,
+            },
+            Self::Right => match flip {
+                Flip::Horizontal | Flip::HorizontalAndVertical => Self::Left,
+                Flip::Vertical => direction,
+            },
+            Self::Up => match flip {
+                Flip::Vertical | Flip::HorizontalAndVertical => Self::Down,
+                Flip::Horizontal => direction,
+            },
+            Self::Down => match flip {
+                Flip::Vertical | Flip::HorizontalAndVertical => Self::Up,
+                Flip::Horizontal => direction,
+            },
+        })
    }

+    #[must_use]
    pub fn is_valid(
-        &self,
+        self,
        layout: Layout,
-        layout_flip: Option<LayoutFlip>,
+        layout_flip: Option<Flip>,
        idx: usize,
        len: usize,
    ) -> bool {
-        match OperationDirection::flip_direction(self, layout_flip) {
+        match Self::flip_direction(self, layout_flip) {
            OperationDirection::Up => match layout {
                Layout::BSP => len > 2 && idx != 0 && idx != 1,
                Layout::Columns => false,
@@ -93,9 +80,10 @@ impl OperationDirection {
        }
    }

-    pub fn new_idx(&self, layout: Layout, layout_flip: Option<LayoutFlip>, idx: usize) -> usize {
-        match OperationDirection::flip_direction(self, layout_flip) {
-            OperationDirection::Up => match layout {
+    #[must_use]
+    pub fn new_idx(self, layout: Layout, layout_flip: Option<Flip>, idx: usize) -> usize {
+        match Self::flip_direction(self, layout_flip) {
+            Self::Up => match layout {
                Layout::BSP => {
                    if idx % 2 == 0 {
                        idx - 1
@@ -106,11 +94,11 @@ impl OperationDirection {
                Layout::Columns => unreachable!(),
                Layout::Rows => idx - 1,
            },
-            OperationDirection::Down => match layout {
+            Self::Down => match layout {
                Layout::BSP | Layout::Rows => idx + 1,
                Layout::Columns => unreachable!(),
            },
-            OperationDirection::Left => match layout {
+            Self::Left => match layout {
                Layout::BSP => {
                    if idx % 2 == 0 {
                        idx - 2
@@ -121,7 +109,7 @@ impl OperationDirection {
                Layout::Columns => idx - 1,
                Layout::Rows => unreachable!(),
            },
-            OperationDirection::Right => match layout {
+            Self::Right => match layout {
                Layout::BSP | Layout::Columns => idx + 1,
                Layout::Rows => unreachable!(),
            },
--- a/komorebi-core/src/rect.rs
+++ b/komorebi-core/src/rect.rs
@@ -1,8 +1,9 @@
+use serde::Deserialize;
 use serde::Serialize;

 use bindings::Windows::Win32::Foundation::RECT;

-#[derive(Debug, Clone, Copy, Serialize, Eq, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)]
 pub struct Rect {
    pub left: i32,
    pub top: i32,
@@ -10,20 +11,9 @@ pub struct Rect {
    pub bottom: i32,
 }

-impl Default for Rect {
-    fn default() -> Self {
-        Rect {
-            left: 0,
-            top: 0,
-            right: 0,
-            bottom: 0,
-        }
-    }
-}
-
 impl From<RECT> for Rect {
    fn from(rect: RECT) -> Self {
-        Rect {
+        Self {
            left: rect.left,
            top: rect.top,
            right: rect.right - rect.left,
@@ -42,7 +32,8 @@ impl Rect {
        }
    }

-    pub fn contains_point(&self, point: (i32, i32)) -> bool {
+    #[must_use]
+    pub const fn contains_point(&self, point: (i32, i32)) -> bool {
        point.0 >= self.left
            && point.0 <= self.left + self.right
            && point.1 >= self.top
--- a/komorebi.sample.ahk
+++ b/komorebi.sample.ahk
@@ -3,6 +3,9 @@
 ; Enable hot reloading of changes to this file
 Run, komorebic.exe watch-configuration enable, , Hide

+; Configure the invisible border dimensions
+Run, komorebic.exe invisible-borders 7 0 14 7, , Hide
+
 ; Enable focus follows mouse
 Run, komorebic.exe focus-follows-mouse enable, , Hide

@@ -29,6 +32,10 @@ Run, komorebic.exe workspace-layout 0 1 columns, , Hide
 ; Set the floaty layout to not tile any windows
 Run, komorebic.exe workspace-tiling 0 4 disable, , Hide

+; Always show chat apps on the second workspace
+Run, komorebic.exe workspace-rule exe slack.exe 0 1, , Hide
+Run, komorebic.exe workspace-rule exe Discord.exe 0 1, , Hide
+
 ; Always float IntelliJ popups, matching on class
 Run, komorebic.exe float-rule class SunAwtDialog, , Hide
 ; Always float Control Panel, matching on title
@@ -42,9 +49,15 @@ Run, komorebic.exe float-rule exe wincompose.exe, , Hide
 Run, komorebic.exe float-rule title Calculator, , Hide
 Run, komorebic.exe float-rule exe 1Password.exe, , Hide

+; Always manage forcibly these applications that don't automatically get picked up by komorebi
+Run, komorebic.exe manage-rule exe TIM.exe, , Hide
+
 ; Identify applications that close to the tray
 Run, komorebic.exe identify-tray-application exe Discord.exe, , Hide

+; Identify applications that have overflowing borders
+Run, komorebic.exe identify-border-overflow exe Discord.exe, , Hide
+
 ; Change the focused window, Alt + Vim direction keys
 !h::
 Run, komorebic.exe focus left, , Hide
@@ -129,6 +142,11 @@ return
 Run, komorebic.exe toggle-monocle, , Hide
 return

+; Toggle native maximize for the focused window, Alt + Shift + =
+!+=::
+Run, komorebic.exe toggle-maximize, , Hide
+return
+
 ; Flip horizontally, Alt + X
 !x::
 Run, komorebic.exe flip-layout horizontal, , Hide
--- a/komorebi.sample.with.lib.ahk
+++ b/komorebi.sample.with.lib.ahk
@@ -0,0 +1,232 @@
+#SingleInstance Force
+#Include %A_ScriptDir%\komorebic.lib.ahk
+
+; Enable hot reloading of changes to this file
+WatchConfiguration("enable")
+
+; Ensure there are 5 workspaces created on monitor 0
+EnsureWorkspaces(0, 5)
+
+; Configure the invisible border dimensions
+InvisibleBorders(7, 0, 14, 7)
+
+; Configure the 1st workspace
+WorkspaceName(0, 0, "bsp")
+
+; Configure the 2nd workspace
+WorkspaceName(0, 1, "columns") ; Optionally set the name of the workspace
+WorkspacePadding(0, 1, 30) ; Set the padding around the edge of the screen
+ContainerPadding(0, 1, 30) ; Set the padding between the containers on the screen
+WorkspaceRule("exe", "slack.exe", 0, 1) ; Always show chat apps on this workspace
+
+; Configure the 3rd workspace
+WorkspaceName(0, 2, "thicc")
+WorkspacePadding(0, 2, 200) ; Set some super thicc padding
+
+; Configure the 4th workspace
+WorkspaceName(0, 3, "matrix")
+WorkspacePadding(0, 3, 0) ; No padding at all
+ContainerPadding(0, 3, 0) ; Matrix-y hacker vibes
+
+; Configure the 5th workspace
+WorkspaceName(0, 4, "floaty")
+WorkspaceTiling(0, 4, "disable") ; Everything floats here
+
+; Configure floating rules
+FloatRule("class", "SunAwtDialog") ; All the IntelliJ popups
+FloatRule("title", "Control Panek")
+FloatRule("class", "TaskManagerWindow")
+FloatRule("exe", "Wally.exe")
+FloatRule("exe", "wincompose.exe")
+FloatRule("exe", "1Password.exe")
+FloatRule("exe", "Wox.exe")
+
+; Identify Minimize-to-Tray Applications
+IdentifyTrayApplication("exe", "Discord.exe")
+IdentifyTrayApplication("exe", "Spotify.exe")
+
+; Identify Electron applications with overflowing borders
+IdentifyBorderOverflow("exe", "Discord.exe")
+IdentifyBorderOverflow("exe", "Spotify.exe")
+IdentifyBorderOverflow("class", "ZPFTEWndClass")
+
+; Change the focused window, Alt + Vim direction keys
+!h::
+Focus("left")
+return
+
+!j::
+Focus("down")
+return
+
+!k::
+Focus("up")
+return
+
+!l::
+Focus("right")
+return
+
+; Move the focused window in a given direction, Alt + Shift + Vim direction keys
+!+h::
+Move("left")
+return
+
+!+j::
+Move("down")
+return
+
+!+k::
+Move("up")
+return
+
+!+l::
+Move("right")
+return
+
+; Stack the focused window in a given direction, Alt + Shift + direction keys
+!+Left::
+Stack("left")
+return
+
+!+Down::
+Stack("down")
+return
+
+!+Up::
+Stack("up")
+return
+
+!+Right::
+Stack("right")
+return
+
+!]::
+CycleStack("next")
+return
+
+![::
+CycleStack("previous")
+return
+
+; Unstack the focused window, Alt + Shift + D
+!+d::
+Unstack()
+return
+
+; Promote the focused window to the top of the tree, Alt + Shift + Enter
+!+Enter::
+Promote()
+return
+
+; Manage the focused window
+!=::
+Manage()
+return
+
+; Unmanage the focused window
+!-::
+Unmanage()
+return
+
+; Switch to an equal-width, max-height column layout on the main workspace, Alt + Shift + C
+!+c::
+ChangeLayout("columns")
+return
+
+; Switch to the default bsp tiling layout on the main workspace, Alt + Shift + T
+!+t::
+ChangeLayout("bsp")
+return
+
+; Toggle the Monocle layout for the focused window, Alt + Shift + F
+!+f::
+ToggleMonocle()
+return
+
+; Toggle native maximize for the focused window, Alt + Shift + =
+!+=::
+ToggleMaximize()
+return
+
+; Flip horizontally, Alt + X
+!x::
+FlipLayout("horizontal")
+return
+
+; Flip vertically, Alt + Y
+!y::
+FlipLayout("vertical")
+return
+
+; Force a retile if things get janky, Alt + Shift + R
+!+r::
+Retile()
+return
+
+; Float the focused window, Alt + T
+!t::
+ToggleFloat()
+return
+
+; Reload ~/komorebi.ahk, Alt + O
+!o::
+ReloadConfiguration()
+return
+
+; Pause responding to any window events or komorebic commands, Alt + P
+!p::
+TogglePause()
+return
+
+; Enable focus follows mouse
+!0::
+ToggleFocusFollowsMouse("komorebi")
+return
+
+; Switch to workspace
+!1::
+Send !
+FocusWorkspace(0)
+return
+
+!2::
+Send !
+FocusWorkspace(1)
+return
+
+!3::
+Send !
+FocusWorkspace(2)
+return
+
+!4::
+Send !
+FocusWorkspace(3)
+return
+
+!5::
+Send !
+FocusWorkspace(4)
+return
+
+; Move window to workspace
+!+1::
+MoveToWorkspace(0)
+return
+
+!+2::
+MoveToWorkspace(1)
+return
+
+!+3::
+MoveToWorkspace(2)
+return
+
+!+4::
+MoveToWorkspace(3)
+return
+
+!+5::
+MoveToWorkspace(4)
+return
--- a/komorebi/Cargo.toml
+++ b/komorebi/Cargo.toml
@@ -1,6 +1,11 @@
 [package]
 name = "komorebi"
-version = "0.1.0"
+version = "0.1.4"
+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 = "2018"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -10,16 +15,17 @@ bindings = { package = "bindings", path = "../bindings" }
 komorebi-core = { path = "../komorebi-core" }

 bitflags = "1"
+clap = "3.0.0-beta.4"
 color-eyre = "0.5"
 crossbeam-channel = "0.5"
 crossbeam-utils = "0.8"
 ctrlc = "3"
 dirs = "3"
-eyre = "0.6"
 getset = "0.1"
 hotwatch = "0.4"
 lazy_static = "1"
 nanoid = "0.4"
+parking_lot = { version = "0.11", features = ["deadlock_detection"] }
 paste = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
@@ -29,4 +35,9 @@ tracing = "0.1"
 tracing-appender = "0.1"
 tracing-subscriber = "0.2"
 uds_windows = "1"
-which = "4"
+which = "4"
+winput = "0.2"
+winvd = "0.0.20"
+
+[features]
+deadlock_detection = []
--- a/komorebi/src/container.rs
+++ b/komorebi/src/container.rs
@@ -44,6 +44,18 @@ impl Container {
        }
    }

+    pub fn hwnd_from_exe(&self, exe: &str) -> Option<isize> {
+        for window in self.windows() {
+            if let Ok(window_exe) = window.exe() {
+                if exe == window_exe {
+                    return Option::from(window.hwnd);
+                }
+            }
+        }
+
+        None
+    }
+
    pub fn contains_window(&self, hwnd: isize) -> bool {
        for window in self.windows() {
            if window.hwnd == hwnd {
--- a/komorebi/src/main.rs
+++ b/komorebi/src/main.rs
@@ -1,15 +1,25 @@
 #![warn(clippy::all, clippy::nursery, clippy::pedantic)]
 #![allow(clippy::missing_errors_doc)]

+use std::collections::HashMap;
 use std::process::Command;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::sync::Mutex;
+#[cfg(feature = "deadlock_detection")]
+use std::thread;
+#[cfg(feature = "deadlock_detection")]
+use std::time::Duration;

-use color_eyre::eyre::ContextCompat;
+use clap::Clap;
+use color_eyre::eyre::anyhow;
 use color_eyre::Result;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use lazy_static::lazy_static;
+#[cfg(feature = "deadlock_detection")]
+use parking_lot::deadlock;
+use parking_lot::Mutex;
 use sysinfo::SystemExt;
 use tracing_appender::non_blocking::WorkerGuard;
 use tracing_subscriber::layer::SubscriberExt;
@@ -18,6 +28,8 @@ use which::which;

 use crate::process_command::listen_for_commands;
 use crate::process_event::listen_for_events;
+use crate::process_movement::listen_for_movements;
+use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;

@@ -28,6 +40,7 @@ mod container;
 mod monitor;
 mod process_command;
 mod process_event;
+mod process_movement;
 mod set_window_position;
 mod styles;
 mod window;
@@ -40,29 +53,32 @@ mod winevent_listener;
 mod workspace;

 lazy_static! {
-    static ref FLOAT_CLASSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
-    static ref FLOAT_EXES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
-    static ref FLOAT_TITLES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
    static ref HIDDEN_HWNDS: Arc<Mutex<Vec<isize>>> = Arc::new(Mutex::new(vec![]));
    static ref LAYERED_EXE_WHITELIST: Arc<Mutex<Vec<String>>> =
        Arc::new(Mutex::new(vec!["steam.exe".to_string()]));
-    static ref TRAY_AND_MULTI_WINDOW_CLASSES: Arc<Mutex<Vec<String>>> =
-        Arc::new(Mutex::new(vec![]));
-    static ref TRAY_AND_MULTI_WINDOW_EXES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
-        "explorer.exe".to_string(),
-        "firefox.exe".to_string(),
-        "chrome.exe".to_string(),
-        "idea64.exe".to_string(),
-        "ApplicationFrameHost.exe".to_string(),
-        "steam.exe".to_string()
-    ]));
+    static ref TRAY_AND_MULTI_WINDOW_IDENTIFIERS: Arc<Mutex<Vec<String>>> =
+        Arc::new(Mutex::new(vec![
+            "explorer.exe".to_string(),
+            "firefox.exe".to_string(),
+            "chrome.exe".to_string(),
+            "idea64.exe".to_string(),
+            "ApplicationFrameHost.exe".to_string(),
+            "steam.exe".to_string(),
+        ]));
    static ref OBJECT_NAME_CHANGE_ON_LAUNCH: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
        "firefox.exe".to_string(),
        "idea64.exe".to_string(),
    ]));
+    static ref WORKSPACE_RULES: Arc<Mutex<HashMap<String, (usize, usize)>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    static ref MANAGE_IDENTIFIERS: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
+    static ref FLOAT_IDENTIFIERS: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
+    static ref BORDER_OVERFLOW_IDENTIFIERS: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
 }

-fn setup() -> Result<WorkerGuard> {
+pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
+
+fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
    if std::env::var("RUST_LIB_BACKTRACE").is_err() {
        std::env::set_var("RUST_LIB_BACKTRACE", "1");
    }
@@ -73,9 +89,11 @@ fn setup() -> Result<WorkerGuard> {
        std::env::set_var("RUST_LOG", "info");
    }

-    let home = dirs::home_dir().context("there is no home directory")?;
+    let home = dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
    let appender = tracing_appender::rolling::never(home, "komorebi.log");
+    let color_appender = tracing_appender::rolling::never(std::env::temp_dir(), "komorebi.log");
    let (non_blocking, guard) = tracing_appender::non_blocking(appender);
+    let (color_non_blocking, color_guard) = tracing_appender::non_blocking(color_appender);

    tracing::subscriber::set_global_default(
        tracing_subscriber::fmt::Subscriber::builder()
@@ -85,6 +103,11 @@ fn setup() -> Result<WorkerGuard> {
                tracing_subscriber::fmt::Layer::default()
                    .with_writer(non_blocking)
                    .with_ansi(false),
+            )
+            .with(
+                tracing_subscriber::fmt::Layer::default()
+                    .with_writer(color_non_blocking)
+                    .with_ansi(true),
            ),
    )?;

@@ -113,11 +136,11 @@ fn setup() -> Result<WorkerGuard> {
        }
    }));

-    Ok(guard)
+    Ok((guard, color_guard))
 }

 pub fn load_configuration() -> Result<()> {
-    let home = dirs::home_dir().context("there is no home directory")?;
+    let home = dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;

    let mut config_v1 = home.clone();
    config_v1.push("komorebi.ahk");
@@ -131,7 +154,7 @@ pub fn load_configuration() -> Result<()> {
            config_v1
                .as_os_str()
                .to_str()
-                .context("cannot convert path to string")?
+                .ok_or_else(|| anyhow!("cannot convert path to string"))?
        );

        Command::new("autohotkey.exe")
@@ -143,7 +166,7 @@ pub fn load_configuration() -> Result<()> {
            config_v2
                .as_os_str()
                .to_str()
-                .context("cannot convert path to string")?
+                .ok_or_else(|| anyhow!("cannot convert path to string"))?
        );

        Command::new("AutoHotkey64.exe")
@@ -154,58 +177,99 @@ pub fn load_configuration() -> Result<()> {
    Ok(())
 }

+#[cfg(feature = "deadlock_detection")]
+#[tracing::instrument]
+fn detect_deadlocks() {
+    // Create a background thread which checks for deadlocks every 10s
+    thread::spawn(move || loop {
+        tracing::info!("running deadlock detector");
+        thread::sleep(Duration::from_secs(5));
+        let deadlocks = deadlock::check_deadlock();
+        if deadlocks.is_empty() {
+            continue;
+        }
+
+        tracing::error!("{} deadlocks detected", deadlocks.len());
+        for (i, threads) in deadlocks.iter().enumerate() {
+            tracing::error!("deadlock #{}", i);
+            for t in threads {
+                tracing::error!("thread id: {:#?}", t.thread_id());
+                tracing::error!("{:#?}", t.backtrace());
+            }
+        }
+    });
+}
+
+#[derive(Clap)]
+#[clap(author, about, version)]
+struct Opts {
+    /// Allow the use of komorebi's custom focus-follows-mouse implementation
+    #[clap(long = "ffm")]
+    focus_follows_mouse: bool,
+}
+
 #[tracing::instrument]
 fn main() -> Result<()> {
-    match std::env::args().count() {
-        1 => {
-            let mut system = sysinfo::System::new_all();
-            system.refresh_processes();
+    let opts: Opts = Opts::parse();
+    CUSTOM_FFM.store(opts.focus_follows_mouse, Ordering::SeqCst);

-            if system.process_by_name("komorebi.exe").len() > 1 {
-                tracing::error!("komorebi.exe is already running, please exit the existing process before starting a new one");
-                std::process::exit(1);
-            }
+    let arg_count = std::env::args().count();
+    let has_valid_args = arg_count == 1 || (arg_count == 2 && CUSTOM_FFM.load(Ordering::SeqCst));

-            // File logging worker guard has to have an assignment in the main fn to work
-            let _guard = setup()?;
+    if has_valid_args {
+        let mut system = sysinfo::System::new_all();
+        system.refresh_processes();

-            let process_id = WindowsApi::current_process_id();
-            WindowsApi::allow_set_foreground_window(process_id)?;
-
-            let (outgoing, incoming): (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) =
-                crossbeam_channel::unbounded();
-
-            let winevent_listener = winevent_listener::new(Arc::new(Mutex::new(outgoing)));
-            winevent_listener.start();
-
-            let wm = Arc::new(Mutex::new(window_manager::new(Arc::new(Mutex::new(
-                incoming,
-            )))?));
-
-            wm.lock().unwrap().init()?;
-            listen_for_commands(wm.clone());
-            listen_for_events(wm.clone());
-
-            load_configuration()?;
-
-            let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
-            ctrlc::set_handler(move || {
-                ctrlc_sender
-                    .send(())
-                    .expect("could not send signal on ctrl-c channel");
-            })?;
-
-            ctrlc_receiver
-                .recv()
-                .expect("could not receive signal on ctrl-c channel");
-
-            tracing::error!(
-                "received ctrl-c, restoring all hidden windows and terminating process"
-            );
-
-            wm.lock().unwrap().restore_all_windows();
-            std::process::exit(130);
+        if system.process_by_name("komorebi.exe").len() > 1 {
+            tracing::error!("komorebi.exe is already running, please exit the existing process before starting a new one");
+            std::process::exit(1);
        }
-        _ => Ok(()),
+
+        // File logging worker guard has to have an assignment in the main fn to work
+        let (_guard, _color_guard) = setup()?;
+
+        #[cfg(feature = "deadlock_detection")]
+        detect_deadlocks();
+
+        let process_id = WindowsApi::current_process_id();
+        WindowsApi::allow_set_foreground_window(process_id)?;
+
+        let (outgoing, incoming): (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) =
+            crossbeam_channel::unbounded();
+
+        let winevent_listener = winevent_listener::new(Arc::new(Mutex::new(outgoing)));
+        winevent_listener.start();
+
+        let wm = Arc::new(Mutex::new(WindowManager::new(Arc::new(Mutex::new(
+            incoming,
+        )))?));
+
+        wm.lock().init()?;
+        listen_for_commands(wm.clone());
+        listen_for_events(wm.clone());
+
+        if CUSTOM_FFM.load(Ordering::SeqCst) {
+            listen_for_movements(wm.clone());
+        }
+
+        load_configuration()?;
+
+        let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
+        ctrlc::set_handler(move || {
+            ctrlc_sender
+                .send(())
+                .expect("could not send signal on ctrl-c channel");
+        })?;
+
+        ctrlc_receiver
+            .recv()
+            .expect("could not receive signal on ctrl-c channel");
+
+        tracing::error!("received ctrl-c, restoring all hidden windows and terminating process");
+
+        wm.lock().restore_all_windows();
+        std::process::exit(130);
    }
+
+    Ok(())
 }
--- a/komorebi/src/monitor.rs
+++ b/komorebi/src/monitor.rs
@@ -1,11 +1,12 @@
 use std::collections::HashMap;
 use std::collections::VecDeque;

-use color_eyre::eyre::ContextCompat;
+use color_eyre::eyre::anyhow;
 use color_eyre::Result;
 use getset::CopyGetters;
 use getset::Getters;
 use getset::MutGetters;
+use getset::Setters;
 use serde::Serialize;

 use komorebi_core::Rect;
@@ -14,12 +15,13 @@ use crate::container::Container;
 use crate::ring::Ring;
 use crate::workspace::Workspace;

-#[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters)]
+#[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters, Setters)]
 pub struct Monitor {
-    #[getset(get_copy = "pub")]
+    #[getset(get_copy = "pub", set = "pub")]
    id: isize,
-    monitor_size: Rect,
-    #[getset(get = "pub")]
+    #[getset(get = "pub", set = "pub")]
+    size: Rect,
+    #[getset(get = "pub", set = "pub")]
    work_area_size: Rect,
    workspaces: Ring<Workspace>,
    #[serde(skip_serializing)]
@@ -29,12 +31,15 @@ pub struct Monitor {

 impl_ring_elements!(Monitor, Workspace);

-pub fn new(id: isize, monitor_size: Rect, work_area_size: Rect) -> Monitor {
+pub fn new(id: isize, size: Rect, work_area_size: Rect) -> Monitor {
+    let mut workspaces = Ring::default();
+    workspaces.elements_mut().push_back(Workspace::default());
+
    Monitor {
        id,
-        monitor_size,
+        size,
        work_area_size,
-        workspaces: Ring::default(),
+        workspaces,
        workspace_names: HashMap::default(),
    }
 }
@@ -56,7 +61,7 @@ impl Monitor {
    pub fn add_container(&mut self, container: Container) -> Result<()> {
        let workspace = self
            .focused_workspace_mut()
-            .context("there is no workspace")?;
+            .ok_or_else(|| anyhow!("there is no workspace"))?;

        workspace.add_container(container);

@@ -70,16 +75,25 @@ impl Monitor {
        }
    }

+    #[tracing::instrument(skip(self))]
    pub fn move_container_to_workspace(
        &mut self,
        target_workspace_idx: usize,
        follow: bool,
    ) -> Result<()> {
-        let container = self
+        let workspace = self
            .focused_workspace_mut()
-            .context("there is no workspace")?
+            .ok_or_else(|| anyhow!("there is no workspace"))?;
+
+        if workspace.maximized_window().is_some() {
+            return Err(anyhow!(
+                "cannot move native maximized window to another monitor or workspace"
+            ));
+        }
+
+        let container = workspace
            .remove_focused_container()
-            .context("there is no container")?;
+            .ok_or_else(|| anyhow!("there is no container"))?;

        let workspaces = self.workspaces_mut();

@@ -120,7 +134,7 @@ impl Monitor {
            if name.is_some() {
                self.workspaces_mut()
                    .get_mut(idx)
-                    .context("there is no workspace")?
+                    .ok_or_else(|| anyhow!("there is no workspace"))?
                    .set_name(name);
            }
        }
@@ -132,12 +146,12 @@ impl Monitor {
        self.workspaces().len()
    }

-    pub fn update_focused_workspace(&mut self) -> Result<()> {
+    pub fn update_focused_workspace(&mut self, invisible_borders: &Rect) -> Result<()> {
        let work_area = *self.work_area_size();

        self.focused_workspace_mut()
-            .context("there is no workspace")?
-            .update(&work_area)?;
+            .ok_or_else(|| anyhow!("there is no workspace"))?
+            .update(&work_area, invisible_borders)?;

        Ok(())
    }
--- a/komorebi/src/process_command.rs
+++ b/komorebi/src/process_command.rs
@@ -2,31 +2,33 @@ use std::io::BufRead;
 use std::io::BufReader;
 use std::io::Write;
 use std::str::FromStr;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::sync::Mutex;
 use std::thread;

-use color_eyre::eyre::ContextCompat;
+use color_eyre::eyre::anyhow;
 use color_eyre::Result;
+use parking_lot::Mutex;
 use uds_windows::UnixStream;

-use komorebi_core::ApplicationIdentifier;
+use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::SocketMessage;
+use komorebi_core::StateQuery;

 use crate::window_manager;
 use crate::window_manager::WindowManager;
 use crate::windows_api::WindowsApi;
-use crate::FLOAT_CLASSES;
-use crate::FLOAT_EXES;
-use crate::FLOAT_TITLES;
-use crate::TRAY_AND_MULTI_WINDOW_CLASSES;
-use crate::TRAY_AND_MULTI_WINDOW_EXES;
+use crate::BORDER_OVERFLOW_IDENTIFIERS;
+use crate::CUSTOM_FFM;
+use crate::FLOAT_IDENTIFIERS;
+use crate::MANAGE_IDENTIFIERS;
+use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
+use crate::WORKSPACE_RULES;

 #[tracing::instrument]
 pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
    let listener = wm
        .lock()
-        .unwrap()
        .command_listener
        .try_clone()
        .expect("could not clone unix listener");
@@ -35,7 +37,7 @@ pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
        tracing::info!("listening");
        for client in listener.incoming() {
            match client {
-                Ok(stream) => match wm.lock().unwrap().read_commands(stream) {
+                Ok(stream) => match wm.lock().read_commands(stream) {
                    Ok(()) => {}
                    Err(error) => tracing::error!("{}", error),
                },
@@ -51,6 +53,8 @@ pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
 impl WindowManager {
    #[tracing::instrument(skip(self))]
    pub fn process_command(&mut self, message: SocketMessage) -> Result<()> {
+        self.validate_virtual_desktop_id();
+
        match message {
            SocketMessage::Promote => self.promote_container_to_front()?,
            SocketMessage::FocusWindow(direction) => {
@@ -66,28 +70,31 @@ impl WindowManager {
            }
            SocketMessage::ToggleFloat => self.toggle_float()?,
            SocketMessage::ToggleMonocle => self.toggle_monocle()?,
+            SocketMessage::ToggleMaximize => self.toggle_maximize()?,
            SocketMessage::ContainerPadding(monitor_idx, workspace_idx, size) => {
                self.set_container_padding(monitor_idx, workspace_idx, size)?;
            }
            SocketMessage::WorkspacePadding(monitor_idx, workspace_idx, size) => {
                self.set_workspace_padding(monitor_idx, workspace_idx, size)?;
            }
-            SocketMessage::FloatClass(target) => {
-                let mut float_classes = FLOAT_CLASSES.lock().unwrap();
-                if !float_classes.contains(&target) {
-                    float_classes.push(target);
+            SocketMessage::WorkspaceRule(_, id, monitor_idx, workspace_idx) => {
+                {
+                    let mut workspace_rules = WORKSPACE_RULES.lock();
+                    workspace_rules.insert(id, (monitor_idx, workspace_idx));
+                }
+
+                self.enforce_workspace_rules()?;
+            }
+            SocketMessage::ManageRule(_, id) => {
+                let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
+                if !manage_identifiers.contains(&id) {
+                    manage_identifiers.push(id);
                }
            }
-            SocketMessage::FloatExe(target) => {
-                let mut float_exes = FLOAT_EXES.lock().unwrap();
-                if !float_exes.contains(&target) {
-                    float_exes.push(target);
-                }
-            }
-            SocketMessage::FloatTitle(target) => {
-                let mut float_titles = FLOAT_TITLES.lock().unwrap();
-                if !float_titles.contains(&target) {
-                    float_titles.push(target);
+            SocketMessage::FloatRule(_, id) => {
+                let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
+                if !float_identifiers.contains(&id) {
+                    float_identifiers.push(id);
                }
            }
            SocketMessage::AdjustContainerPadding(sizing, adjustment) => {
@@ -102,8 +109,19 @@ impl WindowManager {
            SocketMessage::MoveContainerToMonitorNumber(monitor_idx) => {
                self.move_container_to_monitor(monitor_idx, true)?;
            }
+            SocketMessage::SendContainerToWorkspaceNumber(workspace_idx) => {
+                self.move_container_to_workspace(workspace_idx, false)?;
+            }
+            SocketMessage::SendContainerToMonitorNumber(monitor_idx) => {
+                self.move_container_to_monitor(monitor_idx, false)?;
+            }
            SocketMessage::TogglePause => {
-                tracing::info!("pausing");
+                if self.is_paused {
+                    tracing::info!("resuming");
+                } else {
+                    tracing::info!("pausing");
+                }
+
                self.is_paused = !self.is_paused;
            }
            SocketMessage::ToggleTiling => {
@@ -113,21 +131,7 @@ impl WindowManager {
                self.focus_monitor(monitor_idx)?;
                self.update_focused_workspace(true)?;
            }
-            SocketMessage::Retile => {
-                for monitor in self.monitors_mut() {
-                    let work_area = *monitor.work_area_size();
-                    let workspace = monitor
-                        .focused_workspace_mut()
-                        .context("there is no workspace")?;
-
-                    // Reset any resize adjustments if we want to force a retile
-                    for resize in workspace.resize_dimensions_mut() {
-                        *resize = None;
-                    }
-
-                    workspace.update(&work_area)?;
-                }
-            }
+            SocketMessage::Retile => self.retile_all()?,
            SocketMessage::FlipLayout(layout_flip) => self.flip_layout(layout_flip)?,
            SocketMessage::ChangeLayout(layout) => self.change_workspace_layout(layout)?,
            SocketMessage::WorkspaceTiling(monitor_idx, workspace_idx, tile) => {
@@ -137,6 +141,15 @@ impl WindowManager {
                self.set_workspace_layout(monitor_idx, workspace_idx, layout)?;
            }
            SocketMessage::FocusWorkspaceNumber(workspace_idx) => {
+                // 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
+                let monitor_idx = self.monitor_idx_from_current_pos().ok_or_else(|| {
+                    anyhow!("there is no monitor associated with the current cursor position")
+                })?;
+
+                self.focus_monitor(monitor_idx)?;
+
                self.focus_workspace(workspace_idx)?;
            }
            SocketMessage::Stop => {
@@ -157,21 +170,132 @@ impl WindowManager {
            }
            SocketMessage::State => {
                let state = serde_json::to_string_pretty(&window_manager::State::from(self))?;
-                let mut socket = dirs::home_dir().context("there is no home directory")?;
+                let mut socket =
+                    dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
                socket.push("komorebic.sock");
                let socket = socket.as_path();

                let mut stream = UnixStream::connect(&socket)?;
                stream.write_all(state.as_bytes())?;
            }
+            SocketMessage::Query(query) => {
+                let response = match query {
+                    StateQuery::FocusedMonitorIndex => self.focused_monitor_idx(),
+                    StateQuery::FocusedWorkspaceIndex => self
+                        .focused_monitor()
+                        .ok_or_else(|| anyhow!("there is no monitor"))?
+                        .focused_workspace_idx(),
+                    StateQuery::FocusedContainerIndex => {
+                        self.focused_workspace()?.focused_container_idx()
+                    }
+                    StateQuery::FocusedWindowIndex => {
+                        self.focused_container()?.focused_window_idx()
+                    }
+                }
+                .to_string();
+
+                let mut socket =
+                    dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
+                socket.push("komorebic.sock");
+                let socket = socket.as_path();
+
+                let mut stream = UnixStream::connect(&socket)?;
+                stream.write_all(response.as_bytes())?;
+            }
            SocketMessage::ResizeWindow(direction, sizing) => {
                self.resize_window(direction, sizing, Option::from(50))?;
            }
-            SocketMessage::FocusFollowsMouse(enable) => {
-                if enable {
-                    WindowsApi::enable_focus_follows_mouse()?;
-                } else {
-                    WindowsApi::disable_focus_follows_mouse()?;
+            SocketMessage::FocusFollowsMouse(mut implementation, enable) => {
+                if !CUSTOM_FFM.load(Ordering::SeqCst) {
+                    tracing::warn!(
+                        "komorebi was not started with the --ffm flag, so the komorebi implementation of focus follows mouse cannot be enabled; defaulting to windows implementation"
+                    );
+                    implementation = FocusFollowsMouseImplementation::Windows;
+                }
+
+                match implementation {
+                    FocusFollowsMouseImplementation::Komorebi => {
+                        if WindowsApi::focus_follows_mouse()? {
+                            tracing::warn!(
+                                "the komorebi implementation of focus follows mouse cannot be enabled while the windows implementation is enabled"
+                            );
+                        } else if enable {
+                            self.focus_follows_mouse = Option::from(implementation);
+                        } else {
+                            self.focus_follows_mouse = None;
+                            self.has_pending_raise_op = false;
+                        }
+                    }
+                    FocusFollowsMouseImplementation::Windows => {
+                        if let Some(FocusFollowsMouseImplementation::Komorebi) =
+                            self.focus_follows_mouse
+                        {
+                            tracing::warn!(
+                                "the windows implementation of focus follows mouse cannot be enabled while the komorebi implementation is enabled"
+                            );
+                        } else if enable {
+                            WindowsApi::enable_focus_follows_mouse()?;
+                            self.focus_follows_mouse =
+                                Option::from(FocusFollowsMouseImplementation::Windows);
+                        } else {
+                            WindowsApi::disable_focus_follows_mouse()?;
+                            self.focus_follows_mouse = None;
+                        }
+                    }
+                }
+            }
+            SocketMessage::ToggleFocusFollowsMouse(mut implementation) => {
+                if !CUSTOM_FFM.load(Ordering::SeqCst) {
+                    tracing::warn!(
+                        "komorebi was not started with the --ffm flag, so the komorebi implementation of focus follows mouse cannot be toggled; defaulting to windows implementation"
+                    );
+                    implementation = FocusFollowsMouseImplementation::Windows;
+                }
+
+                match implementation {
+                    FocusFollowsMouseImplementation::Komorebi => {
+                        if WindowsApi::focus_follows_mouse()? {
+                            tracing::warn!(
+                                "the komorebi implementation of focus follows mouse cannot be toggled while the windows implementation is enabled"
+                            );
+                        } else {
+                            match self.focus_follows_mouse {
+                                None => {
+                                    self.focus_follows_mouse = Option::from(implementation);
+                                    self.has_pending_raise_op = false;
+                                }
+                                Some(FocusFollowsMouseImplementation::Komorebi) => {
+                                    self.focus_follows_mouse = None;
+                                }
+                                Some(FocusFollowsMouseImplementation::Windows) => {
+                                    tracing::warn!("ignoring command that could mix different focus follows mouse implementations");
+                                }
+                            }
+                        }
+                    }
+                    FocusFollowsMouseImplementation::Windows => {
+                        if let Some(FocusFollowsMouseImplementation::Komorebi) =
+                            self.focus_follows_mouse
+                        {
+                            tracing::warn!(
+                                "the windows implementation of focus follows mouse cannot be toggled while the komorebi implementation is enabled"
+                            );
+                        } else {
+                            match self.focus_follows_mouse {
+                                None => {
+                                    WindowsApi::enable_focus_follows_mouse()?;
+                                    self.focus_follows_mouse = Option::from(implementation);
+                                }
+                                Some(FocusFollowsMouseImplementation::Windows) => {
+                                    WindowsApi::disable_focus_follows_mouse()?;
+                                    self.focus_follows_mouse = None;
+                                }
+                                Some(FocusFollowsMouseImplementation::Komorebi) => {
+                                    tracing::warn!("ignoring command that could mix different focus follows mouse implementations");
+                                }
+                            }
+                        }
+                    }
                }
            }
            SocketMessage::ReloadConfiguration => {
@@ -180,22 +304,29 @@ impl WindowManager {
            SocketMessage::WatchConfiguration(enable) => {
                self.watch_configuration(enable)?;
            }
-            SocketMessage::IdentifyTrayApplication(identifier, id) => match identifier {
-                ApplicationIdentifier::Exe => {
-                    let mut exes = TRAY_AND_MULTI_WINDOW_EXES.lock().unwrap();
-                    if !exes.contains(&id) {
-                        exes.push(id);
-                    }
+            SocketMessage::IdentifyBorderOverflow(_, id) => {
+                let mut identifiers = BORDER_OVERFLOW_IDENTIFIERS.lock();
+                if !identifiers.contains(&id) {
+                    identifiers.push(id);
                }
-                ApplicationIdentifier::Class => {
-                    let mut classes = TRAY_AND_MULTI_WINDOW_CLASSES.lock().unwrap();
-                    if !classes.contains(&id) {
-                        classes.push(id);
-                    }
+            }
+            SocketMessage::IdentifyTrayApplication(_, id) => {
+                let mut identifiers = TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
+                if !identifiers.contains(&id) {
+                    identifiers.push(id);
                }
-                ApplicationIdentifier::Title => {}
-            },
-        }
+            }
+            SocketMessage::ManageFocusedWindow => {
+                self.manage_focused_window()?;
+            }
+            SocketMessage::UnmanageFocusedWindow => {
+                self.unmanage_focused_window()?;
+            }
+            SocketMessage::InvisibleBorders(rect) => {
+                self.invisible_borders = rect;
+                self.retile_all()?;
+            }
+        };

        tracing::info!("processed");
        Ok(())
@@ -208,14 +339,15 @@ impl WindowManager {
            let message = SocketMessage::from_str(&line?)?;

            if self.is_paused {
-                if let SocketMessage::TogglePause = message {
-                    tracing::info!("resuming");
-                    self.is_paused = !self.is_paused;
-                    return Ok(());
-                }
-
-                tracing::trace!("ignoring while paused");
-                return Ok(());
+                return match message {
+                    SocketMessage::TogglePause | SocketMessage::State | SocketMessage::Stop => {
+                        Ok(self.process_command(message)?)
+                    }
+                    _ => {
+                        tracing::trace!("ignoring while paused");
+                        Ok(())
+                    }
+                };
            }

            self.process_command(message)?;
--- a/komorebi/src/process_event.rs
+++ b/komorebi/src/process_event.rs
@@ -1,11 +1,11 @@
 use std::fs::OpenOptions;
 use std::sync::Arc;
-use std::sync::Mutex;
 use std::thread;

-use color_eyre::eyre::ContextCompat;
+use color_eyre::eyre::anyhow;
 use color_eyre::Result;
 use crossbeam_channel::select;
+use parking_lot::Mutex;

 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
@@ -15,12 +15,11 @@ use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::HIDDEN_HWNDS;
-use crate::TRAY_AND_MULTI_WINDOW_CLASSES;
-use crate::TRAY_AND_MULTI_WINDOW_EXES;
+use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;

 #[tracing::instrument]
 pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
-    let receiver = wm.lock().unwrap().incoming_events.lock().unwrap().clone();
+    let receiver = wm.lock().incoming_events.lock().clone();

    thread::spawn(move || {
        tracing::info!("listening");
@@ -28,7 +27,7 @@ pub fn listen_for_events(wm: Arc<Mutex<WindowManager>>) {
            select! {
                recv(receiver) -> mut maybe_event => {
                    if let Ok(event) = maybe_event.as_mut() {
-                        match wm.lock().unwrap().process_event(event) {
+                        match wm.lock().process_event(event) {
                            Ok(()) => {},
                            Err(error) => tracing::error!("{}", error)
                        }
@@ -48,26 +47,32 @@ impl WindowManager {
            return Ok(());
        }

+        self.validate_virtual_desktop_id();
+
        // Make sure we have the most recently focused monitor from any event
        match event {
-            WindowManagerEvent::FocusChange(_, window)
+            WindowManagerEvent::MonitorPoll(_, window)
+            | WindowManagerEvent::FocusChange(_, window)
            | WindowManagerEvent::Show(_, window)
            | WindowManagerEvent::MoveResizeEnd(_, window) => {
-                let monitor_idx = self
-                    .monitor_idx_from_window(*window)
-                    .context("there is no monitor associated with this window, it may have already been destroyed")?;
+                self.reconcile_monitors()?;
+
+                let monitor_idx = self.monitor_idx_from_window(*window)
+                    .ok_or_else(|| anyhow!("there is no monitor associated with this window, it may have already been destroyed"))?;

                self.focus_monitor(monitor_idx)?;
            }
            _ => {}
        }

+        let invisible_borders = self.invisible_borders;
+
        for (i, monitor) in self.monitors_mut().iter_mut().enumerate() {
            let work_area = *monitor.work_area_size();
            for (j, workspace) in monitor.workspaces_mut().iter_mut().enumerate() {
                let reaped_orphans = workspace.reap_orphans()?;
                if reaped_orphans.0 > 0 || reaped_orphans.1 > 0 {
-                    workspace.update(&work_area)?;
+                    workspace.update(&work_area, &invisible_borders)?;
                    tracing::info!(
                        "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
                        reaped_orphans.0,
@@ -79,33 +84,51 @@ impl WindowManager {
            }
        }

+        self.enforce_workspace_rules()?;
+
        if matches!(event, WindowManagerEvent::MouseCapture(..)) {
-            tracing::trace!("only reaping orphans for mouse capture event");
+            tracing::trace!(
+                "only reaping orphans and enforcing workspace rules for mouse capture event"
+            );
            return Ok(());
        }

        match event {
-            WindowManagerEvent::Minimize(_, window) | WindowManagerEvent::Destroy(_, window) => {
+            WindowManagerEvent::Raise(window) => {
+                window.raise()?;
+                self.has_pending_raise_op = false;
+            }
+            WindowManagerEvent::Minimize(_, window)
+            | WindowManagerEvent::Destroy(_, window)
+            | WindowManagerEvent::Unmanage(window) => {
                self.focused_workspace_mut()?.remove_window(window.hwnd)?;
                self.update_focused_workspace(false)?;
            }

            WindowManagerEvent::Hide(_, window) => {
+                let mut hide = false;
                // Some major applications unfortunately send the HIDE signal when they are being
                // minimized or destroyed. Applications that close to the tray also do the same,
                // and will have is_window() return true, as the process is still running even if
                // the window is not visible.
-                let tray_and_multi_window_exes = TRAY_AND_MULTI_WINDOW_EXES.lock().unwrap();
-                let tray_and_multi_window_classes = TRAY_AND_MULTI_WINDOW_CLASSES.lock().unwrap();
-
-                // We don't want to purge windows that have been deliberately hidden by us, eg. when
-                // they are not on the top of a container stack.
-                let programmatically_hidden_hwnds = HIDDEN_HWNDS.lock().unwrap();
-
-                if (!window.is_window() || tray_and_multi_window_exes.contains(&window.exe()?))
-                    || tray_and_multi_window_classes.contains(&window.class()?)
-                        && !programmatically_hidden_hwnds.contains(&window.hwnd)
                {
+                    let tray_and_multi_window_identifiers =
+                        TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
+
+                    // We don't want to purge windows that have been deliberately hidden by us, eg. when
+                    // they are not on the top of a container stack.
+                    let programmatically_hidden_hwnds = HIDDEN_HWNDS.lock();
+
+                    if (!window.is_window()
+                        || tray_and_multi_window_identifiers.contains(&window.exe()?))
+                        || tray_and_multi_window_identifiers.contains(&window.class()?)
+                            && !programmatically_hidden_hwnds.contains(&window.hwnd)
+                    {
+                        hide = true;
+                    }
+                }
+
+                if hide {
                    self.focused_workspace_mut()?.remove_window(window.hwnd)?;
                    self.update_focused_workspace(false)?;
                }
@@ -120,10 +143,16 @@ impl WindowManager {
                    return Ok(());
                }

+                if let Some(w) = workspace.maximized_window() {
+                    if w.hwnd == window.hwnd {
+                        return Ok(());
+                    }
+                }
+
                self.focused_workspace_mut()?
                    .focus_container_by_window(window.hwnd)?;
            }
-            WindowManagerEvent::Show(_, window) => {
+            WindowManagerEvent::Show(_, window) | WindowManagerEvent::Manage(window) => {
                let mut switch_to = None;
                for (i, monitors) in self.monitors().iter().enumerate() {
                    for (j, workspace) in monitors.workspaces().iter().enumerate() {
@@ -133,16 +162,16 @@ impl WindowManager {
                    }
                }

-                if let Some(indices) = switch_to {
-                    if self.focused_monitor_idx() != indices.0
-                        && self
+                if let Some((known_monitor_idx, known_workspace_idx)) = switch_to {
+                    if self.focused_monitor_idx() != known_monitor_idx
+                        || self
                            .focused_monitor()
-                            .context("there is no monitor")?
+                            .ok_or_else(|| anyhow!("there is no monitor"))?
                            .focused_workspace_idx()
-                            != indices.1
+                            != known_workspace_idx
                    {
-                        self.focus_monitor(indices.0)?;
-                        self.focus_workspace(indices.1)?;
+                        self.focus_monitor(known_monitor_idx)?;
+                        self.focus_workspace(known_workspace_idx)?;
                        return Ok(());
                    }
                }
@@ -170,7 +199,7 @@ impl WindowManager {

                let workspace = self.focused_workspace_mut()?;

-                if workspace.containers().is_empty() || !workspace.contains_window(window.hwnd) {
+                if !workspace.contains_window(window.hwnd) {
                    workspace.new_container_for_window(*window);
                    self.update_focused_workspace(false)?;
                }
@@ -189,22 +218,14 @@ impl WindowManager {
                let old_position = *workspace
                    .latest_layout()
                    .get(focused_idx)
-                    .context("there is no latest layout")?;
+                    .ok_or_else(|| anyhow!("there is no latest layout"))?;
                let mut new_position = WindowsApi::window_rect(window.hwnd())?;

-                // See Window.set_position() in window.rs for comments
-                let border = Rect {
-                    left: 12,
-                    top: 0,
-                    right: 24,
-                    bottom: 12,
-                };
-
-                // Adjust for the invisible border
-                new_position.left += border.left;
-                new_position.top += border.top;
-                new_position.right -= border.right;
-                new_position.bottom -= border.bottom;
+                // Adjust for the invisible borders
+                new_position.left += invisible_borders.left;
+                new_position.top += invisible_borders.top;
+                new_position.right -= invisible_borders.right;
+                new_position.bottom -= invisible_borders.bottom;

                let resize = Rect {
                    left: new_position.left - old_position.left,
@@ -264,9 +285,14 @@ impl WindowManager {
                    self.update_focused_workspace(false)?;
                }
            }
-            WindowManagerEvent::MouseCapture(..) => {}
+            WindowManagerEvent::MonitorPoll(..) | WindowManagerEvent::MouseCapture(..) => {}
        };

+        // If we unmanaged a window, it shouldn't be immediately hidden behind managed windows
+        if let WindowManagerEvent::Unmanage(window) = event {
+            window.center(&self.focused_monitor_work_area()?, &invisible_borders)?;
+        }
+
        tracing::trace!("updating list of known hwnds");
        let mut known_hwnds = vec![];
        for monitor in self.monitors() {
@@ -279,7 +305,8 @@ impl WindowManager {
            }
        }

-        let mut hwnd_json = dirs::home_dir().context("there is no home directory")?;
+        let mut hwnd_json =
+            dirs::home_dir().ok_or_else(|| anyhow!("there is no home directory"))?;
        hwnd_json.push("komorebi.hwnd.json");
        let file = OpenOptions::new()
            .write(true)
@@ -288,6 +315,7 @@ impl WindowManager {
            .open(hwnd_json)?;

        serde_json::to_writer_pretty(&file, &known_hwnds)?;
+
        tracing::info!("processed: {}", event.window().to_string());
        Ok(())
    }
--- a/komorebi/src/process_movement.rs
+++ b/komorebi/src/process_movement.rs
@@ -0,0 +1,41 @@
+use std::sync::Arc;
+
+use parking_lot::Mutex;
+use winput::message_loop;
+use winput::message_loop::Event;
+use winput::Action;
+
+use komorebi_core::FocusFollowsMouseImplementation;
+
+use crate::window_manager::WindowManager;
+
+#[tracing::instrument]
+pub fn listen_for_movements(wm: Arc<Mutex<WindowManager>>) {
+    std::thread::spawn(move || {
+        let mut ignore_movement = false;
+
+        let receiver = message_loop::start().expect("could not start winput message loop");
+
+        loop {
+            let focus_follows_mouse = wm.lock().focus_follows_mouse.clone();
+            if let Some(FocusFollowsMouseImplementation::Komorebi) = focus_follows_mouse {
+                match receiver.next_event() {
+                    // Don't want to send any raise events while we are dragging or resizing
+                    Event::MouseButton { action, .. } => match action {
+                        Action::Press => ignore_movement = true,
+                        Action::Release => ignore_movement = false,
+                    },
+                    Event::MouseMoveRelative { .. } => {
+                        if !ignore_movement {
+                            match wm.lock().raise_window_at_cursor_pos() {
+                                Ok(_) => {}
+                                Err(error) => tracing::error!("{}", error),
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+    });
+}
--- a/komorebi/src/window.rs
+++ b/komorebi/src/window.rs
@@ -2,7 +2,7 @@ use std::convert::TryFrom;
 use std::fmt::Display;
 use std::fmt::Formatter;

-use color_eyre::eyre::ContextCompat;
+use color_eyre::eyre::anyhow;
 use color_eyre::Result;
 use serde::ser::SerializeStruct;
 use serde::Serialize;
@@ -15,11 +15,11 @@ use crate::styles::GwlExStyle;
 use crate::styles::GwlStyle;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
-use crate::FLOAT_CLASSES;
-use crate::FLOAT_EXES;
-use crate::FLOAT_TITLES;
+use crate::BORDER_OVERFLOW_IDENTIFIERS;
+use crate::FLOAT_IDENTIFIERS;
 use crate::HIDDEN_HWNDS;
 use crate::LAYERED_EXE_WHITELIST;
+use crate::MANAGE_IDENTIFIERS;

 #[derive(Debug, Clone, Copy)]
 pub struct Window {
@@ -71,46 +71,52 @@ impl Window {
        HWND(self.hwnd)
    }

-    pub fn set_position(&mut self, layout: &Rect, top: bool) -> Result<()> {
-        // NOTE: This is how the border variable below was calculated; every time this code was
-        // run on any window in any position, the generated border was always the same, so I am
-        // hard coding the border Rect to avoid two calls to set_window_pos and making the screen
-        // flicker on container/window movement. Still not 100% sure if this is DPI-aware.
+    pub fn center(&mut self, work_area: &Rect, invisible_borders: &Rect) -> Result<()> {
+        let half_width = work_area.right / 2;
+        let half_weight = work_area.bottom / 2;

-        // Set the new position first to be able to get the extended frame bounds
-        // WindowsApi::set_window_pos(self.hwnd(), layout, false, false)?;
-        // let mut rect = WindowsApi::window_rect(self.hwnd())?;
-
-        // Get the extended frame bounds of the new position
-        // let frame = WindowsApi::window_rect_with_extended_frame_bounds(self.hwnd())?;
-
-        // Calculate the invisible border diff
-        // let border = Rect {
-        //     left: frame.left - rect.left,
-        //     top: frame.top - rect.top,
-        //     right: rect.right - frame.right,
-        //     bottom: rect.bottom - frame.bottom,
-        // };
+        self.set_position(
+            &Rect {
+                left: work_area.left + ((work_area.right - half_width) / 2),
+                top: work_area.top + ((work_area.bottom - half_weight) / 2),
+                right: half_width,
+                bottom: half_weight,
+            },
+            invisible_borders,
+            true,
+        )
+    }

+    pub fn set_position(
+        &mut self,
+        layout: &Rect,
+        invisible_borders: &Rect,
+        top: bool,
+    ) -> Result<()> {
        let mut rect = *layout;
-        let border = Rect {
-            left: 12,
-            top: 0,
-            right: 24,
-            bottom: 12,
-        };
+        let mut should_remove_border = true;

-        // Remove the invisible border
-        rect.left -= border.left;
-        rect.top -= border.top;
-        rect.right += border.right;
-        rect.bottom += border.bottom;
+        let border_overflows = BORDER_OVERFLOW_IDENTIFIERS.lock();
+        if border_overflows.contains(&self.title()?)
+            || border_overflows.contains(&self.exe()?)
+            || border_overflows.contains(&self.class()?)
+        {
+            should_remove_border = false;
+        }
+
+        if should_remove_border {
+            // Remove the invisible borders
+            rect.left -= invisible_borders.left;
+            rect.top -= invisible_borders.top;
+            rect.right += invisible_borders.right;
+            rect.bottom += invisible_borders.bottom;
+        }

        WindowsApi::position_window(self.hwnd(), &rect, top)
    }

    pub fn hide(self) {
-        let mut programmatically_hidden_hwnds = HIDDEN_HWNDS.lock().unwrap();
+        let mut programmatically_hidden_hwnds = HIDDEN_HWNDS.lock();
        if !programmatically_hidden_hwnds.contains(&self.hwnd) {
            programmatically_hidden_hwnds.push(self.hwnd);
        }
@@ -119,7 +125,7 @@ impl Window {
    }

    pub fn restore(self) {
-        let mut programmatically_hidden_hwnds = HIDDEN_HWNDS.lock().unwrap();
+        let mut programmatically_hidden_hwnds = HIDDEN_HWNDS.lock();
        if let Some(idx) = programmatically_hidden_hwnds
            .iter()
            .position(|&hwnd| hwnd == self.hwnd)
@@ -130,6 +136,39 @@ impl Window {
        WindowsApi::restore_window(self.hwnd());
    }

+    pub fn maximize(self) {
+        let mut programmatically_hidden_hwnds = HIDDEN_HWNDS.lock();
+        if let Some(idx) = programmatically_hidden_hwnds
+            .iter()
+            .position(|&hwnd| hwnd == self.hwnd)
+        {
+            programmatically_hidden_hwnds.remove(idx);
+        }
+
+        WindowsApi::maximize_window(self.hwnd());
+    }
+
+    pub fn raise(self) -> Result<()> {
+        // Attach komorebi thread to Window thread
+        let (_, window_thread_id) = WindowsApi::window_thread_process_id(self.hwnd());
+        let current_thread_id = WindowsApi::current_thread_id();
+        WindowsApi::attach_thread_input(current_thread_id, window_thread_id, true)?;
+
+        // Raise Window to foreground
+        match WindowsApi::set_foreground_window(self.hwnd()) {
+            Ok(_) => {}
+            Err(error) => {
+                tracing::error!(
+                    "could not set as foreground window, but continuing execution of focus(): {}",
+                    error
+                );
+            }
+        };
+
+        // This isn't really needed when the above command works as expected via AHK
+        WindowsApi::set_focus(self.hwnd())
+    }
+
    pub fn focus(self) -> Result<()> {
        // Attach komorebi thread to Window thread
        let (_, window_thread_id) = WindowsApi::window_thread_process_id(self.hwnd());
@@ -161,12 +200,12 @@ impl Window {

    pub fn style(self) -> Result<GwlStyle> {
        let bits = u32::try_from(WindowsApi::gwl_style(self.hwnd())?)?;
-        GwlStyle::from_bits(bits).context("there is no gwl style")
+        GwlStyle::from_bits(bits).ok_or_else(|| anyhow!("there is no gwl style"))
    }

    pub fn ex_style(self) -> Result<GwlExStyle> {
        let bits = u32::try_from(WindowsApi::gwl_ex_style(self.hwnd())?)?;
-        GwlExStyle::from_bits(bits).context("there is no gwl style")
+        GwlExStyle::from_bits(bits).ok_or_else(|| anyhow!("there is no gwl style"))
    }

    pub fn title(self) -> Result<String> {
@@ -192,9 +231,9 @@ impl Window {

    #[tracing::instrument(fields(exe, title))]
    pub fn should_manage(self, event: Option<WindowManagerEvent>) -> Result<bool> {
-        let classes = FLOAT_CLASSES.lock().unwrap();
-        let exes = FLOAT_EXES.lock().unwrap();
-        let titles = FLOAT_TITLES.lock().unwrap();
+        if let Some(WindowManagerEvent::MonitorPoll(_, _)) = event {
+            return Ok(true);
+        }

        if self.title().is_err() {
            return Ok(false);
@@ -212,22 +251,25 @@ impl Window {
            (true, _) |
            // If not allowing cloaked windows, we need to ensure the window is not cloaked
            (false, false) => {
-                if let (Ok(title), Ok(exe_name)) = (self.title(), self.exe()) {
-                    if titles.contains(&title) {
-                        return Ok(false);
-                    }
-
-                    if exes.contains(&exe_name) {
-                        return Ok(false);
-                    }
-
-                    if let Ok(class) = self.class() {
-                        if classes.contains(&class) {
+                if let (Ok(title), Ok(exe_name), Ok(class)) = (self.title(), self.exe(), self.class()) {
+                    {
+                        let float_identifiers = FLOAT_IDENTIFIERS.lock();
+                        if float_identifiers.contains(&title)
+                            || float_identifiers.contains(&exe_name)
+                            || float_identifiers.contains(&class) {
                            return Ok(false);
                        }
                    }

-                    let allow_layered = LAYERED_EXE_WHITELIST.lock().unwrap().contains(&exe_name);
+                    let managed_override = {
+                        let manage_identifiers = MANAGE_IDENTIFIERS.lock();
+                        manage_identifiers.contains(&exe_name) || manage_identifiers.contains(&class)
+                    };
+
+                    let allow_layered = {
+                        let layered_exe_whitelist = LAYERED_EXE_WHITELIST.lock();
+                        layered_exe_whitelist.contains(&exe_name)
+                    };

                    let style = self.style()?;
                    let ex_style = self.ex_style()?;
@@ -240,20 +282,17 @@ impl Window {
                        // allowing a specific layered window on the whitelist (like Steam), it should
                        // pass this check
                        && (allow_layered || !ex_style.contains(GwlExStyle::LAYERED))
+                        || managed_override
                    {
-                        Ok(true)
-                    } else {
-                        if event.is_some() {
-                            tracing::debug!("ignoring (exe: {}, title: {})", exe_name, title);
-                        }
-
-                        Ok(false)
+                        return Ok(true);
+                    } else if event.is_some() {
+                        tracing::debug!("ignoring (exe: {}, title: {})", exe_name, title);
                    }
-                } else {
-                    Ok(false)
                }
            }
-            _ => Ok(false),
+            _ => {}
        }
+
+        Ok(false)
    }
 }
--- a/komorebi/src/window_manager.rs
+++ b/komorebi/src/window_manager.rs
--- a/komorebi/src/window_manager_event.rs
+++ b/komorebi/src/window_manager_event.rs
@@ -3,6 +3,7 @@ use std::fmt::Formatter;

 use crate::window::Window;
 use crate::winevent::WinEvent;
+use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;

 #[derive(Debug, Copy, Clone)]
 pub enum WindowManagerEvent {
@@ -13,11 +14,21 @@ pub enum WindowManagerEvent {
    Show(WinEvent, Window),
    MoveResizeEnd(WinEvent, Window),
    MouseCapture(WinEvent, Window),
+    Manage(Window),
+    Unmanage(Window),
+    Raise(Window),
+    MonitorPoll(WinEvent, Window),
 }

 impl Display for WindowManagerEvent {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
+            WindowManagerEvent::Manage(window) => {
+                write!(f, "Manage (Window: {})", window)
+            }
+            WindowManagerEvent::Unmanage(window) => {
+                write!(f, "Unmanage (Window: {})", window)
+            }
            WindowManagerEvent::Destroy(winevent, window) => {
                write!(f, "Destroy (WinEvent: {}, Window: {})", winevent, window)
            }
@@ -51,6 +62,16 @@ impl Display for WindowManagerEvent {
                    winevent, window
                )
            }
+            WindowManagerEvent::Raise(window) => {
+                write!(f, "Raise (Window: {})", window)
+            }
+            WindowManagerEvent::MonitorPoll(winevent, window) => {
+                write!(
+                    f,
+                    "MonitorPoll (WinEvent: {}, Window: {})",
+                    winevent, window
+                )
+            }
        }
    }
 }
@@ -64,28 +85,61 @@ impl WindowManagerEvent {
            | WindowManagerEvent::Minimize(_, window)
            | WindowManagerEvent::Show(_, window)
            | WindowManagerEvent::MoveResizeEnd(_, window)
-            | WindowManagerEvent::MouseCapture(_, window) => window,
+            | WindowManagerEvent::MouseCapture(_, window)
+            | WindowManagerEvent::MonitorPoll(_, window)
+            | WindowManagerEvent::Raise(window)
+            | WindowManagerEvent::Manage(window)
+            | WindowManagerEvent::Unmanage(window) => window,
        }
    }

-    pub const fn from_win_event(winevent: WinEvent, window: Window) -> Option<Self> {
+    pub fn from_win_event(winevent: WinEvent, window: Window) -> Option<Self> {
        match winevent {
-            WinEvent::ObjectDestroy => Some(Self::Destroy(winevent, window)),
+            WinEvent::ObjectDestroy => Option::from(Self::Destroy(winevent, window)),

-            WinEvent::ObjectCloaked | WinEvent::ObjectHide => Some(Self::Hide(winevent, window)),
+            WinEvent::ObjectCloaked | WinEvent::ObjectHide => {
+                Option::from(Self::Hide(winevent, window))
+            }

-            WinEvent::SystemMinimizeStart => Some(Self::Minimize(winevent, window)),
+            WinEvent::SystemMinimizeStart => Option::from(Self::Minimize(winevent, window)),

            WinEvent::ObjectShow | WinEvent::ObjectUncloaked | WinEvent::SystemMinimizeEnd => {
-                Some(Self::Show(winevent, window))
+                Option::from(Self::Show(winevent, window))
            }

            WinEvent::ObjectFocus | WinEvent::SystemForeground => {
-                Some(Self::FocusChange(winevent, window))
+                Option::from(Self::FocusChange(winevent, window))
            }
-            WinEvent::SystemMoveSizeEnd => Some(Self::MoveResizeEnd(winevent, window)),
+            WinEvent::SystemMoveSizeEnd => Option::from(Self::MoveResizeEnd(winevent, window)),
            WinEvent::SystemCaptureStart | WinEvent::SystemCaptureEnd => {
-                Some(Self::MouseCapture(winevent, window))
+                Option::from(Self::MouseCapture(winevent, window))
+            }
+            WinEvent::ObjectNameChange => {
+                // Some apps like Firefox don't send ObjectCreate or ObjectShow on launch
+                // This spams the message queue, but I don't know what else to do. On launch
+                // it only sends the following WinEvents :/
+                //
+                // [yatta\src\windows_event.rs:110] event = 32780 ObjectNameChange
+                // [yatta\src\windows_event.rs:110] event = 32779 ObjectLocationChange
+
+                let object_name_change_on_launch = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
+
+                if object_name_change_on_launch.contains(&window.exe().ok()?) {
+                    Option::from(Self::Show(winevent, window))
+                } else {
+                    None
+                }
+            }
+            WinEvent::ObjectCreate => {
+                if let Ok(title) = window.title() {
+                    // Hidden COM support mechanism window that fires this event on both DPI/scaling
+                    // changes and resolution changes, a good candidate for polling
+                    if title == "OLEChannelWnd" {
+                        return Option::from(Self::MonitorPoll(winevent, window));
+                    }
+                }
+
+                None
            }
            _ => None,
        }
--- a/komorebi/src/windows_api.rs
+++ b/komorebi/src/windows_api.rs
@@ -3,9 +3,9 @@ use std::convert::TryFrom;
 use std::convert::TryInto;
 use std::ffi::c_void;

-use color_eyre::eyre::ContextCompat;
+use color_eyre::eyre::anyhow;
+use color_eyre::eyre::Error;
 use color_eyre::Result;
-use eyre::Error;

 use bindings::Windows::Win32::Foundation::BOOL;
 use bindings::Windows::Win32::Foundation::HANDLE;
@@ -23,6 +23,7 @@ use bindings::Windows::Win32::Graphics::Dwm::DWM_CLOAKED_INHERITED;
 use bindings::Windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
 use bindings::Windows::Win32::Graphics::Gdi::EnumDisplayMonitors;
 use bindings::Windows::Win32::Graphics::Gdi::GetMonitorInfoW;
+use bindings::Windows::Win32::Graphics::Gdi::MonitorFromPoint;
 use bindings::Windows::Win32::Graphics::Gdi::MonitorFromWindow;
 use bindings::Windows::Win32::Graphics::Gdi::HDC;
 use bindings::Windows::Win32::Graphics::Gdi::HMONITOR;
@@ -42,6 +43,7 @@ use bindings::Windows::Win32::UI::WindowsAndMessaging::AllowSetForegroundWindow;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::EnumWindows;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::GetCursorPos;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::GetDesktopWindow;
+use bindings::Windows::Win32::UI::WindowsAndMessaging::GetForegroundWindow;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::GetTopWindow;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::GetWindow;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW;
@@ -58,6 +60,7 @@ use bindings::Windows::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SetWindowPos;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SystemParametersInfoW;
+use bindings::Windows::Win32::UI::WindowsAndMessaging::WindowFromPoint;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::GW_HWNDNEXT;
@@ -66,8 +69,10 @@ use bindings::Windows::Win32::UI::WindowsAndMessaging::HWND_TOPMOST;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SET_WINDOW_POS_FLAGS;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SPIF_SENDCHANGE;
+use bindings::Windows::Win32::UI::WindowsAndMessaging::SPI_GETACTIVEWINDOWTRACKING;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SPI_SETACTIVEWINDOWTRACKING;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SW_HIDE;
+use bindings::Windows::Win32::UI::WindowsAndMessaging::SW_MAXIMIZE;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SW_RESTORE;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_ACTION;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS;
@@ -81,7 +86,6 @@ use crate::monitor::Monitor;
 use crate::ring::Ring;
 use crate::set_window_position::SetWindowPosition;
 use crate::windows_callbacks;
-use crate::workspace::Workspace;

 pub enum WindowsResult<T, E> {
    Err(E),
@@ -161,6 +165,17 @@ impl WindowsApi {
        }))
    }

+    pub fn valid_hmonitors() -> Result<Vec<isize>> {
+        let mut monitors: Vec<isize> = vec![];
+        let monitors_ref: &mut Vec<isize> = monitors.as_mut();
+        Self::enum_display_monitors(
+            windows_callbacks::valid_display_monitors,
+            monitors_ref as *mut Vec<isize> as isize,
+        )?;
+
+        Ok(monitors)
+    }
+
    pub fn load_monitor_information(monitors: &mut Ring<Monitor>) -> Result<()> {
        Self::enum_display_monitors(
            windows_callbacks::enum_display_monitor,
@@ -176,9 +191,8 @@ impl WindowsApi {

    pub fn load_workspace_information(monitors: &mut Ring<Monitor>) -> Result<()> {
        for monitor in monitors.elements_mut() {
-            if monitor.workspaces().is_empty() {
-                let mut workspace = Workspace::default();
-
+            let monitor_id = monitor.id();
+            if let Some(workspace) = monitor.workspaces_mut().front_mut() {
                // EnumWindows will enumerate through windows on all monitors
                Self::enum_windows(
                    windows_callbacks::enum_window,
@@ -195,7 +209,7 @@ impl WindowsApi {

                for container in workspace.containers_mut() {
                    for window in container.windows() {
-                        if Self::monitor_from_window(window.hwnd()) != monitor.id() {
+                        if Self::monitor_from_window(window.hwnd()) != monitor_id {
                            windows_on_other_monitors.push(window.hwnd().0);
                        }
                    }
@@ -204,8 +218,6 @@ impl WindowsApi {
                for hwnd in windows_on_other_monitors {
                    workspace.remove_window(hwnd)?;
                }
-
-                monitor.workspaces_mut().push_back(workspace);
            }
        }

@@ -224,6 +236,12 @@ impl WindowsApi {
        unsafe { MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST) }.0
    }

+    pub fn monitor_from_point(point: POINT) -> isize {
+        // MONITOR_DEFAULTTONEAREST ensures that the return value will never be NULL
+        // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-monitorfromwindow
+        unsafe { MonitorFromPoint(point, MONITOR_DEFAULTTONEAREST) }.0
+    }
+
    pub fn position_window(hwnd: HWND, layout: &Rect, top: bool) -> Result<()> {
        let flags = SetWindowPosition::NO_ACTIVATE;

@@ -259,6 +277,14 @@ impl WindowsApi {
        Self::show_window(hwnd, SW_RESTORE);
    }

+    pub fn maximize_window(hwnd: HWND) {
+        Self::show_window(hwnd, SW_MAXIMIZE);
+    }
+
+    pub fn foreground_window() -> Result<isize> {
+        Result::from(WindowsResult::from(unsafe { GetForegroundWindow() }))
+    }
+
    pub fn set_foreground_window(hwnd: HWND) -> Result<()> {
        match WindowsResult::from(unsafe { SetForegroundWindow(hwnd) }) {
            WindowsResult::Ok(_) => Ok(()),
@@ -275,6 +301,7 @@ impl WindowsApi {
        }
    }

+    #[allow(dead_code)]
    pub fn top_window() -> Result<isize> {
        Result::from(WindowsResult::from(unsafe { GetTopWindow(HWND::NULL).0 }))
    }
@@ -283,12 +310,14 @@ impl WindowsApi {
        Result::from(WindowsResult::from(unsafe { GetDesktopWindow() }))
    }

+    #[allow(dead_code)]
    pub fn next_window(hwnd: HWND) -> Result<isize> {
        Result::from(WindowsResult::from(unsafe {
            GetWindow(hwnd, GW_HWNDNEXT).0
        }))
    }

+    #[allow(dead_code)]
    pub fn top_visible_window() -> Result<isize> {
        let hwnd = Self::top_window()?;
        let mut next_hwnd = hwnd;
@@ -301,7 +330,7 @@ impl WindowsApi {
            next_hwnd = Self::next_window(HWND(next_hwnd))?;
        }

-        Err(eyre::anyhow!("could not find next window"))
+        Err(anyhow!("could not find next window"))
    }

    pub fn window_rect(hwnd: HWND) -> Result<Rect> {
@@ -328,6 +357,14 @@ impl WindowsApi {
        Ok(cursor_pos)
    }

+    pub fn window_from_point(point: POINT) -> Result<isize> {
+        Result::from(WindowsResult::from(unsafe { WindowFromPoint(point) }))
+    }
+
+    pub fn window_at_cursor_pos() -> Result<isize> {
+        Self::window_from_point(Self::cursor_pos()?)
+    }
+
    pub fn center_cursor_in_rect(rect: &Rect) -> Result<()> {
        Self::set_cursor_pos(rect.left + (rect.right / 2), rect.top + (rect.bottom / 2))
    }
@@ -450,7 +487,7 @@ impl WindowsApi {
        Ok(Self::exe_path(handle)?
            .split('\\')
            .last()
-            .context("there is no last element")?
+            .ok_or_else(|| anyhow!("there is no last element"))?
            .to_string())
    }

@@ -523,16 +560,17 @@ impl WindowsApi {
        Ok(monitor_info)
    }

-    pub fn monitor(hmonitor: HMONITOR) -> Result<Monitor> {
-        let monitor_info = Self::monitor_info_w(hmonitor)?;
+    pub fn monitor(hmonitor: isize) -> Result<Monitor> {
+        let monitor_info = Self::monitor_info_w(HMONITOR(hmonitor))?;

        Ok(monitor::new(
-            hmonitor.0,
+            hmonitor,
            monitor_info.rcMonitor.into(),
            monitor_info.rcWork.into(),
        ))
    }

+    #[allow(dead_code)]
    pub fn system_parameters_info_w(
        action: SYSTEM_PARAMETERS_INFO_ACTION,
        ui_param: u32,
@@ -544,6 +582,21 @@ impl WindowsApi {
        }))
    }

+    #[allow(dead_code)]
+    pub fn focus_follows_mouse() -> Result<bool> {
+        let mut is_enabled: BOOL = unsafe { std::mem::zeroed() };
+
+        Self::system_parameters_info_w(
+            SPI_GETACTIVEWINDOWTRACKING,
+            0,
+            (&mut is_enabled as *mut BOOL).cast(),
+            SPIF_SENDCHANGE,
+        )?;
+
+        Ok(is_enabled.into())
+    }
+
+    #[allow(dead_code)]
    pub fn enable_focus_follows_mouse() -> Result<()> {
        Self::system_parameters_info_w(
            SPI_SETACTIVEWINDOWTRACKING,
@@ -553,6 +606,7 @@ impl WindowsApi {
        )
    }

+    #[allow(dead_code)]
    pub fn disable_focus_follows_mouse() -> Result<()> {
        Self::system_parameters_info_w(
            SPI_SETACTIVEWINDOWTRACKING,
--- a/komorebi/src/windows_callbacks.rs
+++ b/komorebi/src/windows_callbacks.rs
@@ -14,9 +14,18 @@ use crate::ring::Ring;
 use crate::window::Window;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
-use crate::winevent::WinEvent;
 use crate::winevent_listener::WINEVENT_CALLBACK_CHANNEL;
-use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
+
+pub extern "system" fn valid_display_monitors(
+    hmonitor: HMONITOR,
+    _: HDC,
+    _: *mut RECT,
+    lparam: LPARAM,
+) -> BOOL {
+    let monitors = unsafe { &mut *(lparam.0 as *mut Vec<isize>) };
+    monitors.push(hmonitor.0);
+    true.into()
+}

 pub extern "system" fn enum_display_monitor(
    hmonitor: HMONITOR,
@@ -25,7 +34,15 @@ pub extern "system" fn enum_display_monitor(
    lparam: LPARAM,
 ) -> BOOL {
    let monitors = unsafe { &mut *(lparam.0 as *mut Ring<Monitor>) };
-    if let Ok(m) = WindowsApi::monitor(hmonitor) {
+
+    // Don't duplicate a monitor that is already being managed
+    for monitor in monitors.elements() {
+        if monitor.id() == hmonitor.0 {
+            return true.into();
+        }
+    }
+
+    if let Ok(m) = WindowsApi::monitor(hmonitor.0) {
        monitors.elements_mut().push_back(m);
    }

@@ -71,37 +88,15 @@ pub extern "system" fn win_event_hook(
    let window = Window { hwnd: hwnd.0 };

    let winevent = unsafe { ::std::mem::transmute(event) };
-    let event_type = if let Some(event) = WindowManagerEvent::from_win_event(winevent, window) {
-        event
-    } else {
-        // Some apps like Firefox don't send ObjectCreate or ObjectShow on launch
-        // This spams the message queue, but I don't know what else to do. On launch
-        // it only sends the following WinEvents :/
-        //
-        // [yatta\src\windows_event.rs:110] event = 32780 ObjectNameChange
-        // [yatta\src\windows_event.rs:110] event = 32779 ObjectLocationChange
-        let object_name_change_on_launch = OBJECT_NAME_CHANGE_ON_LAUNCH.lock().unwrap();
-
-        if let Ok(exe) = window.exe() {
-            if winevent == WinEvent::ObjectNameChange {
-                if object_name_change_on_launch.contains(&exe) {
-                    WindowManagerEvent::Show(winevent, window)
-                } else {
-                    return;
-                }
-            } else {
-                return;
-            }
-        } else {
-            return;
-        }
+    let event_type = match WindowManagerEvent::from_win_event(winevent, window) {
+        None => return,
+        Some(event) => event,
    };

    if let Ok(should_manage) = window.should_manage(Option::from(event_type)) {
        if should_manage {
            WINEVENT_CALLBACK_CHANNEL
                .lock()
-                .unwrap()
                .0
                .send(event_type)
                .expect("could not send message on WINEVENT_CALLBACK_CHANNEL");
--- a/komorebi/src/winevent_listener.rs
+++ b/komorebi/src/winevent_listener.rs
@@ -1,13 +1,13 @@
 use std::sync::atomic::AtomicIsize;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::sync::Mutex;
 use std::thread;
 use std::time::Duration;

 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use lazy_static::lazy_static;
+use parking_lot::Mutex;

 use bindings::Windows::Win32::Foundation::HWND;
 use bindings::Windows::Win32::UI::Accessibility::SetWinEventHook;
@@ -43,7 +43,7 @@ pub fn new(outgoing: Arc<Mutex<Sender<WindowManagerEvent>>>) -> WinEventListener
 impl WinEventListener {
    pub fn start(self) {
        let hook = self.hook.clone();
-        let outgoing = self.outgoing_events.lock().unwrap().clone();
+        let outgoing = self.outgoing_events.lock().clone();

        thread::spawn(move || unsafe {
            let hook_ref = SetWinEventHook(
@@ -61,7 +61,7 @@ impl WinEventListener {
            // The code in the callback doesn't work in its own loop, needs to be within
            // the MessageLoop callback for the winevent callback to even fire
            MessageLoop::start(10, |_msg| {
-                if let Ok(event) = WINEVENT_CALLBACK_CHANNEL.lock().unwrap().1.try_recv() {
+                if let Ok(event) = WINEVENT_CALLBACK_CHANNEL.lock().1.try_recv() {
                    match outgoing.send(event) {
                        Ok(_) => {}
                        Err(error) => {
--- a/komorebi/src/workspace.rs
+++ b/komorebi/src/workspace.rs
@@ -1,6 +1,7 @@
 use std::collections::VecDeque;
 use std::num::NonZeroUsize;

+use color_eyre::eyre::anyhow;
 use color_eyre::eyre::ContextCompat;
 use color_eyre::Result;
 use getset::CopyGetters;
@@ -9,8 +10,8 @@ use getset::MutGetters;
 use getset::Setters;
 use serde::Serialize;

+use komorebi_core::Flip;
 use komorebi_core::Layout;
-use komorebi_core::LayoutFlip;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;

@@ -28,13 +29,18 @@ pub struct Workspace {
    monocle_container: Option<Container>,
    #[serde(skip_serializing)]
    #[getset(get_copy = "pub", set = "pub")]
-    monocle_restore_idx: Option<usize>,
+    monocle_container_restore_idx: Option<usize>,
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
+    maximized_window: Option<Window>,
+    #[serde(skip_serializing)]
+    #[getset(get_copy = "pub", set = "pub")]
+    maximized_window_restore_idx: Option<usize>,
    #[getset(get = "pub", get_mut = "pub")]
    floating_windows: Vec<Window>,
    #[getset(get_copy = "pub", set = "pub")]
    layout: Layout,
    #[getset(get_copy = "pub", set = "pub")]
-    layout_flip: Option<LayoutFlip>,
+    layout_flip: Option<Flip>,
    #[getset(get_copy = "pub", set = "pub")]
    workspace_padding: Option<i32>,
    #[getset(get_copy = "pub", set = "pub")]
@@ -57,7 +63,9 @@ impl Default for Workspace {
            name: None,
            containers: Ring::default(),
            monocle_container: None,
-            monocle_restore_idx: None,
+            maximized_window: None,
+            maximized_window_restore_idx: None,
+            monocle_container_restore_idx: None,
            floating_windows: Vec::default(),
            layout: Layout::BSP,
            layout_flip: None,
@@ -77,6 +85,20 @@ impl Workspace {
                window.hide();
            }
        }
+
+        if let Some(window) = self.maximized_window() {
+            window.hide();
+        }
+
+        if let Some(container) = self.monocle_container_mut() {
+            for window in container.windows_mut() {
+                window.hide();
+            }
+        }
+
+        for window in self.floating_windows() {
+            window.hide();
+        }
    }

    pub fn restore(&mut self) -> Result<()> {
@@ -87,20 +109,37 @@ impl Workspace {
                window.restore();

                if idx == i {
-                    to_focus = Option::from(window);
+                    to_focus = Option::from(*window);
                }
            }
        }

+        if let Some(window) = self.maximized_window() {
+            window.maximize();
+        }
+
+        if let Some(container) = self.monocle_container_mut() {
+            for window in container.windows_mut() {
+                window.restore();
+            }
+        }
+
+        for window in self.floating_windows() {
+            window.restore();
+        }
+
        // Do this here to make sure that an error doesn't stop the restoration of other windows
+        // Maximised windows should always be drawn at the top of the Z order
        if let Some(window) = to_focus {
-            window.focus()?;
+            if self.maximized_window().is_none() {
+                window.focus()?;
+            }
        }

        Ok(())
    }

-    pub fn update(&mut self, work_area: &Rect) -> Result<()> {
+    pub fn update(&mut self, work_area: &Rect, invisible_borders: &Rect) -> Result<()> {
        let mut adjusted_work_area = *work_area;
        adjusted_work_area.add_padding(self.workspace_padding());

@@ -109,8 +148,10 @@ impl Workspace {
        if *self.tile() {
            if let Some(container) = self.monocle_container_mut() {
                if let Some(window) = container.focused_window_mut() {
-                    window.set_position(&adjusted_work_area, true)?;
-                }
+                    window.set_position(&adjusted_work_area, invisible_borders, true)?;
+                };
+            } else if let Some(window) = self.maximized_window_mut() {
+                window.maximize();
            } else if !self.containers().is_empty() {
                let layouts = self.layout().calculate(
                    &adjusted_work_area,
@@ -125,7 +166,7 @@ impl Workspace {
                let windows = self.visible_windows_mut();
                for (i, window) in windows.into_iter().enumerate() {
                    if let (Some(window), Some(layout)) = (window, layouts.get(i)) {
-                        window.set_position(layout, false)?;
+                        window.set_position(layout, invisible_borders, false)?;
                    }
                }

@@ -189,16 +230,16 @@ impl Workspace {
    pub fn focus_container_by_window(&mut self, hwnd: isize) -> Result<()> {
        let container_idx = self
            .container_idx_for_window(hwnd)
-            .context("there is no container/window")?;
+            .ok_or_else(|| anyhow!("there is no container/window"))?;

        let container = self
            .containers_mut()
            .get_mut(container_idx)
-            .context("there is no container")?;
+            .ok_or_else(|| anyhow!("there is no container"))?;

        let window_idx = container
            .idx_for_window(hwnd)
-            .context("there is no window")?;
+            .ok_or_else(|| anyhow!("there is no window"))?;

        container.focus_window(window_idx);
        self.focus_container(container_idx);
@@ -222,9 +263,59 @@ impl Workspace {
        idx
    }

+    pub fn hwnd_from_exe(&self, exe: &str) -> Option<isize> {
+        for container in self.containers() {
+            if let Some(hwnd) = container.hwnd_from_exe(exe) {
+                return Option::from(hwnd);
+            }
+        }
+
+        if let Some(window) = self.maximized_window() {
+            if let Ok(window_exe) = window.exe() {
+                if exe == window_exe {
+                    return Option::from(window.hwnd);
+                }
+            }
+        }
+
+        if let Some(container) = self.monocle_container() {
+            if let Some(hwnd) = container.hwnd_from_exe(exe) {
+                return Option::from(hwnd);
+            }
+        }
+
+        for window in self.floating_windows() {
+            if let Ok(window_exe) = window.exe() {
+                if exe == window_exe {
+                    return Option::from(window.hwnd);
+                }
+            }
+        }
+
+        None
+    }
+
    pub fn contains_window(&self, hwnd: isize) -> bool {
-        for x in self.containers() {
-            if x.contains_window(hwnd) {
+        for container in self.containers() {
+            if container.contains_window(hwnd) {
+                return true;
+            }
+        }
+
+        if let Some(window) = self.maximized_window() {
+            if hwnd == window.hwnd {
+                return true;
+            }
+        }
+
+        if let Some(container) = self.monocle_container() {
+            if container.contains_window(hwnd) {
+                return true;
+            }
+        }
+
+        for window in self.floating_windows() {
+            if hwnd == window.hwnd {
                return true;
            }
        }
@@ -235,7 +326,7 @@ impl Workspace {
    pub fn promote_container(&mut self) -> Result<()> {
        let container = self
            .remove_focused_container()
-            .context("there is no container")?;
+            .ok_or_else(|| anyhow!("there is no container"))?;
        self.containers_mut().push_front(container);
        self.resize_dimensions_mut().insert(0, None);
        self.focus_container(0);
@@ -245,7 +336,7 @@ impl Workspace {

    pub fn add_container(&mut self, container: Container) {
        self.containers_mut().push_back(container);
-        self.focus_container(self.containers().len() - 1);
+        self.focus_last_container();
    }

    fn remove_container_by_idx(&mut self, idx: usize) -> Option<Container> {
@@ -270,29 +361,56 @@ impl Workspace {
            return Ok(());
        }

+        if let Some(container) = self.monocle_container_mut() {
+            if let Some(window_idx) = container
+                .windows()
+                .iter()
+                .position(|window| window.hwnd == hwnd)
+            {
+                container
+                    .remove_window_by_idx(window_idx)
+                    .ok_or_else(|| anyhow!("there is no window"))?;
+
+                if container.windows().is_empty() {
+                    self.set_monocle_container(None);
+                    self.set_monocle_container_restore_idx(None);
+                }
+
+                return Ok(());
+            }
+        }
+
+        if let Some(window) = self.maximized_window() {
+            if window.hwnd == hwnd {
+                self.set_maximized_window(None);
+                self.set_maximized_window_restore_idx(None);
+                return Ok(());
+            }
+        }
+
        let container_idx = self
            .container_idx_for_window(hwnd)
-            .context("there is no window")?;
+            .ok_or_else(|| anyhow!("there is no window"))?;

        let container = self
            .containers_mut()
            .get_mut(container_idx)
-            .context("there is no container")?;
+            .ok_or_else(|| anyhow!("there is no container"))?;

        let window_idx = container
            .windows()
            .iter()
            .position(|window| window.hwnd == hwnd)
-            .context("there is no window")?;
+            .ok_or_else(|| anyhow!("there is no window"))?;

        container
            .remove_window_by_idx(window_idx)
-            .context("there is no window")?;
+            .ok_or_else(|| anyhow!("there is no window"))?;

        if container.windows().is_empty() {
            self.containers_mut()
                .remove(container_idx)
-                .context("there is no container")?;
+                .ok_or_else(|| anyhow!("there is no container"))?;

            // Whenever a container is empty, we need to remove any resize dimensions for it too
            if self.resize_dimensions().get(container_idx).is_some() {
@@ -300,9 +418,7 @@ impl Workspace {
            }
        }

-        if container_idx != 0 {
-            self.focus_container(container_idx - 1);
-        }
+        self.focus_previous_container();

        Ok(())
    }
@@ -310,10 +426,7 @@ impl Workspace {
    pub fn remove_focused_container(&mut self) -> Option<Container> {
        let focused_idx = self.focused_container_idx();
        let container = self.remove_container_by_idx(focused_idx);
-
-        if focused_idx != 0 {
-            self.focus_container(focused_idx - 1);
-        }
+        self.focus_previous_container();

        container
    }
@@ -340,11 +453,11 @@ impl Workspace {

        let container = self
            .focused_container_mut()
-            .context("there is no container")?;
+            .ok_or_else(|| anyhow!("there is no container"))?;

        let window = container
            .remove_focused_window()
-            .context("there is no window")?;
+            .ok_or_else(|| anyhow!("there is no window"))?;

        // This is a little messy
        let adjusted_target_container_index = if container.windows().is_empty() {
@@ -364,13 +477,13 @@ impl Workspace {
        let target_container = self
            .containers_mut()
            .get_mut(adjusted_target_container_index)
-            .context("there is no container")?;
+            .ok_or_else(|| anyhow!("there is no container"))?;

        target_container.add_window(window);

        self.focus_container(adjusted_target_container_index);
        self.focused_container_mut()
-            .context("there is no container")?
+            .ok_or_else(|| anyhow!("there is no container"))?
            .load_focused_window();

        Ok(())
@@ -381,11 +494,11 @@ impl Workspace {

        let container = self
            .focused_container_mut()
-            .context("there is no container")?;
+            .ok_or_else(|| anyhow!("there is no container"))?;

        let window = container
            .remove_focused_window()
-            .context("there is no window")?;
+            .ok_or_else(|| anyhow!("there is no window"))?;

        if container.windows().is_empty() {
            self.containers_mut().remove(focused_container_idx);
@@ -405,7 +518,7 @@ impl Workspace {
        let focused_idx = self.focused_container_idx();
        let window = self
            .remove_focused_floating_window()
-            .context("there is no floating window")?;
+            .ok_or_else(|| anyhow!("there is no floating window"))?;

        let mut container = Container::default();
        container.add_window(window);
@@ -416,7 +529,11 @@ impl Workspace {
    }

    pub fn new_container_for_window(&mut self, window: Window) {
-        let next_idx = self.focused_container_idx() + 1;
+        let next_idx = if self.containers().is_empty() {
+            0
+        } else {
+            self.focused_container_idx() + 1
+        };

        let mut container = Container::default();
        container.add_window(window);
@@ -441,11 +558,11 @@ impl Workspace {

        let container = self
            .focused_container_mut()
-            .context("there is no container")?;
+            .ok_or_else(|| anyhow!("there is no container"))?;

        let window = container
            .remove_focused_window()
-            .context("there is no window")?;
+            .ok_or_else(|| anyhow!("there is no window"))?;

        if container.windows().is_empty() {
            self.containers_mut().remove(focused_idx);
@@ -490,22 +607,19 @@ impl Workspace {
        let container = self
            .containers_mut()
            .remove(focused_idx)
-            .context("there is not container")?;
+            .ok_or_else(|| anyhow!("there is no container"))?;

        // We don't remove any resize adjustments for a monocle, because when this container is
        // inevitably reintegrated, it would be weird if it doesn't go back to the dimensions
        // it had before

        self.set_monocle_container(Option::from(container));
-        self.set_monocle_restore_idx(Option::from(focused_idx));
-
-        if focused_idx != 0 {
-            self.focus_container(focused_idx - 1);
-        }
+        self.set_monocle_container_restore_idx(Option::from(focused_idx));
+        self.focus_previous_container();

        self.monocle_container_mut()
            .as_mut()
-            .context("there is no monocle container")?
+            .ok_or_else(|| anyhow!("there is no monocle container"))?
            .load_focused_window();

        Ok(())
@@ -513,13 +627,13 @@ impl Workspace {

    pub fn reintegrate_monocle_container(&mut self) -> Result<()> {
        let restore_idx = self
-            .monocle_restore_idx()
-            .context("there is no monocle restore index")?;
+            .monocle_container_restore_idx()
+            .ok_or_else(|| anyhow!("there is no monocle restore index"))?;

        let container = self
            .monocle_container_mut()
            .as_ref()
-            .context("there is no monocle container")?;
+            .ok_or_else(|| anyhow!("there is no monocle container"))?;

        let container = container.clone();
        if restore_idx > self.containers().len() - 1 {
@@ -530,10 +644,73 @@ impl Workspace {
        self.containers_mut().insert(restore_idx, container);
        self.focus_container(restore_idx);
        self.focused_container_mut()
-            .context("there is no container")?
+            .ok_or_else(|| anyhow!("there is no container"))?
            .load_focused_window();

        self.set_monocle_container(None);
+        self.set_monocle_container_restore_idx(None);
+
+        Ok(())
+    }
+
+    pub fn new_maximized_window(&mut self) -> Result<()> {
+        let focused_idx = self.focused_container_idx();
+
+        let container = self
+            .focused_container_mut()
+            .ok_or_else(|| anyhow!("there is no container"))?;
+
+        let window = container
+            .remove_focused_window()
+            .ok_or_else(|| anyhow!("there is no window"))?;
+
+        if container.windows().is_empty() {
+            self.containers_mut().remove(focused_idx);
+            self.resize_dimensions_mut().remove(focused_idx);
+        } else {
+            container.load_focused_window();
+        }
+
+        self.set_maximized_window(Option::from(window));
+        self.set_maximized_window_restore_idx(Option::from(focused_idx));
+
+        if let Some(window) = self.maximized_window() {
+            window.maximize();
+        }
+
+        self.focus_previous_container();
+
+        Ok(())
+    }
+
+    pub fn reintegrate_maximized_window(&mut self) -> Result<()> {
+        let restore_idx = self
+            .maximized_window_restore_idx()
+            .ok_or_else(|| anyhow!("there is no monocle restore index"))?;
+
+        let window = self
+            .maximized_window()
+            .as_ref()
+            .ok_or_else(|| anyhow!("there is no monocle container"))?;
+
+        let window = *window;
+        if !self.containers().is_empty() && restore_idx > self.containers().len() - 1 {
+            self.containers_mut()
+                .resize(restore_idx, Container::default());
+        }
+
+        let mut container = Container::default();
+        container.windows_mut().push_back(window);
+        self.containers_mut().insert(restore_idx, container);
+
+        self.focus_container(restore_idx);
+
+        self.focused_container_mut()
+            .ok_or_else(|| anyhow!("there is no container"))?
+            .load_focused_window();
+
+        self.set_maximized_window(None);
+        self.set_maximized_window_restore_idx(None);

        Ok(())
    }
@@ -551,7 +728,7 @@ impl Workspace {
    }

    pub fn remove_focused_floating_window(&mut self) -> Option<Window> {
-        let hwnd = WindowsApi::top_visible_window().ok()?;
+        let hwnd = WindowsApi::foreground_window().ok()?;

        let mut idx = None;
        for (i, window) in self.floating_windows.iter().enumerate() {
@@ -572,6 +749,15 @@ impl Workspace {
        }
    }

+    pub fn visible_windows(&self) -> Vec<Option<&Window>> {
+        let mut vec = vec![];
+        for container in self.containers() {
+            vec.push(container.focused_window());
+        }
+
+        vec
+    }
+
    pub fn visible_windows_mut(&mut self) -> Vec<Option<&mut Window>> {
        let mut vec = vec![];
        for container in self.containers_mut() {
@@ -580,4 +766,16 @@ impl Workspace {

        vec
    }
+
+    fn focus_previous_container(&mut self) {
+        let focused_idx = self.focused_container_idx();
+
+        if focused_idx != 0 {
+            self.focus_container(focused_idx - 1);
+        }
+    }
+
+    fn focus_last_container(&mut self) {
+        self.focus_container(self.containers().len() - 1);
+    }
 }
--- a/komorebic.lib.sample.ahk
+++ b/komorebic.lib.sample.ahk
@@ -0,0 +1,197 @@
+; Generated by komorebic.exe
+
+Start(ffm) {
+    Run, komorebic.exe start  --ffm %ffm%, , Hide
+}
+
+Stop() {
+    Run, komorebic.exe stop, , Hide
+}
+
+State() {
+    Run, komorebic.exe state, , Hide
+}
+
+Query(state_query) {
+    Run, komorebic.exe query %state_query%, , Hide
+}
+
+Log() {
+    Run, komorebic.exe log, , Hide
+}
+
+Focus(operation_direction) {
+    Run, komorebic.exe focus %operation_direction%, , Hide
+}
+
+Move(operation_direction) {
+    Run, komorebic.exe move %operation_direction%, , Hide
+}
+
+Stack(operation_direction) {
+    Run, komorebic.exe stack %operation_direction%, , Hide
+}
+
+Resize(edge, sizing) {
+    Run, komorebic.exe resize %edge% %sizing%, , Hide
+}
+
+Unstack() {
+    Run, komorebic.exe unstack, , Hide
+}
+
+CycleStack(cycle_direction) {
+    Run, komorebic.exe cycle-stack %cycle_direction%, , Hide
+}
+
+MoveToMonitor(target) {
+    Run, komorebic.exe move-to-monitor %target%, , Hide
+}
+
+MoveToWorkspace(target) {
+    Run, komorebic.exe move-to-workspace %target%, , Hide
+}
+
+SendToMonitor(target) {
+    Run, komorebic.exe send-to-monitor %target%, , Hide
+}
+
+SendToWorkspace(target) {
+    Run, komorebic.exe send-to-workspace %target%, , Hide
+}
+
+FocusMonitor(target) {
+    Run, komorebic.exe focus-monitor %target%, , Hide
+}
+
+FocusWorkspace(target) {
+    Run, komorebic.exe focus-workspace %target%, , Hide
+}
+
+NewWorkspace() {
+    Run, komorebic.exe new-workspace, , Hide
+}
+
+InvisibleBorders(left, top, right, bottom) {
+    Run, komorebic.exe invisible-borders %left% %top% %right% %bottom%, , Hide
+}
+
+AdjustContainerPadding(sizing, adjustment) {
+    Run, komorebic.exe adjust-container-padding %sizing% %adjustment%, , Hide
+}
+
+AdjustWorkspacePadding(sizing, adjustment) {
+    Run, komorebic.exe adjust-workspace-padding %sizing% %adjustment%, , Hide
+}
+
+ChangeLayout(layout) {
+    Run, komorebic.exe change-layout %layout%, , Hide
+}
+
+FlipLayout(flip) {
+    Run, komorebic.exe flip-layout %flip%, , Hide
+}
+
+Promote() {
+    Run, komorebic.exe promote, , Hide
+}
+
+Retile() {
+    Run, komorebic.exe retile, , Hide
+}
+
+EnsureWorkspaces(monitor, workspace_count) {
+    Run, komorebic.exe ensure-workspaces %monitor% %workspace_count%, , Hide
+}
+
+ContainerPadding(monitor, workspace, size) {
+    Run, komorebic.exe container-padding %monitor% %workspace% %size%, , Hide
+}
+
+WorkspacePadding(monitor, workspace, size) {
+    Run, komorebic.exe workspace-padding %monitor% %workspace% %size%, , Hide
+}
+
+WorkspaceLayout(monitor, workspace, value) {
+    Run, komorebic.exe workspace-layout %monitor% %workspace% %value%, , Hide
+}
+
+WorkspaceTiling(monitor, workspace, value) {
+    Run, komorebic.exe workspace-tiling %monitor% %workspace% %value%, , Hide
+}
+
+WorkspaceName(monitor, workspace, value) {
+    Run, komorebic.exe workspace-name %monitor% %workspace% %value%, , Hide
+}
+
+TogglePause() {
+    Run, komorebic.exe toggle-pause, , Hide
+}
+
+ToggleTiling() {
+    Run, komorebic.exe toggle-tiling, , Hide
+}
+
+ToggleFloat() {
+    Run, komorebic.exe toggle-float, , Hide
+}
+
+ToggleMonocle() {
+    Run, komorebic.exe toggle-monocle, , Hide
+}
+
+ToggleMaximize() {
+    Run, komorebic.exe toggle-maximize, , Hide
+}
+
+RestoreWindows() {
+    Run, komorebic.exe restore-windows, , Hide
+}
+
+Manage() {
+    Run, komorebic.exe manage, , Hide
+}
+
+Unmanage() {
+    Run, komorebic.exe unmanage, , Hide
+}
+
+ReloadConfiguration() {
+    Run, komorebic.exe reload-configuration, , Hide
+}
+
+WatchConfiguration(boolean_state) {
+    Run, komorebic.exe watch-configuration %boolean_state%, , Hide
+}
+
+FloatRule(identifier, id) {
+    Run, komorebic.exe float-rule %identifier% %id%, , Hide
+}
+
+ManageRule(identifier, id) {
+    Run, komorebic.exe manage-rule %identifier% %id%, , Hide
+}
+
+WorkspaceRule(identifier, id, monitor, workspace) {
+    Run, komorebic.exe workspace-rule %identifier% %id% %monitor% %workspace%, , Hide
+}
+
+IdentifyTrayApplication(identifier, id) {
+    Run, komorebic.exe identify-tray-application %identifier% %id%, , Hide
+}
+
+IdentifyBorderOverflow(identifier, id) {
+    Run, komorebic.exe identify-border-overflow %identifier% %id%, , Hide
+}
+
+FocusFollowsMouse(boolean_state, implementation) {
+    Run, komorebic.exe focus-follows-mouse %boolean_state% --implementation %implementation%, , Hide
+}
+
+ToggleFocusFollowsMouse(implementation) {
+    Run, komorebic.exe toggle-focus-follows-mouse  --implementation %implementation%, , Hide
+}
+
+AhkLibrary() {
+    Run, komorebic.exe ahk-library, , Hide
+}
--- a/komorebic/Cargo.toml
+++ b/komorebic/Cargo.toml
@@ -1,19 +1,27 @@
 [package]
 name = "komorebic"
-version = "0.1.0"
+version = "0.1.4"
+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 = "2018"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [dependencies]
 bindings = { package = "bindings", path = "../bindings" }
+derive-ahk = { path = "../derive-ahk" }
 komorebi-core = { path = "../komorebi-core" }

 clap = "3.0.0-beta.4"
 color-eyre = "0.5"
 dirs = "3"
+fs-tail = "0.1"
+heck = "0.3"
 paste = "1"
 powershell_script = "0.2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-uds_windows = "1"
+uds_windows = "1"
--- a/komorebic/src/main.rs
+++ b/komorebic/src/main.rs
@@ -1,4 +1,8 @@
+#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
+#![allow(clippy::missing_errors_doc)]
+
 use std::fs::File;
+use std::fs::OpenOptions;
 use std::io::BufRead;
 use std::io::BufReader;
 use std::io::ErrorKind;
@@ -11,6 +15,8 @@ use clap::ArgEnum;
 use clap::Clap;
 use color_eyre::eyre::ContextCompat;
 use color_eyre::Result;
+use fs_tail::TailedFile;
+use heck::KebabCase;
 use paste::paste;
 use uds_windows::UnixListener;
 use uds_windows::UnixStream;
@@ -19,13 +25,26 @@ use bindings::Windows::Win32::Foundation::HWND;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SHOW_WINDOW_CMD;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::SW_RESTORE;
+use derive_ahk::AhkFunction;
+use derive_ahk::AhkLibrary;
 use komorebi_core::ApplicationIdentifier;
 use komorebi_core::CycleDirection;
+use komorebi_core::Flip;
+use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::Layout;
-use komorebi_core::LayoutFlip;
 use komorebi_core::OperationDirection;
+use komorebi_core::Rect;
 use komorebi_core::Sizing;
 use komorebi_core::SocketMessage;
+use komorebi_core::StateQuery;
+
+trait AhkLibrary {
+    fn generate_ahk_library() -> String;
+}
+
+trait AhkFunction {
+    fn generate_ahk_function() -> String;
+}

 #[derive(ArgEnum)]
 enum BooleanState {
@@ -44,10 +63,10 @@ impl From<BooleanState> for bool {

 macro_rules! gen_enum_subcommand_args {
    // SubCommand Pattern: Enum Type
-    ( $( $name:ident: $element:ty ),+ ) => {
+    ( $( $name:ident: $element:ty ),+ $(,)? ) => {
        $(
            paste! {
-                #[derive(clap::Clap)]
+                #[derive(clap::Clap, derive_ahk::AhkFunction)]
                pub struct $name {
                    #[clap(arg_enum)]
                    [<$element:snake>]: $element
@@ -62,16 +81,17 @@ gen_enum_subcommand_args! {
    Move: OperationDirection,
    Stack: OperationDirection,
    CycleStack: CycleDirection,
-    FlipLayout: LayoutFlip,
+    FlipLayout: Flip,
+    ChangeLayout: Layout,
    WatchConfiguration: BooleanState,
-    FocusFollowsMouse: BooleanState
+    Query: StateQuery,
 }

 macro_rules! gen_target_subcommand_args {
    // SubCommand Pattern
-    ( $( $name:ident ),+ ) => {
+    ( $( $name:ident ),+ $(,)? ) => {
        $(
-            #[derive(clap::Clap)]
+            #[derive(clap::Clap, derive_ahk::AhkFunction)]
            pub struct $name {
                /// Target index (zero-indexed)
                target: usize,
@@ -83,8 +103,10 @@ macro_rules! gen_target_subcommand_args {
 gen_target_subcommand_args! {
    MoveToMonitor,
    MoveToWorkspace,
+    SendToMonitor,
+    SendToWorkspace,
    FocusMonitor,
-    FocusWorkspace
+    FocusWorkspace,
 }

 // Thanks to @danielhenrymantilla for showing me how to use cfg_attr with an optional argument like
@@ -92,10 +114,10 @@ gen_target_subcommand_args! {
 macro_rules! gen_workspace_subcommand_args {
    // Workspace Property: #[enum] Value Enum (if the value is an Enum)
    // Workspace Property: Value Type (if the value is anything else)
-    ( $( $name:ident: $(#[enum] $(@$arg_enum:tt)?)? $value:ty ),+ ) => (
+    ( $( $name:ident: $(#[enum] $(@$arg_enum:tt)?)? $value:ty ),+ $(,)? ) => (
        paste! {
            $(
-                #[derive(clap::Clap)]
+                #[derive(clap::Clap, derive_ahk::AhkFunction)]
                pub struct [<Workspace $name>] {
                    /// Monitor index (zero-indexed)
                    monitor: usize,
@@ -118,10 +140,10 @@ macro_rules! gen_workspace_subcommand_args {
 gen_workspace_subcommand_args! {
    Name: String,
    Layout: #[enum] Layout,
-    Tiling: #[enum] BooleanState
+    Tiling: #[enum] BooleanState,
 }

-#[derive(Clap)]
+#[derive(Clap, AhkFunction)]
 struct Resize {
    #[clap(arg_enum)]
    edge: OperationDirection,
@@ -129,7 +151,19 @@ struct Resize {
    sizing: Sizing,
 }

-#[derive(Clap)]
+#[derive(Clap, AhkFunction)]
+struct InvisibleBorders {
+    /// Size of the left invisible border
+    left: i32,
+    /// Size of the top invisible border (usually 0)
+    top: i32,
+    /// Size of the right invisible border (usually left * 2)
+    right: i32,
+    /// Size of the bottom invisible border (usually the same as left)
+    bottom: i32,
+}
+
+#[derive(Clap, AhkFunction)]
 struct EnsureWorkspaces {
    /// Monitor index (zero-indexed)
    monitor: usize,
@@ -137,48 +171,123 @@ struct EnsureWorkspaces {
    workspace_count: usize,
 }

-#[derive(Clap)]
-struct Padding {
-    /// Monitor index (zero-indexed)
-    monitor: usize,
-    /// Workspace index on the specified monitor (zero-indexed)
-    workspace: usize,
-    /// Pixels to pad with as an integer
-    size: i32,
+macro_rules! gen_padding_subcommand_args {
+    // SubCommand Pattern
+    ( $( $name:ident ),+ $(,)? ) => {
+        $(
+            #[derive(clap::Clap, derive_ahk::AhkFunction)]
+            pub struct $name {
+                /// Monitor index (zero-indexed)
+                monitor: usize,
+                /// Workspace index on the specified monitor (zero-indexed)
+                workspace: usize,
+                /// Pixels to pad with as an integer
+                size: i32,
+            }
+        )+
+    };
 }

-#[derive(Clap)]
-struct PaddingAdjustment {
-    #[clap(arg_enum)]
-    sizing: Sizing,
-    /// Pixels to adjust by as an integer
-    adjustment: i32,
+gen_padding_subcommand_args! {
+    ContainerPadding,
+    WorkspacePadding,
 }

-#[derive(Clap)]
-struct ApplicationTarget {
+macro_rules! gen_padding_adjustment_subcommand_args {
+    // SubCommand Pattern
+    ( $( $name:ident ),+ $(,)? ) => {
+        $(
+            #[derive(clap::Clap, derive_ahk::AhkFunction)]
+            pub struct $name {
+                #[clap(arg_enum)]
+                sizing: Sizing,
+                /// Pixels to adjust by as an integer
+                adjustment: i32,
+            }
+        )+
+    };
+}
+
+gen_padding_adjustment_subcommand_args! {
+    AdjustContainerPadding,
+    AdjustWorkspacePadding,
+}
+
+macro_rules! gen_application_target_subcommand_args {
+    // SubCommand Pattern
+    ( $( $name:ident ),+ $(,)? ) => {
+        $(
+            #[derive(clap::Clap, derive_ahk::AhkFunction)]
+            pub struct $name {
+                #[clap(arg_enum)]
+                identifier: ApplicationIdentifier,
+                /// Identifier as a string
+                id: String,
+            }
+        )+
+    };
+}
+
+gen_application_target_subcommand_args! {
+    FloatRule,
+    ManageRule,
+    IdentifyTrayApplication,
+    IdentifyBorderOverflow,
+}
+
+#[derive(Clap, AhkFunction)]
+struct WorkspaceRule {
    #[clap(arg_enum)]
    identifier: ApplicationIdentifier,
    /// Identifier as a string
    id: String,
+    /// Monitor index (zero-indexed)
+    monitor: usize,
+    /// Workspace index on the specified monitor (zero-indexed)
+    workspace: usize,
+}
+
+#[derive(Clap, AhkFunction)]
+struct ToggleFocusFollowsMouse {
+    #[clap(arg_enum, short, long, default_value = "windows")]
+    implementation: FocusFollowsMouseImplementation,
+}
+
+#[derive(Clap, AhkFunction)]
+struct FocusFollowsMouse {
+    #[clap(arg_enum, short, long, default_value = "windows")]
+    implementation: FocusFollowsMouseImplementation,
+    #[clap(arg_enum)]
+    boolean_state: BooleanState,
+}
+
+#[derive(Clap, AhkFunction)]
+struct Start {
+    /// Allow the use of komorebi's custom focus-follows-mouse implementation
+    #[clap(long)]
+    ffm: bool,
 }

 #[derive(Clap)]
-#[clap(version = "0.1.0", author = "Jade Iqbal <jadeiqbal@fastmail.com>")]
-#[clap(setting = AppSettings::DeriveDisplayOrder)]
+#[clap(author, about, version, setting = AppSettings::DeriveDisplayOrder)]
 struct Opts {
    #[clap(subcommand)]
    subcmd: SubCommand,
 }

-#[derive(Clap)]
+#[derive(Clap, AhkLibrary)]
 enum SubCommand {
    /// Start komorebi.exe as a background process
-    Start,
+    Start(Start),
    /// Stop the komorebi.exe process and restore all hidden windows
    Stop,
    /// Show a JSON representation of the current window manager state
    State,
+    /// Query the current window manager state
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    Query(Query),
+    /// Tail komorebi.exe's process logs (cancel with Ctrl-C)
+    Log,
    /// Change focus to the window in the specified direction
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    Focus(Focus),
@@ -202,6 +311,12 @@ enum SubCommand {
    /// Move the focused window to the specified workspace
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    MoveToWorkspace(MoveToWorkspace),
+    /// Send the focused window to the specified monitor
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    SendToMonitor(SendToMonitor),
+    /// Send the focused window to the specified workspace
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    SendToWorkspace(SendToWorkspace),
    /// Focus the specified monitor
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    FocusMonitor(FocusMonitor),
@@ -210,13 +325,20 @@ enum SubCommand {
    FocusWorkspace(FocusWorkspace),
    /// Create and append a new workspace on the focused monitor
    NewWorkspace,
+    /// Set the invisible border dimensions around each window
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    InvisibleBorders(InvisibleBorders),
    /// Adjust container padding on the focused workspace
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
-    AdjustContainerPadding(PaddingAdjustment),
+    AdjustContainerPadding(AdjustContainerPadding),
    /// Adjust workspace padding on the focused workspace
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
-    AdjustWorkspacePadding(PaddingAdjustment),
+    AdjustWorkspacePadding(AdjustWorkspacePadding),
+    /// Set the layout on the focused workspace
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    ChangeLayout(ChangeLayout),
    /// Flip the layout on the focused workspace (BSP only)
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    FlipLayout(FlipLayout),
    /// Promote the focused window to the top of the tree
    Promote,
@@ -227,10 +349,10 @@ enum SubCommand {
    EnsureWorkspaces(EnsureWorkspaces),
    /// Set the container padding for the specified workspace
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
-    ContainerPadding(Padding),
+    ContainerPadding(ContainerPadding),
    /// Set the workspace padding for the specified workspace
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
-    WorkspacePadding(Padding),
+    WorkspacePadding(WorkspacePadding),
    /// Set the layout for the specified workspace
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    WorkspaceLayout(WorkspaceLayout),
@@ -248,21 +370,42 @@ enum SubCommand {
    ToggleFloat,
    /// Toggle monocle mode for the focused container
    ToggleMonocle,
+    /// Toggle native maximization for the focused window
+    ToggleMaximize,
    /// Restore all hidden windows (debugging command)
    RestoreWindows,
+    /// Force komorebi to manage the focused window
+    Manage,
+    /// Unmanage a window that was forcibly managed
+    Unmanage,
    /// Reload ~/komorebi.ahk (if it exists)
    ReloadConfiguration,
-    /// Toggle the automatic reloading of ~/komorebi.ahk (if it exists)
+    /// Enable or disable watching of ~/komorebi.ahk (if it exists)
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    WatchConfiguration(WatchConfiguration),
    /// Add a rule to always float the specified application
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
-    FloatRule(ApplicationTarget),
+    FloatRule(FloatRule),
+    /// Add a rule to always manage the specified application
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    ManageRule(ManageRule),
+    /// Add a rule to associate an application with a workspace
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    WorkspaceRule(WorkspaceRule),
    /// Identify an application that closes to the system tray
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
-    IdentifyTrayApplication(ApplicationTarget),
+    IdentifyTrayApplication(IdentifyTrayApplication),
+    /// Identify an application that has overflowing borders
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    IdentifyBorderOverflow(IdentifyBorderOverflow),
    /// Enable or disable focus follows mouse for the operating system
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    FocusFollowsMouse(FocusFollowsMouse),
+    /// Toggle focus follows mouse for the operating system
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    ToggleFocusFollowsMouse(ToggleFocusFollowsMouse),
+    /// Generate a library of AutoHotKey helper functions
+    AhkLibrary,
 }

 pub fn send_message(bytes: &[u8]) -> Result<()> {
@@ -274,10 +417,44 @@ pub fn send_message(bytes: &[u8]) -> Result<()> {
    Ok(stream.write_all(&*bytes)?)
 }

+#[allow(clippy::too_many_lines)]
 fn main() -> Result<()> {
    let opts: Opts = Opts::parse();

    match opts.subcmd {
+        SubCommand::AhkLibrary => {
+            let mut library = dirs::home_dir().context("there is no home directory")?;
+            library.push("komorebic.lib.ahk");
+            let mut file = OpenOptions::new()
+                .write(true)
+                .create(true)
+                .truncate(true)
+                .open(library.clone())?;
+
+            file.write_all(SubCommand::generate_ahk_library().as_bytes())?;
+
+            println!(
+                "\nAHK helper library for komorebic written to {}",
+                library
+                    .to_str()
+                    .context("could not find the path to the generated ahk lib file")?
+            );
+
+            println!(
+                "\nYou can include the library at the top of your ~/komorebi.ahk config with this line:"
+            );
+
+            println!("\n#Include %A_ScriptDir%\\komorebic.lib.ahk");
+        }
+        SubCommand::Log => {
+            let mut color_log = std::env::temp_dir();
+            color_log.push("komorebi.log");
+            let file = TailedFile::new(File::open(color_log)?);
+            let locked = file.lock();
+            for line in locked.lines() {
+                println!("{}", line?);
+            }
+        }
        SubCommand::Focus(arg) => {
            send_message(&*SocketMessage::FocusWindow(arg.operation_direction).as_bytes()?)?;
        }
@@ -299,6 +476,23 @@ fn main() -> Result<()> {
        SubCommand::MoveToWorkspace(arg) => {
            send_message(&*SocketMessage::MoveContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
        }
+        SubCommand::SendToMonitor(arg) => {
+            send_message(&*SocketMessage::SendContainerToMonitorNumber(arg.target).as_bytes()?)?;
+        }
+        SubCommand::SendToWorkspace(arg) => {
+            send_message(&*SocketMessage::SendContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
+        }
+        SubCommand::InvisibleBorders(arg) => {
+            send_message(
+                &*SocketMessage::InvisibleBorders(Rect {
+                    left: arg.left,
+                    top: arg.top,
+                    right: arg.right,
+                    bottom: arg.bottom,
+                })
+                .as_bytes()?,
+            )?;
+        }
        SubCommand::ContainerPadding(arg) => {
            send_message(
                &*SocketMessage::ContainerPadding(arg.monitor, arg.workspace, arg.size)
@@ -321,6 +515,9 @@ fn main() -> Result<()> {
                &*SocketMessage::AdjustContainerPadding(arg.sizing, arg.adjustment).as_bytes()?,
            )?;
        }
+        SubCommand::ToggleFocusFollowsMouse(arg) => {
+            send_message(&*SocketMessage::ToggleFocusFollowsMouse(arg.implementation).as_bytes()?)?;
+        }
        SubCommand::ToggleTiling => {
            send_message(&*SocketMessage::ToggleTiling.as_bytes()?)?;
        }
@@ -330,6 +527,9 @@ fn main() -> Result<()> {
        SubCommand::ToggleMonocle => {
            send_message(&*SocketMessage::ToggleMonocle.as_bytes()?)?;
        }
+        SubCommand::ToggleMaximize => {
+            send_message(&*SocketMessage::ToggleMaximize.as_bytes()?)?;
+        }
        SubCommand::WorkspaceLayout(arg) => {
            send_message(
                &*SocketMessage::WorkspaceLayout(arg.monitor, arg.workspace, arg.value)
@@ -342,7 +542,7 @@ fn main() -> Result<()> {
                    .as_bytes()?,
            )?;
        }
-        SubCommand::Start => {
+        SubCommand::Start(arg) => {
            let mut buf: PathBuf;

            // The komorebi.ps1 shim will only exist in the Path if installed by Scoop
@@ -365,11 +565,27 @@ fn main() -> Result<()> {
                None
            };

-            let script = if let Some(exec) = exec {
-                format!("Start-Process '{}' -WindowStyle hidden", exec)
-            } else {
-                String::from("Start-Process komorebi -WindowStyle hidden")
-            };
+            let script = exec.map_or_else(
+                || {
+                    if arg.ffm {
+                        String::from(
+                            "Start-Process komorebi.exe -ArgumentList '--ffm' -WindowStyle hidden",
+                        )
+                    } else {
+                        String::from("Start-Process komorebi.exe -WindowStyle hidden")
+                    }
+                },
+                |exec| {
+                    if arg.ffm {
+                        format!(
+                            "Start-Process '{}' -ArgumentList '--ffm' -WindowStyle hidden",
+                            exec
+                        )
+                    } else {
+                        format!("Start-Process '{}' -WindowStyle hidden", exec)
+                    }
+                },
+            );

            match powershell_script::run(&script, true) {
                Ok(output) => {
@@ -383,17 +599,18 @@ fn main() -> Result<()> {
        SubCommand::Stop => {
            send_message(&*SocketMessage::Stop.as_bytes()?)?;
        }
-        SubCommand::FloatRule(arg) => match arg.identifier {
-            ApplicationIdentifier::Exe => {
-                send_message(&*SocketMessage::FloatExe(arg.id).as_bytes()?)?;
-            }
-            ApplicationIdentifier::Class => {
-                send_message(&*SocketMessage::FloatClass(arg.id).as_bytes()?)?;
-            }
-            ApplicationIdentifier::Title => {
-                send_message(&*SocketMessage::FloatTitle(arg.id).as_bytes()?)?;
-            }
-        },
+        SubCommand::FloatRule(arg) => {
+            send_message(&*SocketMessage::FloatRule(arg.identifier, arg.id).as_bytes()?)?;
+        }
+        SubCommand::ManageRule(arg) => {
+            send_message(&*SocketMessage::ManageRule(arg.identifier, arg.id).as_bytes()?)?;
+        }
+        SubCommand::WorkspaceRule(arg) => {
+            send_message(
+                &*SocketMessage::WorkspaceRule(arg.identifier, arg.id, arg.monitor, arg.workspace)
+                    .as_bytes()?,
+            )?;
+        }
        SubCommand::Stack(arg) => {
            send_message(&*SocketMessage::StackWindow(arg.operation_direction).as_bytes()?)?;
        }
@@ -403,8 +620,11 @@ fn main() -> Result<()> {
        SubCommand::CycleStack(arg) => {
            send_message(&*SocketMessage::CycleStack(arg.cycle_direction).as_bytes()?)?;
        }
+        SubCommand::ChangeLayout(arg) => {
+            send_message(&*SocketMessage::ChangeLayout(arg.layout).as_bytes()?)?;
+        }
        SubCommand::FlipLayout(arg) => {
-            send_message(&*SocketMessage::FlipLayout(arg.layout_flip).as_bytes()?)?;
+            send_message(&*SocketMessage::FlipLayout(arg.flip).as_bytes()?)?;
        }
        SubCommand::FocusMonitor(arg) => {
            send_message(&*SocketMessage::FocusMonitorNumber(arg.target).as_bytes()?)?;
@@ -451,13 +671,47 @@ fn main() -> Result<()> {
                Ok(incoming) => {
                    let stream = BufReader::new(incoming.0);
                    for line in stream.lines() {
-                        println!("{}", line?)
+                        println!("{}", line?);
                    }

                    return Ok(());
                }
                Err(error) => {
-                    panic!("{}", error)
+                    panic!("{}", error);
+                }
+            }
+        }
+        SubCommand::Query(arg) => {
+            let home = dirs::home_dir().context("there is no home directory")?;
+            let mut socket = home;
+            socket.push("komorebic.sock");
+            let socket = socket.as_path();
+
+            match std::fs::remove_file(&socket) {
+                Ok(_) => {}
+                Err(error) => match error.kind() {
+                    // Doing this because ::exists() doesn't work reliably on Windows via IntelliJ
+                    ErrorKind::NotFound => {}
+                    _ => {
+                        return Err(error.into());
+                    }
+                },
+            };
+
+            send_message(&*SocketMessage::Query(arg.state_query).as_bytes()?)?;
+
+            let listener = UnixListener::bind(&socket)?;
+            match listener.accept() {
+                Ok(incoming) => {
+                    let stream = BufReader::new(incoming.0);
+                    for line in stream.lines() {
+                        println!("{}", line?);
+                    }
+
+                    return Ok(());
+                }
+                Err(error) => {
+                    panic!("{}", error);
                }
            }
        }
@@ -482,7 +736,9 @@ fn main() -> Result<()> {
                BooleanState::Disable => false,
            };

-            send_message(&*SocketMessage::FocusFollowsMouse(enable).as_bytes()?)?;
+            send_message(
+                &*SocketMessage::FocusFollowsMouse(arg.implementation, enable).as_bytes()?,
+            )?;
        }
        SubCommand::ReloadConfiguration => {
            send_message(&*SocketMessage::ReloadConfiguration.as_bytes()?)?;
@@ -500,6 +756,17 @@ fn main() -> Result<()> {
                    .as_bytes()?,
            )?;
        }
+        SubCommand::IdentifyBorderOverflow(target) => {
+            send_message(
+                &*SocketMessage::IdentifyBorderOverflow(target.identifier, target.id).as_bytes()?,
+            )?;
+        }
+        SubCommand::Manage => {
+            send_message(&*SocketMessage::ManageFocusedWindow.as_bytes()?)?;
+        }
+        SubCommand::Unmanage => {
+            send_message(&*SocketMessage::UnmanageFocusedWindow.as_bytes()?)?;
+        }
    }

    Ok(())