feat(wm): add cmds for titlebar removal

This commit introduces some basic commands to read from/add to a whitelist of applications which that user has determined that are safe to remove the titlebar from. Titlebars and removed and added by removing and adding the WS_CAPTION and WS_THICKFRAME styles (this is the approach that Workspacer also takes) from the windows. Wherever possible, the user should prefer native preferences and settings that remove the titlebar in popular apps (Windows Terminal, Firefox etc). re #57
feat(subscriptions): embed latest state
2026-02-12 08:17:40 +01:00 · 2021-10-27 17:37:57 -07:00 · 2021-10-26 18:49:53 -07:00 · 2021-10-26 08:48:53 -07:00 · 2021-10-25 12:08:59 -07:00 · 2021-10-25 09:31:59 -07:00
41 changed files with 5508 additions and 1516 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.71"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"
+checksum = "79c2681d6594606957bbb8631c4b90a7fcaaa72cdb714743a437b156d6a7eedd"

 [[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"
@@ -168,9 +199,9 @@ checksum = "fb58b6451e8c2a812ad979ed1d83378caa5e927eef2622017a45f251457c2c9d"

 [[package]]
 name = "core-foundation-sys"
-version = "0.8.2"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea221b5284a47e40033bf9b66f35f984ec0ea2931eb03505246cd27a963f981b"
+checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"

 [[package]]
 name = "crossbeam-channel"
@@ -218,19 +249,28 @@ dependencies = [

 [[package]]
 name = "ctrlc"
-version = "3.2.0"
+version = "3.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "377c9b002a72a0b2c1a18c62e2f3864bdfea4a015e3683a96e24aa45dd6c02d1"
+checksum = "a19c6cedffdc8c03a3346d723eb20bd85a13362bb96dc2ac000842c6381ec7bf"
 dependencies = [
 "nix",
 "winapi 0.3.9",
 ]

+[[package]]
+name = "derive-ahk"
+version = "0.1.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "dirs"
-version = "3.0.2"
+version = "4.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30baa043103c9d0c2a57cf537cc2f35623889dc0d405e6c3cccfadbc81c71309"
+checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
 dependencies = [
 "dirs-sys",
 ]
@@ -246,6 +286,12 @@ dependencies = [
 "winapi 0.3.9",
 ]

+[[package]]
+name = "dtoa"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56899898ce76aaf4a0f24d914c97ea6ed976d42fec6ad33fcbb0a1103e07b2b0"
+
 [[package]]
 name = "either"
 version = "1.6.1"
@@ -274,6 +320,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"
@@ -370,9 +431,9 @@ dependencies = [

 [[package]]
 name = "hotwatch"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d61ee702e77f237b41761361a82e5c4bf6277dbb4bc8b6b7d745cb249cc82b31"
+checksum = "39301670a6f5798b75f36a1b149a379a50df5aa7c71be50f4b41ec6eab445cb8"
 dependencies = [
 "log",
 "notify",
@@ -414,6 +475,15 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "instant"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "716d3d89f35ac6a34fd0eed635395f4c3b76fa889338a4632e5231a8684216bd"
+dependencies = [
+ "cfg-if 1.0.0",
+]
+
 [[package]]
 name = "iovec"
 version = "0.1.4"
@@ -425,9 +495,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 +511,23 @@ dependencies = [

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

 [[package]]
 name = "komorebi-core"
-version = "0.1.0"
+version = "0.1.6"
 dependencies = [
 "bindings",
 "clap",
 "color-eyre",
 "serde",
 "serde_json",
+ "serde_yaml",
 "strum",
 ]

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

 [[package]]
 name = "libc"
-version = "0.2.99"
+version = "0.2.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7f823d141fe0a24df1e23b4af4e3c7ba9e5966ec514ea068c93024aa7deb765"
+checksum = "dd8f7255a17a627354f321ef0055d63b898c6fb27eff628af4d1b66b7331edf6"
+
+[[package]]
+name = "linked-hash-map"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3"
+
+[[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 +627,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"
@@ -570,7 +663,7 @@ dependencies = [
 "kernel32-sys",
 "libc",
 "log",
- "miow",
+ "miow 0.2.2",
 "net2",
 "slab",
 "winapi 0.2.8",
@@ -600,6 +693,15 @@ dependencies = [
 "ws2_32-sys",
 ]

+[[package]]
+name = "miow"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+dependencies = [
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "nanoid"
 version = "0.4.0"
@@ -622,9 +724,9 @@ dependencies = [

 [[package]]
 name = "nix"
-version = "0.22.0"
+version = "0.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf1e25ee6b412c2a1e3fcb6a4499a5c1bfe7f43e014bdce9a6b6666e5aa2d187"
+checksum = "f305c2c2e4c39a82f7bf0bf65fb557f9070ce06781d4f2454295cc34b1c43188"
 dependencies = [
 "bitflags",
 "cc",
@@ -691,9 +793,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 +818,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"
@@ -736,9 +876,9 @@ checksum = "36d62894f5590e88d99d0d82918742ba8e5bff1985af15d4906b6a65f635adb2"

 [[package]]
 name = "ppv-lite86"
-version = "0.2.10"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
+checksum = "c3ca011bd0129ff4ae15cd04c4eef202cadf6c51c21e47aba319b4e0501db741"

 [[package]]
 name = "proc-macro-error"
@@ -766,18 +906,18 @@ dependencies = [

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

 [[package]]
 name = "quote"
-version = "1.0.9"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
+checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
 dependencies = [
 "proc-macro2",
 ]
@@ -938,9 +1078,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 +1105,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 +1125,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",
@@ -995,25 +1135,37 @@ dependencies = [
 ]

 [[package]]
-name = "sharded-slab"
-version = "0.1.3"
+name = "serde_yaml"
+version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "740223c51853f3145fe7c90360d2d4232f2b62e3449489c207eccde818979982"
+checksum = "d8c608a35705a5d3cdc9fbe403147647ff34b921f8e833e49306df898f9b20af"
+dependencies = [
+ "dtoa",
+ "indexmap",
+ "serde",
+ "yaml-rust",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31"
 dependencies = [
 "lazy_static",
 ]

 [[package]]
 name = "slab"
-version = "0.4.4"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c307a32c1c5c437f38c7fd45d753050587732ba8628319fbdf12a7e289ccc590"
+checksum = "9def91fd1e018fe007022791f865d0ccc9b3a0d5001e01aabb8b40e46000afb5"

 [[package]]
 name = "smallvec"
-version = "1.6.1"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"
+checksum = "1ecab6c735a6bb4139c0caafd0cc3635748bbb3acf4550e8138122099251f309"

 [[package]]
 name = "strsim"
@@ -1044,9 +1196,9 @@ dependencies = [

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

 [[package]]
 name = "sysinfo"
-version = "0.20.0"
+version = "0.20.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0af066e6272f2175c1783cfc2ebf3e2d8dfe2c182b00677fdeccbf8291af83fb"
+checksum = "e223c65cd36b485a34c2ce6e38efa40777d31c4166d9076030c74cdcf971679f"
 dependencies = [
 "cfg-if 1.0.0",
 "core-foundation-sys",
@@ -1096,6 +1248,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 +1280,9 @@ dependencies = [

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

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

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

 [[package]]
 name = "tracing-subscriber"
-version = "0.2.19"
+version = "0.2.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab69019741fca4d98be3c62d2b75254528b5432233fd8a4d2739fec20278de48"
+checksum = "0e0d2eaa99c3c2e41547cfa109e910a68ea03823cccad4a0525dcbc9b01e8c71"
 dependencies = [
 "ansi_term",
 "chrono",
@@ -1229,9 +1392,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,29 +1487,68 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"

 [[package]]
 name = "windows"
-version = "0.18.0"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68088239696c06152844eadc03d262f088932cce50c67e4ace86e19d95e976fe"
+checksum = "b8f5f8d2ea79bf690bbee453fd4a1516ae426e5d5c7215d96cc0c3dc134fc4a0"
 dependencies = [
 "const-sha1",
 "windows_gen",
 "windows_macros",
+ "windows_reader",
 ]

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

 [[package]]
 name = "windows_macros"
-version = "0.18.0"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58acfb8832e9f707f8997bd161e537a1c1f603e60a5bd9c3cf53484fdcc998f3"
+checksum = "81cc2357b1b03c19f056cb0e6d06011f80f54beadb4e36aee2ca98493c7cfc3c"
 dependencies = [
 "syn",
 "windows_gen",
+ "windows_quote",
+ "windows_reader",
+]
+
+[[package]]
+name = "windows_quote"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cf987b5288c15e1997226848f78f3ed3ef8b78dcfd71a201c8c8684163a7e4d"
+
+[[package]]
+name = "windows_reader"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "237b53e8b40766ea7db5da0d8c6c1442d21d0429f0ee7500d7b5688967bd9d7b"
+
+[[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]]
@@ -1358,3 +1560,12 @@ dependencies = [
 "winapi 0.2.8",
 "winapi-build",
 ]
+
+[[package]]
+name = "yaml-rust"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
+dependencies = [
+ "linked-hash-map",
+]
--- 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,14 @@ _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))
+
+There is a [Discord server](https://discord.gg/vzBmPm6RkQ) available for _komorebi_-related discussion, help,
+troubleshooting etc. If you have any specific feature requests or bugs to report, please create an issue in this
+repository.
+
 ## Description

 _komorebi_ only responds to [WinEvents](https://docs.microsoft.com/en-us/windows/win32/winauto/event-constants) and the
@@ -59,6 +67,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 +78,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 +91,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 +105,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 +118,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 +164,104 @@ 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
+```
+
+#### Saving and Loading Resized Layouts
+
+If you create a BSP layout through various resize adjustments that you want to be able to restore easily in the future,
+it is possible to "quicksave" that layout to the system's temporary folder and load it later in the same session, or
+alternatively, you may save it to a specific file to be loaded again at any point in the future.
+
+```powershell
+komorebic.exe quick-save # saves the focused workspace to $Env:TEMP\komorebi.quicksave.json
+komorebic.exe quick-load # loads $Env:TEMP\komorebi.quicksave.json on the focused workspace
+
+komorebic.exe save ~/layouts/primary.json # saves the focused workspace to $Env:USERPROFILE\layouts\primary.json
+komorebic.exe load ~/layouts/secondary.json # loads $Env:USERPROFILE\layouts\secondary.json on the focused workspace
+```
+
+These layouts can be applied to arbitrary collections of windows on any workspace, as they only track the layout
+dimensions and are not coupled to the applications that were running at the time of saving.
+
+When layouts that expect more or less windows than the number currently on the focused workspace are loaded, `komorebi`
+will automatically reconcile the difference.
+
+#### Creating and Loading Custom Layouts
+
+Particularly for users of ultrawide monitors, traditional tiling layouts may not seem like the most efficient use of
+screen space. If you feel this is the case with any of the default layouts, you are also welcome to create your own
+custom layouts and save them as JSON or YAML.
+
+If you're not comfortable writing the layouts directly in JSON or YAML, you can use
+the [komorebi Custom Layout Generator](https://lgug2z.github.io/komorebi-custom-layout-generator/) to interactively
+define a custom layout, and then copy the generated JSON content.
+
+Custom layouts can be loaded on the current workspace or configured for a specific workspace with the following
+commands:
+
+```powershell
+komorebic.exe load-custom-layout ~/custom.yaml
+komorebic.exe workspace-custom-layout 0 0 ~/custom.yaml
+```
+
+The fundamental building block of a custom _komorebi_ layout is the Column.
+
+Columns come in three variants:
+
+- **Primary**: This is where your primary focus will be on the screen most of the time. There must be exactly one Primary
+  Column in any custom layout. Optionally, you can specify the percentage of the screen width that you want the Primary
+  Column to occupy.
+- **Secondary**: This is an optional column that can either be full height of split horizontally into a fixed number of
+  maximum rows. There can be any number of Secondary Columns in a custom layout.
+- **Tertiary**: This is the final column where any remaining windows will be split horizontally into rows as they get added.
+
+If there is only one window on the screen when a custom layout is selected, that window will take up the full work area
+of the screen.
+
+If the number of windows is equal to or less than the total number of columns defined in a custom layout, the windows
+will be arranged in an equal-width columns.
+
+When the number of windows is greater than the number of columns defined in the custom layout, the windows will begin to
+be arranged according to the constraints set on the Primary and Secondary columns of the layout.
+
+Here is an example custom layout that can be used as a starting point for your own:
+
+YAML
+
+```yaml
+- column: Secondary
+  configuration:
+    Horizontal: 2 # max number of rows,
+- column: Primary
+  configuration:
+    WidthPercentage: 45 # percentage of screen
+- column: Tertiary
+  configuration: Horizontal
+```
+
+## 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 +271,82 @@ 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
+subscribe                     Subscribe to komorebi events
+unsubscribe                   Unsubscribe from komorebi events
+log                           Tail komorebi.exe's process logs (cancel with Ctrl-C)
+quick-save                    Quicksave the current resize layout dimensions
+quick-load                    Load the last quicksaved resize layout dimensions
+save                          Save the current resize layout dimensions to a file
+load                          Load the resize layout dimensions from a file
+focus                         Change focus to the window in the specified direction
+move                          Move the focused window in the specified direction
+cycle-focus                   Change focus to the window in the specified cycle direction
+cycle-move                    Move the focused window in the specified cycle 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
+cycle-monitor                 Focus the monitor in the given cycle direction
+cycle-workspace               Focus the workspace in the given cycle direction
+new-workspace                 Create and append a new workspace on the focused monitor
+invisible-borders             Set the invisible border dimensions around each window
+work-area-offset              Set offsets to exclude parts of the work area from tiling
+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
+load-custom-layout            Load a custom layout from file for 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-custom-layout       Set a custom 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,30 +355,47 @@ 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
+- [x] Quicksave and quickload layouts with resize dimensions
+- [x] Save and load layouts with resize dimensions to/from specific files
 - [x] Mouse drag to swap window container position
 - [x] Mouse drag to resize window container
 - [x] Configurable workspace and container gaps
- [x] BSP tree layout
+- [x] BSP tree layout (`bsp`)
 - [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] Equal-width, max-height column layout (`columns`)
+- [x] Equal-height, max-width row layout (`rows`)
+- [x] Main half-height window with vertical stack layout (`horizontal-stack`)
+- [x] Main half-width window with horizontal stack layout (`vertical-stack`)
+- [x] 2x Main window (half and quarter-width) with horizontal stack layout (`ultrawide-vertical-stack`)
+- [x] Load custom layouts from JSON and YAML representations
+- [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 work area offsets to preserve space for custom taskbars
+- [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
+- [x] Subscribe to event and message notifications

 ## Development

@@ -184,7 +415,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 +431,61 @@ 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
-}
+## Window Manager Event Subscriptions
+
+It is also possible to subscribe to notifications of every `WindowManagerEvent` and `SocketMessage` handled
+by `komorebi` using [Named Pipes](https://docs.microsoft.com/en-us/windows/win32/ipc/named-pipes).
+
+First, your application must create a named pipe. Once the named pipe has been created, run the following command:
+
+```powershell
+komorebic.exe subscribe <your pipe name>
 ```
+
+Note that you do not have to include the full path of the named pipe, just the name.
+
+If the named pipe exists, `komorebi` will start pushing JSON data of successfully handled events and messages:
+
+```json lines
+{"event":{"type":"AddSubscriber","content":"yasb"},"state":{...}}
+{"event":{"type":"FocusWindow","content":"Left"},"state":{...}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":131444,"title":"komorebi – README.md","exe":"idea64.exe","class":"SunAwtFrame","rect":{"left":13,"top":60,"right":1520,"bottom":1655}}]},"state":{...}}
+{"event":{"type":"MonitorPoll","content":["ObjectCreate",{"hwnd":5572450,"title":"OLEChannelWnd","exe":"explorer.exe","class":"OleMainThreadWndClass","rect":{"left":0,"top":0,"right":0,"bottom":0}}]},"state":{...}}
+{"event":{"type":"FocusWindow","content":"Right"},"state":{...}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{}...}
+{"event":{"type":"FocusWindow","content":"Down"},"state":{...}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":329264,"title":"den — Mozilla Firefox","exe":"firefox.exe","class":"MozillaWindowClass","rect":{"left":1539,"top":894,"right":1520,"bottom":821}}]},"state":{...}}
+{"event":{"type":"FocusWindow","content":"Up"},"state":{...}}
+{"event":{"type":"FocusChange","content":["SystemForeground",{"hwnd":132968,"title":"Windows PowerShell","exe":"WindowsTerminal.exe","class":"CASCADIA_HOSTING_WINDOW_CLASS","rect":{"left":1539,"top":60,"right":1520,"bottom":821}}]},"state":{...}}
+```
+
+You may then filter on the `type` key to listen to the events that you are interested in. For a full list of possible
+notification types, refer to the enum variants of `WindowManagerEvent` in `komorebi` and `SocketMessage`
+in `komorebi-core`.
+
+An example of how to create a named pipe and a subscription to `komorebi`'s handled events in Python
+by [@denBot](https://github.com/denBot) can be
+found [here](https://gist.github.com/denBot/4136279812f87819f86d99eba77c1ee0).
--- a/bindings/Cargo.toml
+++ b/bindings/Cargo.toml
@@ -2,12 +2,12 @@
 name = "bindings"
 version = "0.1.0"
 authors = ["Jade Iqbal"]
-edition = "2018"
+edition = "2021"

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

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

 [build-dependencies]
-windows = "0.18"
+windows = "0.21"
--- a/bindings/src/lib.rs
+++ b/bindings/src/lib.rs
@@ -1 +1,4 @@
+pub use windows::Handle;
+pub use windows::Result;
+
 ::windows::include_bindings!();
--- a/derive-ahk/Cargo.toml
+++ b/derive-ahk/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "derive-ahk"
+version = "0.1.0"
+edition = "2021"
+
+[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,7 +1,7 @@
 [package]
 name = "komorebi-core"
-version = "0.1.0"
-edition = "2018"
+version = "0.1.6"
+edition = "2021"

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

@@ -12,4 +12,5 @@ clap = "3.0.0-beta.4"
 color-eyre = "0.5"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+serde_yaml = "0.8"
 strum = { version = "0.21", features = ["derive"] }
--- a/komorebi-core/src/arrangement.rs
+++ b/komorebi-core/src/arrangement.rs
@@ -0,0 +1,584 @@
+use std::num::NonZeroUsize;
+
+use clap::ArgEnum;
+use serde::Deserialize;
+use serde::Serialize;
+use strum::Display;
+use strum::EnumString;
+
+use crate::custom_layout::Column;
+use crate::custom_layout::ColumnSplit;
+use crate::custom_layout::ColumnSplitWithCapacity;
+use crate::CustomLayout;
+use crate::DefaultLayout;
+use crate::Rect;
+
+pub trait Arrangement {
+    fn calculate(
+        &self,
+        area: &Rect,
+        len: NonZeroUsize,
+        container_padding: Option<i32>,
+        layout_flip: Option<Flip>,
+        resize_dimensions: &[Option<Rect>],
+    ) -> Vec<Rect>;
+}
+
+impl Arrangement for DefaultLayout {
+    #[allow(clippy::too_many_lines)]
+    fn calculate(
+        &self,
+        area: &Rect,
+        len: NonZeroUsize,
+        container_padding: Option<i32>,
+        layout_flip: Option<Flip>,
+        resize_dimensions: &[Option<Rect>],
+    ) -> Vec<Rect> {
+        let len = usize::from(len);
+        let mut dimensions = match self {
+            DefaultLayout::BSP => recursive_fibonacci(
+                0,
+                len,
+                area,
+                layout_flip,
+                calculate_resize_adjustments(resize_dimensions),
+            ),
+            DefaultLayout::Columns => columns(area, len),
+            DefaultLayout::Rows => rows(area, len),
+            DefaultLayout::VerticalStack => {
+                let mut layouts: Vec<Rect> = vec![];
+
+                let primary_right = match len {
+                    1 => area.right,
+                    _ => area.right / 2,
+                };
+
+                let mut main_left = area.left;
+                let mut stack_left = area.left + primary_right;
+
+                match layout_flip {
+                    Some(Flip::Horizontal | Flip::HorizontalAndVertical) if len > 1 => {
+                        main_left = main_left + area.right - primary_right;
+                        stack_left = area.left;
+                    }
+                    _ => {}
+                }
+
+                if len >= 1 {
+                    layouts.push(Rect {
+                        left: main_left,
+                        top: area.top,
+                        right: primary_right,
+                        bottom: area.bottom,
+                    });
+
+                    if len > 1 {
+                        layouts.append(&mut rows(
+                            &Rect {
+                                left: stack_left,
+                                top: area.top,
+                                right: area.right - primary_right,
+                                bottom: area.bottom,
+                            },
+                            len - 1,
+                        ));
+                    }
+                }
+
+                layouts
+            }
+            DefaultLayout::HorizontalStack => {
+                let mut layouts: Vec<Rect> = vec![];
+
+                let bottom = match len {
+                    1 => area.bottom,
+                    _ => area.bottom / 2,
+                };
+
+                let mut main_top = area.top;
+                let mut stack_top = area.top + bottom;
+
+                match layout_flip {
+                    Some(Flip::Vertical | Flip::HorizontalAndVertical) if len > 1 => {
+                        main_top = main_top + area.bottom - bottom;
+                        stack_top = area.top;
+                    }
+                    _ => {}
+                }
+
+                if len >= 1 {
+                    layouts.push(Rect {
+                        left: area.left,
+                        top: main_top,
+                        right: area.right,
+                        bottom,
+                    });
+
+                    if len > 1 {
+                        layouts.append(&mut columns(
+                            &Rect {
+                                left: area.left,
+                                top: stack_top,
+                                right: area.right,
+                                bottom: area.bottom - bottom,
+                            },
+                            len - 1,
+                        ));
+                    }
+                }
+
+                layouts
+            }
+            DefaultLayout::UltrawideVerticalStack => {
+                let mut layouts: Vec<Rect> = vec![];
+
+                let primary_right = match len {
+                    1 => area.right,
+                    _ => area.right / 2,
+                };
+
+                let secondary_right = match len {
+                    1 => 0,
+                    2 => area.right - primary_right,
+                    _ => (area.right - primary_right) / 2,
+                };
+
+                let (primary_left, secondary_left, stack_left) = match len {
+                    1 => (area.left, 0, 0),
+                    2 => {
+                        let mut primary = area.left + secondary_right;
+                        let mut secondary = area.left;
+
+                        match layout_flip {
+                            Some(Flip::Horizontal | Flip::HorizontalAndVertical) if len > 1 => {
+                                primary = area.left;
+                                secondary = area.left + primary_right;
+                            }
+                            _ => {}
+                        }
+
+                        (primary, secondary, 0)
+                    }
+                    _ => {
+                        let primary = area.left + secondary_right;
+                        let mut secondary = area.left;
+                        let mut stack = area.left + primary_right + secondary_right;
+
+                        match layout_flip {
+                            Some(Flip::Horizontal | Flip::HorizontalAndVertical) if len > 1 => {
+                                secondary = area.left + primary_right + secondary_right;
+                                stack = area.left;
+                            }
+                            _ => {}
+                        }
+
+                        (primary, secondary, stack)
+                    }
+                };
+
+                if len >= 1 {
+                    layouts.push(Rect {
+                        left: primary_left,
+                        top: area.top,
+                        right: primary_right,
+                        bottom: area.bottom,
+                    });
+
+                    if len >= 2 {
+                        layouts.push(Rect {
+                            left: secondary_left,
+                            top: area.top,
+                            right: secondary_right,
+                            bottom: area.bottom,
+                        });
+
+                        if len > 2 {
+                            layouts.append(&mut rows(
+                                &Rect {
+                                    left: stack_left,
+                                    top: area.top,
+                                    right: secondary_right,
+                                    bottom: area.bottom,
+                                },
+                                len - 2,
+                            ));
+                        }
+                    }
+                }
+
+                layouts
+            }
+        };
+
+        dimensions
+            .iter_mut()
+            .for_each(|l| l.add_padding(container_padding));
+
+        dimensions
+    }
+}
+
+impl Arrangement for CustomLayout {
+    fn calculate(
+        &self,
+        area: &Rect,
+        len: NonZeroUsize,
+        container_padding: Option<i32>,
+        _layout_flip: Option<Flip>,
+        _resize_dimensions: &[Option<Rect>],
+    ) -> Vec<Rect> {
+        let mut dimensions = vec![];
+        let container_count = len.get();
+
+        if container_count <= self.len() {
+            let mut layouts = columns(area, container_count);
+            dimensions.append(&mut layouts);
+        } else {
+            let count_map = self.column_container_counts();
+
+            // If there are not enough windows to trigger the final tertiary
+            // column in the custom layout, use an offset to reduce the number of
+            // columns to calculate each column's area by, so that we don't have
+            // an empty ghost tertiary column and the screen space can be maximised
+            // until there are enough windows to create it
+            let mut tertiary_trigger_threshold = 0;
+
+            // always -1 because we don't insert the tertiary column in the count_map
+            for i in 0..self.len() - 1 {
+                tertiary_trigger_threshold += count_map.get(&i).unwrap();
+            }
+
+            let enable_tertiary_column = len.get() > tertiary_trigger_threshold;
+
+            let offset = if enable_tertiary_column {
+                None
+            } else {
+                Option::from(1)
+            };
+
+            #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+            let primary_right = self.primary_width_percentage().map_or_else(
+                || area.right / self.len() as i32,
+                |percentage| (area.right / 100) * percentage as i32,
+            );
+
+            for (idx, column) in self.iter().enumerate() {
+                // If we are offsetting a tertiary column for which the threshold
+                // has not yet been met, this loop should not run for that final
+                // tertiary column
+                if idx < self.len() - offset.unwrap_or(0) {
+                    let column_area = if idx == 0 {
+                        Self::column_area_with_last(self.len(), area, primary_right, None, offset)
+                    } else {
+                        Self::column_area_with_last(
+                            self.len(),
+                            area,
+                            primary_right,
+                            Option::from(dimensions[self.first_container_idx(idx - 1)]),
+                            offset,
+                        )
+                    };
+
+                    match column {
+                        Column::Primary(Option::Some(_)) => {
+                            let main_column_area = if idx == 0 {
+                                Self::main_column_area(area, primary_right, None)
+                            } else {
+                                Self::main_column_area(
+                                    area,
+                                    primary_right,
+                                    Option::from(dimensions[self.first_container_idx(idx - 1)]),
+                                )
+                            };
+
+                            dimensions.push(main_column_area);
+                        }
+                        Column::Primary(None) | Column::Secondary(None) => {
+                            dimensions.push(column_area);
+                        }
+                        Column::Secondary(Some(split)) => match split {
+                            ColumnSplitWithCapacity::Horizontal(capacity) => {
+                                let mut rows = rows(&column_area, *capacity);
+                                dimensions.append(&mut rows);
+                            }
+                            ColumnSplitWithCapacity::Vertical(capacity) => {
+                                let mut columns = columns(&column_area, *capacity);
+                                dimensions.append(&mut columns);
+                            }
+                        },
+                        Column::Tertiary(split) => {
+                            let column_area = Self::column_area_with_last(
+                                self.len(),
+                                area,
+                                primary_right,
+                                Option::from(dimensions[self.first_container_idx(idx - 1)]),
+                                offset,
+                            );
+
+                            let remaining = container_count - tertiary_trigger_threshold;
+
+                            match split {
+                                ColumnSplit::Horizontal => {
+                                    let mut rows = rows(&column_area, remaining);
+                                    dimensions.append(&mut rows);
+                                }
+                                ColumnSplit::Vertical => {
+                                    let mut columns = columns(&column_area, remaining);
+                                    dimensions.append(&mut columns);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        dimensions
+            .iter_mut()
+            .for_each(|l| l.add_padding(container_padding));
+
+        dimensions
+    }
+}
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
+#[strum(serialize_all = "snake_case")]
+pub enum Flip {
+    Horizontal,
+    Vertical,
+    HorizontalAndVertical,
+}
+
+#[must_use]
+fn columns(area: &Rect, len: usize) -> Vec<Rect> {
+    #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
+    let right = area.right / len as i32;
+    let mut left = 0;
+
+    let mut layouts: Vec<Rect> = vec![];
+    for _ in 0..len {
+        layouts.push(Rect {
+            left: area.left + left,
+            top: area.top,
+            right,
+            bottom: area.bottom,
+        });
+
+        left += right;
+    }
+
+    layouts
+}
+
+#[must_use]
+fn rows(area: &Rect, len: usize) -> Vec<Rect> {
+    #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
+    let bottom = area.bottom / len as i32;
+    let mut top = 0;
+
+    let mut layouts: Vec<Rect> = vec![];
+    for _ in 0..len {
+        layouts.push(Rect {
+            left: area.left,
+            top: area.top + top,
+            right: area.right,
+            bottom,
+        });
+
+        top += bottom;
+    }
+
+    layouts
+}
+
+fn calculate_resize_adjustments(resize_dimensions: &[Option<Rect>]) -> Vec<Option<Rect>> {
+    let mut resize_adjustments = resize_dimensions.to_vec();
+
+    // This needs to be aware of layout flips
+    for (i, opt) in resize_dimensions.iter().enumerate() {
+        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 {
+                        i - 1..i
+                    } else {
+                        i - 2..i
+                    };
+
+                    for n in range {
+                        let should_adjust = n % 2 == 0;
+                        if should_adjust {
+                            if let Some(Some(adjacent_resize)) = resize_adjustments.get_mut(n) {
+                                adjacent_resize.right += resize_ref.left;
+                            } else {
+                                resize_adjustments[n] = Option::from(Rect {
+                                    left: 0,
+                                    top: 0,
+                                    right: resize_ref.left,
+                                    bottom: 0,
+                                });
+                            }
+                        }
+                    }
+
+                    if let Some(rr) = resize_adjustments[i].as_mut() {
+                        rr.left = 0;
+                    }
+                }
+
+                if resize_ref.top != 0 {
+                    let range = if i == 1 {
+                        0..1
+                    } else if i & 1 == 0 {
+                        i - 1..i
+                    } else {
+                        i - 2..i
+                    };
+
+                    for n in range {
+                        let should_adjust = n % 2 != 0;
+                        if should_adjust {
+                            if let Some(Some(adjacent_resize)) = resize_adjustments.get_mut(n) {
+                                adjacent_resize.bottom += resize_ref.top;
+                            } else {
+                                resize_adjustments[n] = Option::from(Rect {
+                                    left: 0,
+                                    top: 0,
+                                    right: 0,
+                                    bottom: resize_ref.top,
+                                });
+                            }
+                        }
+                    }
+
+                    if let Some(Some(resize)) = resize_adjustments.get_mut(i) {
+                        resize.top = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    let cleaned_resize_adjustments: Vec<_> = resize_adjustments
+        .iter()
+        .map(|adjustment| match adjustment {
+            None => None,
+            Some(rect) if rect.eq(&Rect::default()) => None,
+            Some(_) => *adjustment,
+        })
+        .collect();
+
+    cleaned_resize_adjustments
+}
+
+fn recursive_fibonacci(
+    idx: usize,
+    count: usize,
+    area: &Rect,
+    layout_flip: Option<Flip>,
+    resize_adjustments: Vec<Option<Rect>>,
+) -> Vec<Rect> {
+    let mut a = *area;
+
+    let resized = if let Some(Some(r)) = resize_adjustments.get(idx) {
+        a.left += r.left;
+        a.top += r.top;
+        a.right += r.right;
+        a.bottom += r.bottom;
+        a
+    } else {
+        *area
+    };
+
+    let half_width = area.right / 2;
+    let half_height = area.bottom / 2;
+    let half_resized_width = resized.right / 2;
+    let half_resized_height = resized.bottom / 2;
+
+    let (main_x, alt_x, alt_y, main_y);
+
+    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;
+            }
+            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;
+            }
+            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;
+            }
+        }
+    } 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 {
+        vec![Rect {
+            left: resized.left,
+            top: resized.top,
+            right: resized.right,
+            bottom: resized.bottom,
+        }]
+    } else if idx % 2 != 0 {
+        let mut res = vec![Rect {
+            left: resized.left,
+            top: main_y,
+            right: resized.right,
+            bottom: half_resized_height,
+        }];
+        res.append(&mut recursive_fibonacci(
+            idx + 1,
+            count - 1,
+            &Rect {
+                left: area.left,
+                top: alt_y,
+                right: area.right,
+                bottom: area.bottom - half_resized_height,
+            },
+            layout_flip,
+            resize_adjustments,
+        ));
+        res
+    } else {
+        let mut res = vec![Rect {
+            left: main_x,
+            top: resized.top,
+            right: half_resized_width,
+            bottom: resized.bottom,
+        }];
+        res.append(&mut recursive_fibonacci(
+            idx + 1,
+            count - 1,
+            &Rect {
+                left: alt_x,
+                top: area.top,
+                right: area.right - half_resized_width,
+                bottom: area.bottom,
+            },
+            layout_flip,
+            resize_adjustments,
+        ));
+        res
+    }
+}
--- a/komorebi-core/src/custom_layout.rs
+++ b/komorebi-core/src/custom_layout.rs
@@ -0,0 +1,262 @@
+use std::collections::HashMap;
+use std::fs::File;
+use std::io::BufReader;
+use std::ops::Deref;
+use std::path::PathBuf;
+
+use color_eyre::eyre::anyhow;
+use color_eyre::Result;
+use serde::Deserialize;
+use serde::Serialize;
+
+use crate::Rect;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct CustomLayout(Vec<Column>);
+
+impl Deref for CustomLayout {
+    type Target = Vec<Column>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl CustomLayout {
+    pub fn from_path_buf(path: PathBuf) -> Result<Self> {
+        let invalid_filetype = anyhow!("custom layouts must be json or yaml files");
+        let layout: Self = match path.extension() {
+            Some(extension) => {
+                if extension == "yaml" || extension == "yml" {
+                    serde_yaml::from_reader(BufReader::new(File::open(path)?))?
+                } else if extension == "json" {
+                    serde_json::from_reader(BufReader::new(File::open(path)?))?
+                } else {
+                    return Err(invalid_filetype);
+                }
+            }
+            None => return Err(invalid_filetype),
+        };
+
+        if !layout.is_valid() {
+            return Err(anyhow!("the layout file provided was invalid"));
+        }
+
+        Ok(layout)
+    }
+
+    #[must_use]
+    pub fn column_with_idx(&self, idx: usize) -> (usize, Option<&Column>) {
+        let column_idx = self.column_for_container_idx(idx);
+        let column = self.get(column_idx);
+        (column_idx, column)
+    }
+
+    #[must_use]
+    pub fn primary_idx(&self) -> Option<usize> {
+        for (i, column) in self.iter().enumerate() {
+            if let Column::Primary(_) = column {
+                return Option::from(i);
+            }
+        }
+
+        None
+    }
+
+    #[must_use]
+    pub fn primary_width_percentage(&self) -> Option<usize> {
+        for column in self.iter() {
+            if let Column::Primary(Option::Some(ColumnWidth::WidthPercentage(percentage))) = column
+            {
+                return Option::from(*percentage);
+            }
+        }
+
+        None
+    }
+
+    #[must_use]
+    pub fn is_valid(&self) -> bool {
+        // A valid layout must have at least one column
+        if self.is_empty() {
+            return false;
+        };
+
+        // Vertical column splits aren't supported at the moment
+        for column in self.iter() {
+            match column {
+                Column::Tertiary(ColumnSplit::Vertical)
+                | Column::Secondary(Some(ColumnSplitWithCapacity::Vertical(_))) => return false,
+                _ => {}
+            }
+        }
+
+        // The final column must not have a fixed capacity
+        match self.last() {
+            Some(Column::Tertiary(_)) => {}
+            _ => return false,
+        }
+
+        let mut primaries = 0;
+        let mut tertiaries = 0;
+
+        for column in self.iter() {
+            match column {
+                Column::Primary(_) => primaries += 1,
+                Column::Tertiary(_) => tertiaries += 1,
+                Column::Secondary(_) => {}
+            }
+        }
+
+        // There must only be one primary and one tertiary column
+        matches!(primaries, 1) && matches!(tertiaries, 1)
+    }
+
+    pub(crate) fn column_container_counts(&self) -> HashMap<usize, usize> {
+        let mut count_map = HashMap::new();
+
+        for (idx, column) in self.iter().enumerate() {
+            match column {
+                Column::Primary(_) | Column::Secondary(None) => {
+                    count_map.insert(idx, 1);
+                }
+                Column::Secondary(Some(split)) => {
+                    count_map.insert(
+                        idx,
+                        match split {
+                            ColumnSplitWithCapacity::Vertical(n)
+                            | ColumnSplitWithCapacity::Horizontal(n) => *n,
+                        },
+                    );
+                }
+                Column::Tertiary(_) => {}
+            }
+        }
+
+        count_map
+    }
+
+    #[must_use]
+    pub fn first_container_idx(&self, col_idx: usize) -> usize {
+        let count_map = self.column_container_counts();
+        let mut container_idx_accumulator = 0;
+
+        for i in 0..col_idx {
+            if let Some(n) = count_map.get(&i) {
+                container_idx_accumulator += n;
+            }
+        }
+
+        container_idx_accumulator
+    }
+
+    #[must_use]
+    pub fn column_for_container_idx(&self, idx: usize) -> usize {
+        let count_map = self.column_container_counts();
+        let mut container_idx_accumulator = 0;
+
+        // always -1 because we don't insert the tertiary column in the count_map
+        for i in 0..self.len() - 1 {
+            if let Some(n) = count_map.get(&i) {
+                container_idx_accumulator += n;
+
+                // The accumulator becomes greater than the window container index
+                // for the first time when we reach a column that contains that
+                // window container index
+                if container_idx_accumulator > idx {
+                    return i;
+                }
+            }
+        }
+
+        // If the accumulator never reaches a point where it is greater than the
+        // window container index, then the only remaining possibility is the
+        // final tertiary column
+        self.len() - 1
+    }
+
+    #[must_use]
+    pub fn column_area(&self, work_area: &Rect, idx: usize, offset: Option<usize>) -> Rect {
+        let divisor = offset.map_or_else(|| self.len(), |offset| self.len() - offset);
+
+        #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
+        let equal_width = work_area.right / divisor as i32;
+        let mut left = work_area.left;
+        let right = equal_width;
+
+        for _ in 0..idx {
+            left += right;
+        }
+
+        Rect {
+            left,
+            top: work_area.top,
+            right,
+            bottom: work_area.bottom,
+        }
+    }
+
+    #[must_use]
+    pub fn column_area_with_last(
+        len: usize,
+        work_area: &Rect,
+        primary_right: i32,
+        last_column: Option<Rect>,
+        offset: Option<usize>,
+    ) -> Rect {
+        let divisor = offset.map_or_else(|| len - 1, |offset| len - offset - 1);
+
+        #[allow(clippy::cast_possible_wrap, clippy::cast_possible_truncation)]
+        let equal_width = (work_area.right - primary_right) / divisor as i32;
+        let left = last_column.map_or(work_area.left, |last| last.left + last.right);
+        let right = equal_width;
+
+        Rect {
+            left,
+            top: work_area.top,
+            right,
+            bottom: work_area.bottom,
+        }
+    }
+
+    #[must_use]
+    pub fn main_column_area(
+        work_area: &Rect,
+        primary_right: i32,
+        last_column: Option<Rect>,
+    ) -> Rect {
+        let left = last_column.map_or(work_area.left, |last| last.left + last.right);
+
+        Rect {
+            left,
+            top: work_area.top,
+            right: primary_right,
+            bottom: work_area.bottom,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+#[serde(tag = "column", content = "configuration")]
+pub enum Column {
+    Primary(Option<ColumnWidth>),
+    Secondary(Option<ColumnSplitWithCapacity>),
+    Tertiary(ColumnSplit),
+}
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+pub enum ColumnWidth {
+    WidthPercentage(usize),
+}
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+pub enum ColumnSplit {
+    Horizontal,
+    Vertical,
+}
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
+pub enum ColumnSplitWithCapacity {
+    Horizontal(usize),
+    Vertical(usize),
+}
--- a/komorebi-core/src/cycle_direction.rs
+++ b/komorebi-core/src/cycle_direction.rs
@@ -1,3 +1,5 @@
+use std::num::NonZeroUsize;
+
 use clap::ArgEnum;
 use serde::Deserialize;
 use serde::Serialize;
@@ -12,17 +14,18 @@ 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: NonZeroUsize) -> usize {
        match self {
-            CycleDirection::Previous => {
+            Self::Previous => {
                if idx == 0 {
-                    len - 1
+                    len.get() - 1
                } else {
                    idx - 1
                }
            }
-            CycleDirection::Next => {
-                if idx == len - 1 {
+            Self::Next => {
+                if idx == len.get() - 1 {
                    0
                } else {
                    idx + 1
--- a/komorebi-core/src/default_layout.rs
+++ b/komorebi-core/src/default_layout.rs
@@ -0,0 +1,125 @@
+use clap::ArgEnum;
+use serde::Deserialize;
+use serde::Serialize;
+use strum::Display;
+use strum::EnumString;
+
+use crate::OperationDirection;
+use crate::Rect;
+use crate::Sizing;
+
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
+#[strum(serialize_all = "snake_case")]
+pub enum DefaultLayout {
+    BSP,
+    Columns,
+    Rows,
+    VerticalStack,
+    HorizontalStack,
+    UltrawideVerticalStack,
+}
+
+impl DefaultLayout {
+    #[must_use]
+    #[allow(clippy::cast_precision_loss)]
+    pub fn resize(
+        &self,
+        unaltered: &Rect,
+        resize: &Option<Rect>,
+        edge: OperationDirection,
+        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 = step.unwrap_or(50);
+
+        match edge {
+            OperationDirection::Left => match sizing {
+                Sizing::Increase => {
+                    // Some final checks to make sure the user can't infinitely resize to
+                    // the point of pushing other windows out of bounds
+
+                    // Note: These checks cannot take into account the changes made to the
+                    // edges of adjacent windows at operation time, so it is still possible
+                    // to push windows out of bounds by maxing out an Increase Left on a
+                    // Window with index 1, and then maxing out a Decrease Right on a Window
+                    // with index 0. I don't think it's worth trying to defensively program
+                    // against this; if people end up in this situation they are better off
+                    // just hitting the retile command
+                    let diff = ((r.left + -resize_step) as f32).abs();
+                    let max = unaltered.right as f32 / max_divisor;
+                    if diff < max {
+                        r.left += -resize_step;
+                    }
+                }
+                Sizing::Decrease => {
+                    let diff = ((r.left - -resize_step) as f32).abs();
+                    let max = unaltered.right as f32 / max_divisor;
+                    if diff < max {
+                        r.left -= -resize_step;
+                    }
+                }
+            },
+            OperationDirection::Up => match sizing {
+                Sizing::Increase => {
+                    let diff = ((r.top + resize_step) as f32).abs();
+                    let max = unaltered.bottom as f32 / max_divisor;
+                    if diff < max {
+                        r.top += -resize_step;
+                    }
+                }
+                Sizing::Decrease => {
+                    let diff = ((r.top - resize_step) as f32).abs();
+                    let max = unaltered.bottom as f32 / max_divisor;
+                    if diff < max {
+                        r.top -= -resize_step;
+                    }
+                }
+            },
+            OperationDirection::Right => match sizing {
+                Sizing::Increase => {
+                    let diff = ((r.right + resize_step) as f32).abs();
+                    let max = unaltered.right as f32 / max_divisor;
+                    if diff < max {
+                        r.right += resize_step;
+                    }
+                }
+                Sizing::Decrease => {
+                    let diff = ((r.right - resize_step) as f32).abs();
+                    let max = unaltered.right as f32 / max_divisor;
+                    if diff < max {
+                        r.right -= resize_step;
+                    }
+                }
+            },
+            OperationDirection::Down => match sizing {
+                Sizing::Increase => {
+                    let diff = ((r.bottom + resize_step) as f32).abs();
+                    let max = unaltered.bottom as f32 / max_divisor;
+                    if diff < max {
+                        r.bottom += resize_step;
+                    }
+                }
+                Sizing::Decrease => {
+                    let diff = ((r.bottom - resize_step) as f32).abs();
+                    let max = unaltered.bottom as f32 / max_divisor;
+                    if diff < max {
+                        r.bottom -= resize_step;
+                    }
+                }
+            },
+        };
+
+        if r.eq(&Rect::default()) {
+            None
+        } else {
+            Option::from(r)
+        }
+    }
+}
--- a/komorebi-core/src/direction.rs
+++ b/komorebi-core/src/direction.rs
@@ -0,0 +1,289 @@
+use crate::custom_layout::Column;
+use crate::custom_layout::ColumnSplit;
+use crate::custom_layout::ColumnSplitWithCapacity;
+use crate::custom_layout::CustomLayout;
+use crate::DefaultLayout;
+use crate::OperationDirection;
+
+pub trait Direction {
+    fn index_in_direction(
+        &self,
+        op_direction: OperationDirection,
+        idx: usize,
+        count: usize,
+    ) -> Option<usize>;
+
+    fn is_valid_direction(
+        &self,
+        op_direction: OperationDirection,
+        idx: usize,
+        count: usize,
+    ) -> bool;
+    fn up_index(&self, idx: usize) -> usize;
+    fn down_index(&self, idx: usize) -> usize;
+    fn left_index(&self, idx: usize) -> usize;
+    fn right_index(&self, idx: usize) -> usize;
+}
+
+impl Direction for DefaultLayout {
+    fn index_in_direction(
+        &self,
+        op_direction: OperationDirection,
+        idx: usize,
+        count: usize,
+    ) -> Option<usize> {
+        match op_direction {
+            OperationDirection::Left => {
+                if self.is_valid_direction(op_direction, idx, count) {
+                    Option::from(self.left_index(idx))
+                } else {
+                    None
+                }
+            }
+            OperationDirection::Right => {
+                if self.is_valid_direction(op_direction, idx, count) {
+                    Option::from(self.right_index(idx))
+                } else {
+                    None
+                }
+            }
+            OperationDirection::Up => {
+                if self.is_valid_direction(op_direction, idx, count) {
+                    Option::from(self.up_index(idx))
+                } else {
+                    None
+                }
+            }
+            OperationDirection::Down => {
+                if self.is_valid_direction(op_direction, idx, count) {
+                    Option::from(self.down_index(idx))
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    fn is_valid_direction(
+        &self,
+        op_direction: OperationDirection,
+        idx: usize,
+        count: usize,
+    ) -> bool {
+        match op_direction {
+            OperationDirection::Up => match self {
+                DefaultLayout::BSP => count > 2 && idx != 0 && idx != 1,
+                DefaultLayout::Columns => false,
+                DefaultLayout::Rows | DefaultLayout::HorizontalStack => idx != 0,
+                DefaultLayout::VerticalStack => idx != 0 && idx != 1,
+                DefaultLayout::UltrawideVerticalStack => idx > 2,
+            },
+            OperationDirection::Down => match self {
+                DefaultLayout::BSP => count > 2 && idx != count - 1 && idx % 2 != 0,
+                DefaultLayout::Columns => false,
+                DefaultLayout::Rows => idx != count - 1,
+                DefaultLayout::VerticalStack => idx != 0 && idx != count - 1,
+                DefaultLayout::HorizontalStack => idx == 0,
+                DefaultLayout::UltrawideVerticalStack => idx > 1 && idx != count - 1,
+            },
+            OperationDirection::Left => match self {
+                DefaultLayout::BSP => count > 1 && idx != 0,
+                DefaultLayout::Columns | DefaultLayout::VerticalStack => idx != 0,
+                DefaultLayout::Rows => false,
+                DefaultLayout::HorizontalStack => idx != 0 && idx != 1,
+                DefaultLayout::UltrawideVerticalStack => count > 1 && idx != 1,
+            },
+            OperationDirection::Right => match self {
+                DefaultLayout::BSP => count > 1 && idx % 2 == 0 && idx != count - 1,
+                DefaultLayout::Columns => idx != count - 1,
+                DefaultLayout::Rows => false,
+                DefaultLayout::VerticalStack => idx == 0,
+                DefaultLayout::HorizontalStack => idx != 0 && idx != count - 1,
+                DefaultLayout::UltrawideVerticalStack => match count {
+                    0 | 1 => false,
+                    2 => idx != 0,
+                    _ => idx < 2,
+                },
+            },
+        }
+    }
+
+    fn up_index(&self, idx: usize) -> usize {
+        match self {
+            DefaultLayout::BSP => {
+                if idx % 2 == 0 {
+                    idx - 1
+                } else {
+                    idx - 2
+                }
+            }
+            DefaultLayout::Columns => unreachable!(),
+            DefaultLayout::Rows
+            | DefaultLayout::VerticalStack
+            | DefaultLayout::UltrawideVerticalStack => idx - 1,
+            DefaultLayout::HorizontalStack => 0,
+        }
+    }
+
+    fn down_index(&self, idx: usize) -> usize {
+        match self {
+            DefaultLayout::BSP
+            | DefaultLayout::Rows
+            | DefaultLayout::VerticalStack
+            | DefaultLayout::UltrawideVerticalStack => idx + 1,
+            DefaultLayout::Columns => unreachable!(),
+            DefaultLayout::HorizontalStack => 1,
+        }
+    }
+
+    fn left_index(&self, idx: usize) -> usize {
+        match self {
+            DefaultLayout::BSP => {
+                if idx % 2 == 0 {
+                    idx - 2
+                } else {
+                    idx - 1
+                }
+            }
+            DefaultLayout::Columns | DefaultLayout::HorizontalStack => idx - 1,
+            DefaultLayout::Rows => unreachable!(),
+            DefaultLayout::VerticalStack => 0,
+            DefaultLayout::UltrawideVerticalStack => match idx {
+                0 => 1,
+                1 => unreachable!(),
+                _ => 0,
+            },
+        }
+    }
+
+    fn right_index(&self, idx: usize) -> usize {
+        match self {
+            DefaultLayout::BSP | DefaultLayout::Columns | DefaultLayout::HorizontalStack => idx + 1,
+            DefaultLayout::Rows => unreachable!(),
+            DefaultLayout::VerticalStack => 1,
+            DefaultLayout::UltrawideVerticalStack => match idx {
+                1 => 0,
+                0 => 2,
+                _ => unreachable!(),
+            },
+        }
+    }
+}
+
+impl Direction for CustomLayout {
+    fn index_in_direction(
+        &self,
+        op_direction: OperationDirection,
+        idx: usize,
+        count: usize,
+    ) -> Option<usize> {
+        if count <= self.len() {
+            return DefaultLayout::Columns.index_in_direction(op_direction, idx, count);
+        }
+
+        match op_direction {
+            OperationDirection::Left => {
+                if self.is_valid_direction(op_direction, idx, count) {
+                    Option::from(self.left_index(idx))
+                } else {
+                    None
+                }
+            }
+            OperationDirection::Right => {
+                if self.is_valid_direction(op_direction, idx, count) {
+                    Option::from(self.right_index(idx))
+                } else {
+                    None
+                }
+            }
+            OperationDirection::Up => {
+                if self.is_valid_direction(op_direction, idx, count) {
+                    Option::from(self.up_index(idx))
+                } else {
+                    None
+                }
+            }
+            OperationDirection::Down => {
+                if self.is_valid_direction(op_direction, idx, count) {
+                    Option::from(self.down_index(idx))
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    fn is_valid_direction(
+        &self,
+        op_direction: OperationDirection,
+        idx: usize,
+        count: usize,
+    ) -> bool {
+        if count <= self.len() {
+            return DefaultLayout::Columns.is_valid_direction(op_direction, idx, count);
+        }
+
+        match op_direction {
+            OperationDirection::Left => idx != 0 && self.column_for_container_idx(idx) != 0,
+            OperationDirection::Right => {
+                idx != count - 1 && self.column_for_container_idx(idx) != self.len() - 1
+            }
+            OperationDirection::Up => {
+                if idx == 0 {
+                    return false;
+                }
+
+                let (column_idx, column) = self.column_with_idx(idx);
+                match column {
+                    None => false,
+                    Some(column) => match column {
+                        Column::Secondary(Some(ColumnSplitWithCapacity::Horizontal(_)))
+                        | Column::Tertiary(ColumnSplit::Horizontal) => {
+                            self.column_for_container_idx(idx - 1) == column_idx
+                        }
+                        _ => false,
+                    },
+                }
+            }
+            OperationDirection::Down => {
+                if idx == count - 1 {
+                    return false;
+                }
+
+                let (column_idx, column) = self.column_with_idx(idx);
+                match column {
+                    None => false,
+                    Some(column) => match column {
+                        Column::Secondary(Some(ColumnSplitWithCapacity::Horizontal(_)))
+                        | Column::Tertiary(ColumnSplit::Horizontal) => {
+                            self.column_for_container_idx(idx + 1) == column_idx
+                        }
+                        _ => false,
+                    },
+                }
+            }
+        }
+    }
+
+    fn up_index(&self, idx: usize) -> usize {
+        idx - 1
+    }
+
+    fn down_index(&self, idx: usize) -> usize {
+        idx + 1
+    }
+
+    fn left_index(&self, idx: usize) -> usize {
+        let column_idx = self.column_for_container_idx(idx);
+        if column_idx - 1 == 0 {
+            0
+        } else {
+            self.first_container_idx(column_idx - 1)
+        }
+    }
+
+    fn right_index(&self, idx: usize) -> usize {
+        let column_idx = self.column_for_container_idx(idx);
+        self.first_container_idx(column_idx + 1)
+    }
+}
--- a/komorebi-core/src/layout.rs
+++ b/komorebi-core/src/layout.rs
@@ -1,397 +1,31 @@
-use std::num::NonZeroUsize;
-
-use clap::ArgEnum;
 use serde::Deserialize;
 use serde::Serialize;
-use strum::Display;
-use strum::EnumString;

-use crate::OperationDirection;
-use crate::Rect;
-use crate::Sizing;
+use crate::Arrangement;
+use crate::CustomLayout;
+use crate::DefaultLayout;
+use crate::Direction;

-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
-#[strum(serialize_all = "snake_case")]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub enum Layout {
-    BSP,
-    Columns,
-    Rows,
-}
-
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
-#[strum(serialize_all = "snake_case")]
-pub enum LayoutFlip {
-    Horizontal,
-    Vertical,
-    HorizontalAndVertical,
+    Default(DefaultLayout),
+    Custom(CustomLayout),
 }

 impl Layout {
-    pub fn resize(
-        &self,
-        unaltered: &Rect,
-        resize: &Option<Rect>,
-        edge: OperationDirection,
-        sizing: Sizing,
-        step: Option<i32>,
-    ) -> Option<Rect> {
-        let max_divisor = 1.005;
-        let mut r = resize.unwrap_or_default();
-
-        let resize_step = if let Some(step) = step { step } else { 50 };
-
-        match edge {
-            OperationDirection::Left => match sizing {
-                Sizing::Increase => {
-                    // Some final checks to make sure the user can't infinitely resize to
-                    // the point of pushing other windows out of bounds
-
-                    // Note: These checks cannot take into account the changes made to the
-                    // edges of adjacent windows at operation time, so it is still possible
-                    // to push windows out of bounds by maxing out an Increase Left on a
-                    // Window with index 1, and then maxing out a Decrease Right on a Window
-                    // with index 0. I don't think it's worth trying to defensively program
-                    // against this; if people end up in this situation they are better off
-                    // just hitting the retile command
-                    let diff = ((r.left + -resize_step) as f32).abs();
-                    let max = unaltered.right as f32 / max_divisor;
-                    if diff < max {
-                        r.left += -resize_step;
-                    }
-                }
-                Sizing::Decrease => {
-                    let diff = ((r.left - -resize_step) as f32).abs();
-                    let max = unaltered.right as f32 / max_divisor;
-                    if diff < max {
-                        r.left -= -resize_step;
-                    }
-                }
-            },
-            OperationDirection::Up => match sizing {
-                Sizing::Increase => {
-                    let diff = ((r.top + resize_step) as f32).abs();
-                    let max = unaltered.bottom as f32 / max_divisor;
-                    if diff < max {
-                        r.top += -resize_step;
-                    }
-                }
-                Sizing::Decrease => {
-                    let diff = ((r.top - resize_step) as f32).abs();
-                    let max = unaltered.bottom as f32 / max_divisor;
-                    if diff < max {
-                        r.top -= -resize_step;
-                    }
-                }
-            },
-            OperationDirection::Right => match sizing {
-                Sizing::Increase => {
-                    let diff = ((r.right + resize_step) as f32).abs();
-                    let max = unaltered.right as f32 / max_divisor;
-                    if diff < max {
-                        r.right += resize_step;
-                    }
-                }
-                Sizing::Decrease => {
-                    let diff = ((r.right - resize_step) as f32).abs();
-                    let max = unaltered.right as f32 / max_divisor;
-                    if diff < max {
-                        r.right -= resize_step;
-                    }
-                }
-            },
-            OperationDirection::Down => match sizing {
-                Sizing::Increase => {
-                    let diff = ((r.bottom + resize_step) as f32).abs();
-                    let max = unaltered.bottom as f32 / max_divisor;
-                    if diff < max {
-                        r.bottom += resize_step;
-                    }
-                }
-                Sizing::Decrease => {
-                    let diff = ((r.bottom - resize_step) as f32).abs();
-                    let max = unaltered.bottom as f32 / max_divisor;
-                    if diff < max {
-                        r.bottom -= resize_step;
-                    }
-                }
-            },
-        };
-
-        if !r.eq(&Rect::default()) {
-            Option::from(r)
-        } else {
-            None
-        }
-    }
-
-    pub fn calculate(
-        &self,
-        area: &Rect,
-        len: NonZeroUsize,
-        container_padding: Option<i32>,
-        layout_flip: Option<LayoutFlip>,
-        resize_dimensions: &[Option<Rect>],
-    ) -> Vec<Rect> {
-        let len = usize::from(len);
-        let mut dimensions = match self {
-            Layout::BSP => recursive_fibonacci(
-                0,
-                len,
-                area,
-                layout_flip,
-                calculate_resize_adjustments(resize_dimensions),
-            ),
-            Layout::Columns => {
-                let right = area.right / len as i32;
-                let mut left = 0;
-
-                let mut layouts: Vec<Rect> = vec![];
-                for _ in 0..len {
-                    layouts.push(Rect {
-                        left: area.left + left,
-                        top: area.top,
-                        right,
-                        bottom: area.bottom,
-                    });
-
-                    left += right;
-                }
-
-                layouts
-            }
-            Layout::Rows => {
-                let bottom = area.bottom / len as i32;
-                let mut top = 0;
-
-                let mut layouts: Vec<Rect> = vec![];
-                for _ in 0..len {
-                    layouts.push(Rect {
-                        left: area.left,
-                        top: area.top + top,
-                        right: area.right,
-                        bottom,
-                    });
-
-                    top += bottom;
-                }
-
-                layouts
-            }
-        };
-
-        dimensions
-            .iter_mut()
-            .for_each(|l| l.add_padding(container_padding));
-
-        dimensions
-    }
-}
-
-impl Layout {
-    pub fn next(&mut self) {
+    #[must_use]
+    pub fn as_boxed_direction(&self) -> Box<dyn Direction> {
        match self {
-            Layout::BSP => *self = Layout::Columns,
-            Layout::Columns => *self = Layout::Rows,
-            Layout::Rows => *self = Layout::BSP,
+            Layout::Default(layout) => Box::new(*layout),
+            Layout::Custom(layout) => Box::new(layout.clone()),
        }
    }

-    pub fn previous(&mut self) {
+    #[must_use]
+    pub fn as_boxed_arrangement(&self) -> Box<dyn Arrangement> {
        match self {
-            Layout::BSP => *self = Layout::Rows,
-            Layout::Columns => *self = Layout::BSP,
-            Layout::Rows => *self = Layout::Columns,
+            Layout::Default(layout) => Box::new(*layout),
+            Layout::Custom(layout) => Box::new(layout.clone()),
        }
    }
 }
-
-fn calculate_resize_adjustments(resize_dimensions: &[Option<Rect>]) -> Vec<Option<Rect>> {
-    let mut resize_adjustments = resize_dimensions.to_vec();
-
-    // This needs to be aware of layout flips
-    for (i, opt) in resize_dimensions.iter().enumerate() {
-        if let Some(resize_ref) = opt {
-            if i > 0 {
-                if resize_ref.left != 0 {
-                    let range = if i == 1 {
-                        0..1
-                    } else if i & 1 != 0 {
-                        i - 1..i
-                    } else {
-                        i - 2..i
-                    };
-
-                    for n in range {
-                        let should_adjust = n % 2 == 0;
-                        if should_adjust {
-                            if let Some(Some(adjacent_resize)) = resize_adjustments.get_mut(n) {
-                                adjacent_resize.right += resize_ref.left;
-                            } else {
-                                resize_adjustments[n] = Option::from(Rect {
-                                    left: 0,
-                                    top: 0,
-                                    right: resize_ref.left,
-                                    bottom: 0,
-                                });
-                            }
-                        }
-                    }
-
-                    if let Some(rr) = resize_adjustments[i].as_mut() {
-                        rr.left = 0;
-                    }
-                }
-
-                if resize_ref.top != 0 {
-                    let range = if i == 1 {
-                        0..1
-                    } else if i & 1 == 0 {
-                        i - 1..i
-                    } else {
-                        i - 2..i
-                    };
-
-                    for n in range {
-                        let should_adjust = n % 2 != 0;
-                        if should_adjust {
-                            if let Some(Some(adjacent_resize)) = resize_adjustments.get_mut(n) {
-                                adjacent_resize.bottom += resize_ref.top;
-                            } else {
-                                resize_adjustments[n] = Option::from(Rect {
-                                    left: 0,
-                                    top: 0,
-                                    right: 0,
-                                    bottom: resize_ref.top,
-                                });
-                            }
-                        }
-                    }
-
-                    if let Some(Some(resize)) = resize_adjustments.get_mut(i) {
-                        resize.top = 0;
-                    }
-                }
-            }
-        }
-    }
-
-    let cleaned_resize_adjustments: Vec<_> = resize_adjustments
-        .iter()
-        .map(|adjustment| match adjustment {
-            None => None,
-            Some(rect) if rect.eq(&Rect::default()) => None,
-            Some(_) => *adjustment,
-        })
-        .collect();
-
-    cleaned_resize_adjustments
-}
-
-fn recursive_fibonacci(
-    idx: usize,
-    count: usize,
-    area: &Rect,
-    layout_flip: Option<LayoutFlip>,
-    resize_adjustments: Vec<Option<Rect>>,
-) -> Vec<Rect> {
-    let mut a = *area;
-
-    let resized = if let Some(Some(r)) = resize_adjustments.get(idx) {
-        a.left += r.left;
-        a.top += r.top;
-        a.right += r.right;
-        a.bottom += r.bottom;
-        a
-    } else {
-        *area
-    };
-
-    let half_width = area.right / 2;
-    let half_height = area.bottom / 2;
-    let half_resized_width = resized.right / 2;
-    let half_resized_height = resized.bottom / 2;
-
-    let (main_x, alt_x, alt_y, main_y);
-
-    match layout_flip {
-        Some(flip) => match flip {
-            LayoutFlip::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 => {
-                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 => {
-                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;
-        }
-    }
-
-    if count == 0 {
-        vec![]
-    } else if count == 1 {
-        vec![Rect {
-            left: resized.left,
-            top: resized.top,
-            right: resized.right,
-            bottom: resized.bottom,
-        }]
-    } else if idx % 2 != 0 {
-        let mut res = vec![Rect {
-            left: resized.left,
-            top: main_y,
-            right: resized.right,
-            bottom: half_resized_height,
-        }];
-        res.append(&mut recursive_fibonacci(
-            idx + 1,
-            count - 1,
-            &Rect {
-                left: area.left,
-                top: alt_y,
-                right: area.right,
-                bottom: area.bottom - half_resized_height,
-            },
-            layout_flip,
-            resize_adjustments,
-        ));
-        res
-    } else {
-        let mut res = vec![Rect {
-            left: main_x,
-            top: resized.top,
-            right: half_resized_width,
-            bottom: resized.bottom,
-        }];
-        res.append(&mut recursive_fibonacci(
-            idx + 1,
-            count - 1,
-            &Rect {
-                left: alt_x,
-                top: area.top,
-                right: area.right - half_resized_width,
-                bottom: area.bottom,
-            },
-            layout_flip,
-            resize_adjustments,
-        ));
-        res
-    }
-}
--- a/komorebi-core/src/lib.rs
+++ b/komorebi-core/src/lib.rs
@@ -1,3 +1,7 @@
+#![warn(clippy::all, clippy::nursery, clippy::pedantic)]
+#![allow(clippy::missing_errors_doc)]
+
+use std::path::PathBuf;
 use std::str::FromStr;

 use clap::ArgEnum;
@@ -7,36 +11,53 @@ use serde::Serialize;
 use strum::Display;
 use strum::EnumString;

+pub use arrangement::Arrangement;
+pub use arrangement::Flip;
+pub use custom_layout::CustomLayout;
 pub use cycle_direction::CycleDirection;
+pub use default_layout::DefaultLayout;
+pub use direction::Direction;
 pub use layout::Layout;
-pub use layout::LayoutFlip;
 pub use operation_direction::OperationDirection;
 pub use rect::Rect;

+pub mod arrangement;
+pub mod custom_layout;
 pub mod cycle_direction;
+pub mod default_layout;
+pub mod direction;
 pub mod layout;
 pub mod operation_direction;
 pub mod rect;

 #[derive(Clone, Debug, Serialize, Deserialize, Display)]
+#[serde(tag = "type", content = "content")]
 pub enum SocketMessage {
    // Window / Container Commands
    FocusWindow(OperationDirection),
    MoveWindow(OperationDirection),
+    CycleFocusWindow(CycleDirection),
+    CycleMoveWindow(CycleDirection),
    StackWindow(OperationDirection),
    ResizeWindow(OperationDirection, Sizing),
    UnstackWindow,
    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),
+    ChangeLayout(DefaultLayout),
+    ChangeLayoutCustom(PathBuf),
+    FlipLayout(Flip),
    // Monitor and Workspace Commands
    EnsureWorkspaces(usize, usize),
    NewWorkspace,
@@ -44,32 +65,44 @@ pub enum SocketMessage {
    Stop,
    TogglePause,
    Retile,
+    QuickSave,
+    QuickLoad,
+    Save(PathBuf),
+    Load(PathBuf),
+    CycleFocusMonitor(CycleDirection),
+    CycleFocusWorkspace(CycleDirection),
    FocusMonitorNumber(usize),
    FocusWorkspaceNumber(usize),
    ContainerPadding(usize, usize, i32),
    WorkspacePadding(usize, usize, i32),
    WorkspaceTiling(usize, usize, bool),
    WorkspaceName(usize, usize, String),
-    WorkspaceLayout(usize, usize, Layout),
+    WorkspaceLayout(usize, usize, DefaultLayout),
+    WorkspaceLayoutCustom(usize, usize, PathBuf),
    // Configuration
    ReloadConfiguration,
    WatchConfiguration(bool),
-    FloatClass(String),
-    FloatExe(String),
-    FloatTitle(String),
+    InvisibleBorders(Rect),
+    WorkAreaOffset(Rect),
+    WorkspaceRule(ApplicationIdentifier, String, usize, usize),
+    FloatRule(ApplicationIdentifier, String),
+    ManageRule(ApplicationIdentifier, String),
    IdentifyTrayApplication(ApplicationIdentifier, String),
+    IdentifyBorderOverflow(ApplicationIdentifier, String),
+    RemoveTitleBar(ApplicationIdentifier, String),
+    ToggleTitleBars,
    State,
-    FocusFollowsMouse(bool),
+    Query(StateQuery),
+    FocusFollowsMouse(FocusFollowsMouseImplementation, bool),
+    ToggleFocusFollowsMouse(FocusFollowsMouseImplementation),
+    AddSubscriber(String),
+    RemoveSubscriber(String),
 }

 impl SocketMessage {
    pub fn as_bytes(&self) -> Result<Vec<u8>> {
        Ok(serde_json::to_string(self)?.as_bytes().to_vec())
    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
-        Ok(serde_json::from_slice(bytes)?)
-    }
 }

 impl FromStr for SocketMessage {
@@ -80,6 +113,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 +130,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 +145,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
@@ -1,11 +1,13 @@
+use std::num::NonZeroUsize;
+
 use clap::ArgEnum;
 use serde::Deserialize;
 use serde::Serialize;
 use strum::Display;
 use strum::EnumString;

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

 #[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum)]
 #[strum(serialize_all = "snake_case")]
@@ -17,114 +19,45 @@ 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(self, layout_flip: Option<Flip>) -> Self {
+        layout_flip.map_or(self, |flip| match self {
+            Self::Left => match flip {
+                Flip::Horizontal | Flip::HorizontalAndVertical => Self::Right,
+                Flip::Vertical => self,
+            },
+            Self::Right => match flip {
+                Flip::Horizontal | Flip::HorizontalAndVertical => Self::Left,
+                Flip::Vertical => self,
+            },
+            Self::Up => match flip {
+                Flip::Vertical | Flip::HorizontalAndVertical => Self::Down,
+                Flip::Horizontal => self,
+            },
+            Self::Down => match flip {
+                Flip::Vertical | Flip::HorizontalAndVertical => Self::Up,
+                Flip::Horizontal => self,
+            },
+        })
    }

-    pub fn is_valid(
-        &self,
-        layout: Layout,
-        layout_flip: Option<LayoutFlip>,
+    #[must_use]
+    pub fn destination(
+        self,
+        layout: &dyn Direction,
+        layout_flip: Option<Flip>,
        idx: usize,
-        len: usize,
-    ) -> bool {
-        match OperationDirection::flip_direction(self, layout_flip) {
-            OperationDirection::Up => match layout {
-                Layout::BSP => len > 2 && idx != 0 && idx != 1,
-                Layout::Columns => false,
-                Layout::Rows => idx != 0,
-            },
-            OperationDirection::Down => match layout {
-                Layout::BSP => len > 2 && idx != len - 1 && idx % 2 != 0,
-                Layout::Columns => false,
-                Layout::Rows => idx != len - 1,
-            },
-            OperationDirection::Left => match layout {
-                Layout::BSP => len > 1 && idx != 0,
-                Layout::Columns => idx != 0,
-                Layout::Rows => false,
-            },
-            OperationDirection::Right => match layout {
-                Layout::BSP => len > 1 && idx % 2 == 0 && idx != len - 1,
-                Layout::Columns => idx != len - 1,
-                Layout::Rows => false,
-            },
-        }
-    }
-
-    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 {
-                Layout::BSP => {
-                    if idx % 2 == 0 {
-                        idx - 1
-                    } else {
-                        idx - 2
-                    }
-                }
-                Layout::Columns => unreachable!(),
-                Layout::Rows => idx - 1,
-            },
-            OperationDirection::Down => match layout {
-                Layout::BSP | Layout::Rows => idx + 1,
-                Layout::Columns => unreachable!(),
-            },
-            OperationDirection::Left => match layout {
-                Layout::BSP => {
-                    if idx % 2 == 0 {
-                        idx - 2
-                    } else {
-                        idx - 1
-                    }
-                }
-                Layout::Columns => idx - 1,
-                Layout::Rows => unreachable!(),
-            },
-            OperationDirection::Right => match layout {
-                Layout::BSP | Layout::Columns => idx + 1,
-                Layout::Rows => unreachable!(),
-            },
-        }
+        len: NonZeroUsize,
+    ) -> Option<usize> {
+        layout.index_in_direction(self.flip(layout_flip), idx, len.get())
    }
 }
--- 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,240 @@
+#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")
+FloatRule("exe", "ddm.exe")
+FloatRule("class", "Chrome_RenderWidgetHostHWND") ; GOG Electron invisible overlay
+FloatRule("class", "CEFCLIENT")
+
+; Identify Minimize-to-Tray Applications
+IdentifyTrayApplication("exe", "Discord.exe")
+IdentifyTrayApplication("exe", "Spotify.exe")
+IdentifyTrayApplication("exe", "GalaxyClient.exe")
+
+; Identify Electron applications with overflowing borders
+IdentifyBorderOverflow("exe", "Discord.exe")
+IdentifyBorderOverflow("exe", "Spotify.exe")
+IdentifyBorderOverflow("exe", "GalaxyClient.exe")
+IdentifyBorderOverflow("class", "ZPFTEWndClass")
+
+; Identify applications to be forcibly managed
+ManageRule("exe", "GalaxyClient.exe")
+
+; 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,7 +1,12 @@
 [package]
 name = "komorebi"
-version = "0.1.0"
-edition = "2018"
+version = "0.1.6"
+authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
+description = "A tiling window manager for Windows"
+categories = ["tiling-window-manager", "windows"]
+repository = "https://github.com/LGUG2Z/komorebi"
+license = "MIT"
+edition = "2021"

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

@@ -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"
+dirs = "4"
 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,10 @@ 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"
+miow = "0.3"
+
+[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,23 +1,41 @@
 #![warn(clippy::all, clippy::nursery, clippy::pedantic)]
 #![allow(clippy::missing_errors_doc)]

+use std::collections::HashMap;
+use std::fs::File;
+use std::io::Write;
 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 serde::Serialize;
 use sysinfo::SystemExt;
 use tracing_appender::non_blocking::WorkerGuard;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::EnvFilter;
 use which::which;

+use komorebi_core::SocketMessage;
+
 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::State;
+use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;

@@ -28,6 +46,7 @@ mod container;
 mod monitor;
 mod process_command;
 mod process_event;
+mod process_movement;
 mod set_window_position;
 mod styles;
 mod window;
@@ -40,29 +59,43 @@ 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![]));
+    static ref WSL2_UI_PROCESSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
+        "X410.exe".to_string(),
+        "mstsc.exe".to_string(),
+        "vcxsrv.exe".to_string(),
+    ]));
+    static ref SUBSCRIPTION_PIPES: Arc<Mutex<HashMap<String, File>>> =
+        Arc::new(Mutex::new(HashMap::new()));
+    // Use app-specific titlebar removal options where possible
+    // eg. Windows Terminal, IntelliJ IDEA, Firefox
+    static ref NO_TITLEBAR: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));
 }

-fn setup() -> Result<WorkerGuard> {
+pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
+pub static REMOVE_TITLEBARS: 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 +106,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 +120,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 +153,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 +171,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 +183,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 +194,146 @@ pub fn load_configuration() -> Result<()> {
    Ok(())
 }

+#[derive(Debug, Serialize)]
+#[serde(untagged)]
+pub enum NotificationEvent {
+    WindowManager(WindowManagerEvent),
+    Socket(SocketMessage),
+}
+
+#[derive(Debug, Serialize)]
+pub struct Notification {
+    pub event: NotificationEvent,
+    pub state: State,
+}
+
+pub fn notify_subscribers(notification: &str) -> Result<()> {
+    let mut stale_subscriptions = vec![];
+    let mut subscriptions = SUBSCRIPTION_PIPES.lock();
+    for (subscriber, pipe) in subscriptions.iter_mut() {
+        match writeln!(pipe, "{}", notification) {
+            Ok(_) => {
+                tracing::debug!("pushed notification to subscriber: {}", subscriber);
+            }
+            Err(error) => {
+                // ERROR_FILE_NOT_FOUND
+                // 2 (0x2)
+                // The system cannot find the file specified.
+
+                // ERROR_NO_DATA
+                // 232 (0xE8)
+                // The pipe is being closed.
+
+                // Remove the subscription; the process will have to subscribe again
+                if let Some(2 | 232) = error.raw_os_error() {
+                    let subscriber_cl = subscriber.clone();
+                    stale_subscriptions.push(subscriber_cl);
+                }
+            }
+        }
+    }
+
+    for subscriber in stale_subscriptions {
+        tracing::warn!("removing stale subscription: {}", subscriber);
+        subscriptions.remove(&subscriber);
+    }
+
+    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,16 @@ impl Monitor {
        self.workspaces().len()
    }

-    pub fn update_focused_workspace(&mut self) -> Result<()> {
+    pub fn update_focused_workspace(
+        &mut self,
+        offset: Option<Rect>,
+        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, offset, invisible_borders)?;

        Ok(())
    }
--- a/komorebi/src/process_command.rs
+++ b/komorebi/src/process_command.rs
@@ -1,32 +1,45 @@
+use std::fs::File;
+use std::fs::OpenOptions;
 use std::io::BufRead;
 use std::io::BufReader;
 use std::io::Write;
+use std::num::NonZeroUsize;
 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 miow::pipe::connect;
+use parking_lot::Mutex;
 use uds_windows::UnixStream;

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

+use crate::notify_subscribers;
 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::Notification;
+use crate::NotificationEvent;
+use crate::BORDER_OVERFLOW_IDENTIFIERS;
+use crate::CUSTOM_FFM;
+use crate::FLOAT_IDENTIFIERS;
+use crate::MANAGE_IDENTIFIERS;
+use crate::NO_TITLEBAR;
+use crate::REMOVE_TITLEBARS;
+use crate::SUBSCRIPTION_PIPES;
+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 +48,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 +64,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) => {
@@ -59,6 +74,12 @@ impl WindowManager {
            SocketMessage::MoveWindow(direction) => {
                self.move_container_in_direction(direction)?;
            }
+            SocketMessage::CycleFocusWindow(direction) => {
+                self.focus_container_in_cycle_direction(direction)?;
+            }
+            SocketMessage::CycleMoveWindow(direction) => {
+                self.move_container_in_cycle_direction(direction)?;
+            }
            SocketMessage::StackWindow(direction) => self.add_window_to_container(direction)?,
            SocketMessage::UnstackWindow => self.remove_window_from_container()?,
            SocketMessage::CycleStack(direction) => {
@@ -66,28 +87,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,48 +126,93 @@ 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 => {
                self.toggle_tiling()?;
            }
+            SocketMessage::CycleFocusMonitor(direction) => {
+                let monitor_idx = direction.next_idx(
+                    self.focused_monitor_idx(),
+                    NonZeroUsize::new(self.monitors().len())
+                        .ok_or_else(|| anyhow!("there must be at least one monitor"))?,
+                );
+
+                self.focus_monitor(monitor_idx)?;
+                self.update_focused_workspace(true)?;
+            }
            SocketMessage::FocusMonitorNumber(monitor_idx) => {
                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::ChangeLayout(layout) => self.change_workspace_layout_default(layout)?,
+            SocketMessage::ChangeLayoutCustom(path) => self.change_workspace_custom_layout(path)?,
+            SocketMessage::WorkspaceLayoutCustom(monitor_idx, workspace_idx, path) => {
+                self.set_workspace_layout_custom(monitor_idx, workspace_idx, path)?;
+            }
            SocketMessage::WorkspaceTiling(monitor_idx, workspace_idx, tile) => {
                self.set_workspace_tiling(monitor_idx, workspace_idx, tile)?;
            }
            SocketMessage::WorkspaceLayout(monitor_idx, workspace_idx, layout) => {
-                self.set_workspace_layout(monitor_idx, workspace_idx, layout)?;
+                self.set_workspace_layout_default(monitor_idx, workspace_idx, layout)?;
+            }
+            SocketMessage::CycleFocusWorkspace(direction) => {
+                // 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)?;
+
+                let focused_monitor = self
+                    .focused_monitor()
+                    .ok_or_else(|| anyhow!("there is no monitor"))?;
+
+                let focused_workspace_idx = focused_monitor.focused_workspace_idx();
+                let workspaces = focused_monitor.workspaces().len();
+
+                let workspace_idx = direction.next_idx(
+                    focused_workspace_idx,
+                    NonZeroUsize::new(workspaces)
+                        .ok_or_else(|| anyhow!("there must be at least one workspace"))?,
+                );
+
+                self.focus_workspace(workspace_idx)?;
            }
            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 => {
                tracing::info!(
                    "received stop command, restoring all hidden windows and terminating process"
                );
-                self.restore_all_windows();
+                self.restore_all_windows()?;
                std::process::exit(0)
            }
            SocketMessage::EnsureWorkspaces(monitor_idx, workspace_count) => {
@@ -156,22 +225,133 @@ impl WindowManager {
                self.set_workspace_name(monitor_idx, workspace_idx, name)?;
            }
            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 state = serde_json::to_string_pretty(&window_manager::State::from(&*self))?;
+                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 +360,113 @@ 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()?;
+            }
+            SocketMessage::WorkAreaOffset(rect) => {
+                self.work_area_offset = Option::from(rect);
+                self.retile_all()?;
+            }
+            SocketMessage::QuickSave => {
+                let workspace = self.focused_workspace()?;
+                let resize = workspace.resize_dimensions();
+
+                let mut quicksave_json = std::env::temp_dir();
+                quicksave_json.push("komorebi.quicksave.json");
+
+                let file = OpenOptions::new()
+                    .write(true)
+                    .truncate(true)
+                    .create(true)
+                    .open(quicksave_json)?;
+
+                serde_json::to_writer_pretty(&file, &resize)?;
+            }
+            SocketMessage::QuickLoad => {
+                let workspace = self.focused_workspace_mut()?;
+
+                let mut quicksave_json = std::env::temp_dir();
+                quicksave_json.push("komorebi.quicksave.json");
+
+                let file = File::open(&quicksave_json).map_err(|_| {
+                    anyhow!(
+                        "no quicksave found at {}",
+                        quicksave_json.display().to_string()
+                    )
+                })?;
+
+                let resize: Vec<Option<Rect>> = serde_json::from_reader(file)?;
+
+                workspace.set_resize_dimensions(resize);
+                self.update_focused_workspace(false)?;
+            }
+            SocketMessage::Save(path) => {
+                let workspace = self.focused_workspace_mut()?;
+                let resize = workspace.resize_dimensions();
+
+                let file = OpenOptions::new()
+                    .write(true)
+                    .truncate(true)
+                    .create(true)
+                    .open(path)?;
+
+                serde_json::to_writer_pretty(&file, &resize)?;
+            }
+            SocketMessage::Load(path) => {
+                let workspace = self.focused_workspace_mut()?;
+
+                let file = File::open(&path)
+                    .map_err(|_| anyhow!("no file found at {}", path.display().to_string()))?;
+
+                let resize: Vec<Option<Rect>> = serde_json::from_reader(file)?;
+
+                workspace.set_resize_dimensions(resize);
+                self.update_focused_workspace(false)?;
+            }
+            SocketMessage::AddSubscriber(subscriber) => {
+                let mut pipes = SUBSCRIPTION_PIPES.lock();
+                let pipe_path = format!(r"\\.\pipe\{}", subscriber);
+                let pipe = connect(&pipe_path).map_err(|_| {
+                    anyhow!("the named pipe '{}' has not yet been created; please create it before running this command", pipe_path)
+                })?;
+
+                pipes.insert(subscriber, pipe);
+            }
+            SocketMessage::RemoveSubscriber(subscriber) => {
+                let mut pipes = SUBSCRIPTION_PIPES.lock();
+                pipes.remove(&subscriber);
+            }
+            SocketMessage::RemoveTitleBar(_, id) => {
+                let mut identifiers = NO_TITLEBAR.lock();
+                if !identifiers.contains(&id) {
+                    identifiers.push(id);
+                }
+            }
+            SocketMessage::ToggleTitleBars => {
+                let current = REMOVE_TITLEBARS.load(Ordering::SeqCst);
+                REMOVE_TITLEBARS.store(!current, Ordering::SeqCst);
+                self.update_focused_workspace(false)?;
+            }
+        };

        tracing::info!("processed");
        Ok(())
@@ -208,17 +479,22 @@ 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)?;
+            self.process_command(message.clone())?;
+            notify_subscribers(&serde_json::to_string(&Notification {
+                event: NotificationEvent::Socket(message.clone()),
+                state: (&*self).into(),
+            })?)?;
        }

        Ok(())
--- a/komorebi/src/process_event.rs
+++ b/komorebi/src/process_event.rs
@@ -1,26 +1,28 @@
 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;
 use komorebi_core::Sizing;

+use crate::notify_subscribers;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
+use crate::Notification;
+use crate::NotificationEvent;
 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 +30,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 +50,33 @@ 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;
+        let offset = self.work_area_offset;
+
        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, offset, &invisible_borders)?;
                    tracing::info!(
                        "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
                        reaped_orphans.0,
@@ -79,33 +88,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 +147,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 +166,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 +203,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 +222,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 +289,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 +309,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 +319,11 @@ impl WindowManager {
            .open(hwnd_json)?;

        serde_json::to_writer_pretty(&file, &known_hwnds)?;
+        notify_subscribers(&serde_json::to_string(&Notification {
+            event: NotificationEvent::WindowManager(*event),
+            state: (&*self).into(),
+        })?)?;
+
        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,8 +2,9 @@ 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::Error;
 use serde::ser::SerializeStruct;
 use serde::Serialize;
 use serde::Serializer;
@@ -15,11 +16,13 @@ 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;
+use crate::NO_TITLEBAR;
+use crate::WSL2_UI_PROCESSES;

 #[derive(Debug, Clone, Copy)]
 pub struct Window {
@@ -55,12 +58,28 @@ impl Serialize for Window {
    {
        let mut state = serializer.serialize_struct("Window", 5)?;
        state.serialize_field("hwnd", &self.hwnd)?;
-        state.serialize_field("title", &self.title().expect("could not get window title"))?;
-        state.serialize_field("exe", &self.exe().expect("could not get window exe"))?;
-        state.serialize_field("class", &self.class().expect("could not get window class"))?;
+        state.serialize_field(
+            "title",
+            &self
+                .title()
+                .map_err(|_| S::Error::custom("could not get window title"))?,
+        )?;
+        state.serialize_field(
+            "exe",
+            &self
+                .exe()
+                .map_err(|_| S::Error::custom("could not get window exe"))?,
+        )?;
+        state.serialize_field(
+            "class",
+            &self
+                .class()
+                .map_err(|_| S::Error::custom("could not get window class"))?,
+        )?;
        state.serialize_field(
            "rect",
-            &WindowsApi::window_rect(self.hwnd()).expect("could not get window rect"),
+            &WindowsApi::window_rect(self.hwnd())
+                .map_err(|_| S::Error::custom("could not get window rect"))?,
        )?;
        state.end()
    }
@@ -71,46 +90,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 +144,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 +155,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());
@@ -154,6 +212,20 @@ impl Window {
        WindowsApi::set_focus(self.hwnd())
    }

+    pub fn remove_title_bar(self) -> Result<()> {
+        let mut style = self.style()?;
+        style.remove(GwlStyle::CAPTION);
+        style.remove(GwlStyle::THICKFRAME);
+        self.update_style(style)
+    }
+
+    pub fn add_title_bar(self) -> Result<()> {
+        let mut style = self.style()?;
+        style.insert(GwlStyle::CAPTION);
+        style.insert(GwlStyle::THICKFRAME);
+        self.update_style(style)
+    }
+
    #[allow(dead_code)]
    pub fn update_style(self, style: GwlStyle) -> Result<()> {
        WindowsApi::update_style(self.hwnd(), isize::try_from(style.bits())?)
@@ -161,12 +233,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,10 +264,11 @@ 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);
+        }

+        #[allow(clippy::question_mark)]
        if self.title().is_err() {
            return Ok(false);
        }
@@ -212,48 +285,61 @@ 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 allow_wsl2_gui = {
+                        let wsl2_ui_processes = WSL2_UI_PROCESSES.lock();
+                        wsl2_ui_processes.contains(&exe_name)
+                    };
+
+                    let allow_titlebar_removed = {
+                        let titlebars_removed = NO_TITLEBAR.lock();
+                        titlebars_removed.contains(&exe_name)
+                    };

                    let style = self.style()?;
                    let ex_style = self.ex_style()?;

-                    if style.contains(GwlStyle::CAPTION)
-                        && ex_style.contains(GwlExStyle::WINDOWEDGE)
+                    if (
+                        allow_wsl2_gui
+                        || allow_titlebar_removed
+                        || style.contains(GwlStyle::CAPTION) && ex_style.contains(GwlExStyle::WINDOWEDGE)
+                    )
                        && !ex_style.contains(GwlExStyle::DLGMODALFRAME)
                        // Get a lot of dupe events coming through that make the redrawing go crazy
                        // on FocusChange events if I don't filter out this one. But, if we are
                        // 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
@@ -1,10 +1,14 @@
 use std::fmt::Display;
 use std::fmt::Formatter;

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

-#[derive(Debug, Copy, Clone)]
+#[derive(Debug, Copy, Clone, Serialize)]
+#[serde(tag = "type", content = "content")]
 pub enum WindowManagerEvent {
    Destroy(WinEvent, Window),
    FocusChange(WinEvent, Window),
@@ -13,11 +17,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 +65,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 +88,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,10 +3,12 @@ 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::Handle;
+use bindings::Result as WindowsCrateResult;
 use bindings::Windows::Win32::Foundation::BOOL;
 use bindings::Windows::Win32::Foundation::HANDLE;
 use bindings::Windows::Win32::Foundation::HWND;
@@ -23,6 +25,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 +45,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 +62,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 +71,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,43 +88,12 @@ 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),
    Ok(T),
 }

-impl From<BOOL> for WindowsResult<(), Error> {
-    fn from(return_value: BOOL) -> Self {
-        if return_value.as_bool() {
-            Self::Ok(())
-        } else {
-            Self::Err(std::io::Error::last_os_error().into())
-        }
-    }
-}
-
-impl From<HWND> for WindowsResult<isize, Error> {
-    fn from(return_value: HWND) -> Self {
-        if return_value.is_null() {
-            Self::Err(std::io::Error::last_os_error().into())
-        } else {
-            Self::Ok(return_value.0)
-        }
-    }
-}
-
-impl From<HANDLE> for WindowsResult<HANDLE, Error> {
-    fn from(return_value: HANDLE) -> Self {
-        if return_value.is_null() {
-            Self::Err(std::io::Error::last_os_error().into())
-        } else {
-            Self::Ok(return_value)
-        }
-    }
-}
-
 macro_rules! impl_from_integer_for_windows_result {
    ( $( $integer_type:ty ),+ ) => {
        $(
@@ -144,6 +120,40 @@ impl<T, E> From<WindowsResult<T, E>> for Result<T, E> {
    }
 }

+pub trait ProcessWindowsCrateResult<T> {
+    fn process(self) -> Result<T>;
+}
+
+macro_rules! impl_process_windows_crate_result {
+    ( $($input:ty => $deref:ty),+ $(,)? ) => (
+        paste::paste! {
+            $(
+                impl ProcessWindowsCrateResult<$deref> for WindowsCrateResult<$input> {
+                    fn process(self) -> Result<$deref> {
+                        match self {
+                            Ok(value) => Ok(value.0),
+                            Err(error) => Err(error.into()),
+                        }
+                    }
+                }
+            )+
+        }
+    );
+}
+
+impl_process_windows_crate_result!(
+    HWND => isize,
+);
+
+impl<T> ProcessWindowsCrateResult<T> for WindowsCrateResult<T> {
+    fn process(self) -> Result<T> {
+        match self {
+            Ok(value) => Ok(value),
+            Err(error) => Err(error.into()),
+        }
+    }
+}
+
 pub struct WindowsApi;

 impl WindowsApi {
@@ -151,14 +161,27 @@ impl WindowsApi {
        callback: MONITORENUMPROC,
        callback_data_address: isize,
    ) -> Result<()> {
-        Result::from(WindowsResult::from(unsafe {
+        unsafe {
            EnumDisplayMonitors(
                HDC(0),
                std::ptr::null_mut(),
                Option::from(callback),
                LPARAM(callback_data_address),
            )
-        }))
+        }
+        .ok()
+        .process()
+    }
+
+    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<()> {
@@ -169,16 +192,15 @@ impl WindowsApi {
    }

    pub fn enum_windows(callback: WNDENUMPROC, callback_data_address: isize) -> Result<()> {
-        Result::from(WindowsResult::from(unsafe {
-            EnumWindows(Option::from(callback), LPARAM(callback_data_address))
-        }))
+        unsafe { EnumWindows(Option::from(callback), LPARAM(callback_data_address)) }
+            .ok()
+            .process()
    }

    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 +217,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 +226,6 @@ impl WindowsApi {
                for hwnd in windows_on_other_monitors {
                    workspace.remove_window(hwnd)?;
                }
-
-                monitor.workspaces_mut().push_back(workspace);
            }
        }

@@ -213,9 +233,9 @@ impl WindowsApi {
    }

    pub fn allow_set_foreground_window(process_id: u32) -> Result<()> {
-        Result::from(WindowsResult::from(unsafe {
-            AllowSetForegroundWindow(process_id)
-        }))
+        unsafe { AllowSetForegroundWindow(process_id) }
+            .ok()
+            .process()
    }

    pub fn monitor_from_window(hwnd: HWND) -> isize {
@@ -224,6 +244,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;

@@ -232,7 +258,7 @@ impl WindowsApi {
    }

    pub fn set_window_pos(hwnd: HWND, layout: &Rect, position: HWND, flags: u32) -> Result<()> {
-        Result::from(WindowsResult::from(unsafe {
+        unsafe {
            SetWindowPos(
                hwnd,
                position,
@@ -242,7 +268,9 @@ impl WindowsApi {
                layout.bottom,
                SET_WINDOW_POS_FLAGS(flags),
            )
-        }))
+        }
+        .ok()
+        .process()
    }

    fn show_window(hwnd: HWND, command: SHOW_WINDOW_CMD) {
@@ -259,36 +287,33 @@ impl WindowsApi {
        Self::show_window(hwnd, SW_RESTORE);
    }

-    pub fn set_foreground_window(hwnd: HWND) -> Result<()> {
-        match WindowsResult::from(unsafe { SetForegroundWindow(hwnd) }) {
-            WindowsResult::Ok(_) => Ok(()),
-            WindowsResult::Err(error) => {
-                // TODO: Figure out the odd behaviour here, docs state that a zero value means
-                // TODO: that the window was not brought to the foreground, but this contradicts
-                // TODO: the behaviour that I have observed which resulted in this check
-                if error.to_string() == "The operation completed successfully. (os error 0)" {
-                    Ok(())
-                } else {
-                    Err(error)
-                }
-            }
-        }
+    pub fn maximize_window(hwnd: HWND) {
+        Self::show_window(hwnd, SW_MAXIMIZE);
    }

+    pub fn foreground_window() -> Result<isize> {
+        unsafe { GetForegroundWindow() }.ok().process()
+    }
+
+    pub fn set_foreground_window(hwnd: HWND) -> Result<()> {
+        unsafe { SetForegroundWindow(hwnd) }.ok().process()
+    }
+
+    #[allow(dead_code)]
    pub fn top_window() -> Result<isize> {
-        Result::from(WindowsResult::from(unsafe { GetTopWindow(HWND::NULL).0 }))
+        unsafe { GetTopWindow(HWND::default()) }.ok().process()
    }

    pub fn desktop_window() -> Result<isize> {
-        Result::from(WindowsResult::from(unsafe { GetDesktopWindow() }))
+        unsafe { GetDesktopWindow() }.ok().process()
    }

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

+    #[allow(dead_code)]
    pub fn top_visible_window() -> Result<isize> {
        let hwnd = Self::top_window()?;
        let mut next_hwnd = hwnd;
@@ -301,33 +326,35 @@ 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> {
        let mut rect = unsafe { std::mem::zeroed() };
-
-        Result::from(WindowsResult::from(unsafe {
-            GetWindowRect(hwnd, &mut rect)
-        }))?;
+        unsafe { GetWindowRect(hwnd, &mut rect) }.ok().process()?;

        Ok(Rect::from(rect))
    }

    fn set_cursor_pos(x: i32, y: i32) -> Result<()> {
-        Result::from(WindowsResult::from(unsafe { SetCursorPos(x, y) }))
+        unsafe { SetCursorPos(x, y) }.ok().process()
    }

    pub fn cursor_pos() -> Result<POINT> {
-        let mut cursor_pos: POINT = unsafe { std::mem::zeroed() };
-
-        Result::from(WindowsResult::from(unsafe {
-            GetCursorPos(&mut cursor_pos)
-        }))?;
+        let mut cursor_pos = POINT::default();
+        unsafe { GetCursorPos(&mut cursor_pos) }.ok().process()?;

        Ok(cursor_pos)
    }

+    pub fn window_from_point(point: POINT) -> Result<isize> {
+        unsafe { WindowFromPoint(point) }.ok().process()
+    }
+
+    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))
    }
@@ -351,24 +378,13 @@ impl WindowsApi {
    }

    pub fn attach_thread_input(thread_id: u32, target_thread_id: u32, attach: bool) -> Result<()> {
-        Result::from(WindowsResult::from(unsafe {
-            AttachThreadInput(thread_id, target_thread_id, attach)
-        }))
+        unsafe { AttachThreadInput(thread_id, target_thread_id, attach) }
+            .ok()
+            .process()
    }

    pub fn set_focus(hwnd: HWND) -> Result<()> {
-        match WindowsResult::from(unsafe { SetFocus(hwnd) }) {
-            WindowsResult::Ok(_) => Ok(()),
-            WindowsResult::Err(error) => {
-                // If the window is not attached to the calling thread's message queue, the return value is NULL
-                // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setfocus
-                if error.to_string() == "The operation completed successfully. (os error 0)" {
-                    Ok(())
-                } else {
-                    Err(error)
-                }
-            }
-        }
+        unsafe { SetFocus(hwnd) }.ok().map(|_| ()).process()
    }

    #[allow(dead_code)]
@@ -392,9 +408,9 @@ impl WindowsApi {
    }

    fn window_long_ptr_w(hwnd: HWND, index: WINDOW_LONG_PTR_INDEX) -> Result<isize> {
-        Result::from(WindowsResult::from(unsafe {
-            GetWindowLongPtrW(hwnd, index)
-        }))
+        // Can return 0, which does not always mean that an error has occurred
+        // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getwindowlongptrw
+        Result::from(unsafe { WindowsResult::Ok(GetWindowLongPtrW(hwnd, index)) })
    }

    #[allow(dead_code)]
@@ -420,9 +436,9 @@ impl WindowsApi {
        inherit_handle: bool,
        process_id: u32,
    ) -> Result<HANDLE> {
-        Result::from(WindowsResult::from(unsafe {
-            OpenProcess(access_rights, inherit_handle, process_id)
-        }))
+        unsafe { OpenProcess(access_rights, inherit_handle, process_id) }
+            .ok()
+            .process()
    }

    pub fn process_handle(process_id: u32) -> Result<HANDLE> {
@@ -434,14 +450,16 @@ impl WindowsApi {
        let mut path: Vec<u16> = vec![0; len as usize];
        let text_ptr = path.as_mut_ptr();

-        Result::from(WindowsResult::from(unsafe {
+        unsafe {
            QueryFullProcessImageNameW(
                handle,
                PROCESS_NAME_FORMAT(0),
                PWSTR(text_ptr),
                &mut len as *mut u32,
            )
-        }))?;
+        }
+        .ok()
+        .process()?;

        Ok(String::from_utf16(&path[..len as usize])?)
    }
@@ -450,7 +468,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())
    }

@@ -516,34 +534,50 @@ impl WindowsApi {
        let mut monitor_info: MONITORINFO = unsafe { std::mem::zeroed() };
        monitor_info.cbSize = u32::try_from(std::mem::size_of::<MONITORINFO>())?;

-        Result::from(WindowsResult::from(unsafe {
-            GetMonitorInfoW(hmonitor, (&mut monitor_info as *mut MONITORINFO).cast())
-        }))?;
+        unsafe { GetMonitorInfoW(hmonitor, (&mut monitor_info as *mut MONITORINFO).cast()) }
+            .ok()
+            .process()?;

        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,
        pv_param: *mut c_void,
        update_flags: SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS,
    ) -> Result<()> {
-        Result::from(WindowsResult::from(unsafe {
-            SystemParametersInfoW(action, ui_param, pv_param, update_flags)
-        }))
+        unsafe { SystemParametersInfoW(action, ui_param, pv_param, update_flags) }
+            .ok()
+            .process()
    }

+    #[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 +587,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.rs
+++ b/komorebi/src/winevent.rs
@@ -1,3 +1,4 @@
+use serde::Serialize;
 use strum::Display;

 use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_AIA_END;
@@ -85,7 +86,7 @@ use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_EVENTID_START;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_END;
 use bindings::Windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_START;

-#[derive(Clone, Copy, PartialEq, Debug, Display)]
+#[derive(Clone, Copy, PartialEq, Debug, Serialize, Display)]
 #[repr(u32)]
 #[allow(dead_code)]
 pub enum WinEvent {
--- 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,7 +1,8 @@
 use std::collections::VecDeque;
 use std::num::NonZeroUsize;
+use std::sync::atomic::Ordering;

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

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

@@ -18,6 +21,8 @@ use crate::container::Container;
 use crate::ring::Ring;
 use crate::window::Window;
 use crate::windows_api::WindowsApi;
+use crate::NO_TITLEBAR;
+use crate::REMOVE_TITLEBARS;

 #[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters, Setters)]
 pub struct Workspace {
@@ -28,13 +33,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")]
+    #[getset(get = "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")]
@@ -42,8 +52,7 @@ pub struct Workspace {
    #[serde(skip_serializing)]
    #[getset(get = "pub", set = "pub")]
    latest_layout: Vec<Rect>,
-    #[serde(skip_serializing)]
-    #[getset(get = "pub", get_mut = "pub")]
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
    resize_dimensions: Vec<Option<Rect>>,
    #[getset(get = "pub", set = "pub")]
    tile: bool,
@@ -57,9 +66,11 @@ 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: Layout::Default(DefaultLayout::BSP),
            layout_flip: None,
            workspace_padding: Option::from(10),
            container_padding: Option::from(10),
@@ -77,6 +88,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,21 +112,56 @@ 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<()> {
-        let mut adjusted_work_area = *work_area;
+    pub fn update(
+        &mut self,
+        work_area: &Rect,
+        offset: Option<Rect>,
+        invisible_borders: &Rect,
+    ) -> Result<()> {
+        let container_padding = self.container_padding();
+        let mut adjusted_work_area = offset.map_or_else(
+            || *work_area,
+            |offset| {
+                let mut with_offset = *work_area;
+                with_offset.left += offset.left;
+                with_offset.top += offset.top;
+                with_offset.right -= offset.right;
+                with_offset.bottom -= offset.bottom;
+
+                with_offset
+            },
+        );
+
        adjusted_work_area.add_padding(self.workspace_padding());

        self.enforce_resize_constraints();
@@ -109,23 +169,37 @@ 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)?;
-                }
+                    adjusted_work_area.add_padding(container_padding);
+                    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(
+                let layouts = self.layout().as_boxed_arrangement().calculate(
                    &adjusted_work_area,
-                    NonZeroUsize::new(self.containers().len()).context(
-                        "there must be at least one container to calculate a workspace layout",
-                    )?,
+                    NonZeroUsize::new(self.containers().len()).ok_or_else(|| {
+                        anyhow!(
+                            "there must be at least one container to calculate a workspace layout"
+                        )
+                    })?,
                    self.container_padding(),
                    self.layout_flip(),
                    self.resize_dimensions(),
                );

+                let should_remove_titlebars = REMOVE_TITLEBARS.load(Ordering::SeqCst);
+                let no_titlebar = { NO_TITLEBAR.lock().clone() };
+
                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)?;
+                        if should_remove_titlebars && no_titlebar.contains(&window.exe()?) {
+                            window.remove_title_bar()?;
+                        } else if no_titlebar.contains(&window.exe()?) {
+                            window.add_title_bar()?;
+                        }
+
+                        window.set_position(layout, invisible_borders, false)?;
                    }
                }

@@ -189,16 +263,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 +296,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;
            }
        }
@@ -233,24 +357,43 @@ impl Workspace {
    }

    pub fn promote_container(&mut self) -> Result<()> {
+        let resize = self.resize_dimensions_mut().remove(0);
        let container = self
            .remove_focused_container()
-            .context("there is no container")?;
-        self.containers_mut().push_front(container);
-        self.resize_dimensions_mut().insert(0, None);
-        self.focus_container(0);
+            .ok_or_else(|| anyhow!("there is no container"))?;
+
+        let primary_idx = match self.layout() {
+            Layout::Default(_) => 0,
+            Layout::Custom(layout) => layout.first_container_idx(
+                layout
+                    .primary_idx()
+                    .ok_or_else(|| anyhow!("this custom layout does not have a primary column"))?,
+            ),
+        };
+
+        self.containers_mut().insert(primary_idx, container);
+        self.resize_dimensions_mut().insert(primary_idx, resize);
+
+        self.focus_container(primary_idx);

        Ok(())
    }

    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> {
-        self.resize_dimensions_mut().remove(idx);
-        self.containers_mut().remove(idx)
+        if idx < self.resize_dimensions().len() {
+            self.resize_dimensions_mut().remove(idx);
+        }
+
+        if idx < self.containers().len() {
+            return self.containers_mut().remove(idx);
+        }
+
+        None
    }

    fn container_idx_for_window(&self, hwnd: isize) -> Option<usize> {
@@ -270,29 +413,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 +470,7 @@ impl Workspace {
            }
        }

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

        Ok(())
    }
@@ -310,29 +478,26 @@ 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
    }

    pub fn new_idx_for_direction(&self, direction: OperationDirection) -> Option<usize> {
-        if direction.is_valid(
-            self.layout(),
+        let len = NonZeroUsize::new(self.containers().len())?;
+
+        direction.destination(
+            self.layout().as_boxed_direction().as_ref(),
            self.layout_flip(),
            self.focused_container_idx(),
-            self.containers().len(),
-        ) {
-            Option::from(direction.new_idx(
-                self.layout(),
-                self.layout_flip(),
-                self.containers.focused_idx(),
-            ))
-        } else {
-            None
-        }
+            len,
+        )
+    }
+    pub fn new_idx_for_cycle_direction(&self, direction: CycleDirection) -> Option<usize> {
+        Option::from(direction.next_idx(
+            self.focused_container_idx(),
+            NonZeroUsize::new(self.containers().len())?,
+        ))
    }

    pub fn move_window_to_container(&mut self, target_container_idx: usize) -> Result<()> {
@@ -340,11 +505,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 +529,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 +546,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 +570,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 +581,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 +610,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 +659,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 +679,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 +696,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 +780,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 +801,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 +818,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,249 @@
+; 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
+}
+
+Subscribe(named_pipe) {
+    Run, komorebic.exe subscribe %named_pipe%, , Hide
+}
+
+Unsubscribe(named_pipe) {
+    Run, komorebic.exe unsubscribe %named_pipe%, , Hide
+}
+
+Log() {
+    Run, komorebic.exe log, , Hide
+}
+
+QuickSave() {
+    Run, komorebic.exe quick-save, , Hide
+}
+
+QuickLoad() {
+    Run, komorebic.exe quick-load, , Hide
+}
+
+Save(path) {
+    Run, komorebic.exe save %path%, , Hide
+}
+
+Load(path) {
+    Run, komorebic.exe load %path%, , Hide
+}
+
+Focus(operation_direction) {
+    Run, komorebic.exe focus %operation_direction%, , Hide
+}
+
+Move(operation_direction) {
+    Run, komorebic.exe move %operation_direction%, , Hide
+}
+
+CycleFocus(cycle_direction) {
+    Run, komorebic.exe cycle-focus %cycle_direction%, , Hide
+}
+
+CycleMove(cycle_direction) {
+    Run, komorebic.exe cycle-move %cycle_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
+}
+
+CycleMonitor(cycle_direction) {
+    Run, komorebic.exe cycle-monitor %cycle_direction%, , Hide
+}
+
+CycleWorkspace(cycle_direction) {
+    Run, komorebic.exe cycle-workspace %cycle_direction%, , Hide
+}
+
+NewWorkspace() {
+    Run, komorebic.exe new-workspace, , Hide
+}
+
+InvisibleBorders(left, top, right, bottom) {
+    Run, komorebic.exe invisible-borders %left% %top% %right% %bottom%, , Hide
+}
+
+WorkAreaOffset(left, top, right, bottom) {
+    Run, komorebic.exe work-area-offset %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(default_layout) {
+    Run, komorebic.exe change-layout %default_layout%, , Hide
+}
+
+LoadCustomLayout(path) {
+    Run, komorebic.exe load-custom-layout %path%, , 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
+}
+
+WorkspaceCustomLayout(monitor, workspace, path) {
+    Run, komorebic.exe workspace-custom-layout %monitor% %workspace% %path%, , 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"
-edition = "2018"
+version = "0.1.6"
+authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
+description = "The command-line interface for Komorebi, a tiling window manager for Windows"
+categories = ["cli", "tiling-window-manager", "windows"]
+repository = "https://github.com/LGUG2Z/komorebi"
+license = "MIT"
+edition = "2021"

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

 [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"
+dirs = "4"
+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;
@@ -9,8 +13,10 @@ use std::process::Command;
 use clap::AppSettings;
 use clap::ArgEnum;
 use clap::Clap;
-use color_eyre::eyre::ContextCompat;
+use color_eyre::eyre::anyhow;
 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::Layout;
-use komorebi_core::LayoutFlip;
+use komorebi_core::DefaultLayout;
+use komorebi_core::Flip;
+use komorebi_core::FocusFollowsMouseImplementation;
 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
@@ -60,18 +79,23 @@ macro_rules! gen_enum_subcommand_args {
 gen_enum_subcommand_args! {
    Focus: OperationDirection,
    Move: OperationDirection,
+    CycleFocus: CycleDirection,
+    CycleMove: CycleDirection,
+    CycleMonitor: CycleDirection,
+    CycleWorkspace: CycleDirection,
    Stack: OperationDirection,
    CycleStack: CycleDirection,
-    FlipLayout: LayoutFlip,
+    FlipLayout: Flip,
+    ChangeLayout: DefaultLayout,
    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 +107,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 +118,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,
@@ -106,7 +132,7 @@ macro_rules! gen_workspace_subcommand_args {
                    $(#[clap(arg_enum)] $($arg_enum)?)?
                    #[cfg_attr(
                        all($(FALSE $($arg_enum)?)?),
-                        doc = ""$name" of the workspace as a "$value""
+                        doc = ""$name " of the workspace as a "$value ""
                    )]
                    value: $value,
                }
@@ -117,11 +143,23 @@ macro_rules! gen_workspace_subcommand_args {

 gen_workspace_subcommand_args! {
    Name: String,
-    Layout: #[enum] Layout,
-    Tiling: #[enum] BooleanState
+    Layout: #[enum] DefaultLayout,
+    Tiling: #[enum] BooleanState,
 }

-#[derive(Clap)]
+#[derive(Clap, AhkFunction)]
+pub struct WorkspaceCustomLayout {
+    /// Monitor index (zero-indexed)
+    monitor: usize,
+
+    /// Workspace index on the specified monitor (zero-indexed)
+    workspace: usize,
+
+    /// JSON or YAML file from which the custom layout definition should be loaded
+    path: String,
+}
+
+#[derive(Clap, AhkFunction)]
 struct Resize {
    #[clap(arg_enum)]
    edge: OperationDirection,
@@ -129,7 +167,31 @@ 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 WorkAreaOffset {
+    /// Size of the left work area offset (set right to left * 2 to maintain right padding)
+    left: i32,
+    /// Size of the top work area offset (set bottom to the same value to maintain bottom padding)
+    top: i32,
+    /// Size of the right work area offset
+    right: i32,
+    /// Size of the bottom work area offset
+    bottom: i32,
+}
+
+#[derive(Clap, AhkFunction)]
 struct EnsureWorkspaces {
    /// Monitor index (zero-indexed)
    monitor: usize,
@@ -137,54 +199,182 @@ 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,
+    RemoveTitleBar,
+}
+
+#[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, AhkFunction)]
+struct Save {
+    /// File to which the resize layout dimensions should be saved
+    path: String,
+}
+
+#[derive(Clap, AhkFunction)]
+struct Load {
+    /// File from which the resize layout dimensions should be loaded
+    path: String,
+}
+
+#[derive(Clap, AhkFunction)]
+struct LoadCustomLayout {
+    /// JSON or YAML file from which the custom layout definition should be loaded
+    path: String,
+}
+
+#[derive(Clap, AhkFunction)]
+struct Subscribe {
+    /// Name of the pipe to send event notifications to (without "\\.\pipe\" prepended)
+    named_pipe: String,
+}
+
+#[derive(Clap, AhkFunction)]
+struct Unsubscribe {
+    /// Name of the pipe to stop sending event notifications to (without "\\.\pipe\" prepended)
+    named_pipe: String,
 }

 #[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),
+    /// Subscribe to komorebi events
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    Subscribe(Subscribe),
+    /// Unsubscribe from komorebi events
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    Unsubscribe(Unsubscribe),
+    /// Tail komorebi.exe's process logs (cancel with Ctrl-C)
+    Log,
+    /// Quicksave the current resize layout dimensions
+    QuickSave,
+    /// Load the last quicksaved resize layout dimensions
+    QuickLoad,
+    /// Save the current resize layout dimensions to a file
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    Save(Save),
+    /// Load the resize layout dimensions from a file
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    Load(Load),
    /// Change focus to the window in the specified direction
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    Focus(Focus),
    /// Move the focused window in the specified direction
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    Move(Move),
+    /// Change focus to the window in the specified cycle direction
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    CycleFocus(CycleFocus),
+    /// Move the focused window in the specified cycle direction
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    CycleMove(CycleMove),
    /// Stack the focused window in the specified direction
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    Stack(Stack),
@@ -202,21 +392,46 @@ 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),
    /// Focus the specified workspace on the focused monitor
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    FocusWorkspace(FocusWorkspace),
+    /// Focus the monitor in the given cycle direction
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    CycleMonitor(CycleMonitor),
+    /// Focus the workspace in the given cycle direction
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    CycleWorkspace(CycleWorkspace),
    /// 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),
+    /// Set offsets to exclude parts of the work area from tiling
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    WorkAreaOffset(WorkAreaOffset),
    /// 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),
+    /// Load a custom layout from file for the focused workspace
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    LoadCustomLayout(LoadCustomLayout),
    /// 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,13 +442,16 @@ 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),
+    /// Set a custom layout for the specified workspace
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    WorkspaceCustomLayout(WorkspaceCustomLayout),
    /// Enable or disable window tiling for the specified workspace
    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
    WorkspaceTiling(WorkspaceTiling),
@@ -248,25 +466,51 @@ 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),
+    /// Whitelist an application for title bar removal
+    #[clap(setting = AppSettings::ArgRequiredElseHelp)]
+    RemoveTitleBar(RemoveTitleBar),
+    /// Toggle title bars for whitelisted applications
+    ToggleTitleBars,
    /// 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<()> {
-    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("komorebi.sock");
    let socket = socket.as_path();

@@ -274,10 +518,45 @@ 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().ok_or_else(|| anyhow!("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().ok_or_else(|| anyhow!(
+                    "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()?)?;
        }
@@ -293,12 +572,46 @@ fn main() -> Result<()> {
        SubCommand::Move(arg) => {
            send_message(&*SocketMessage::MoveWindow(arg.operation_direction).as_bytes()?)?;
        }
+        SubCommand::CycleFocus(arg) => {
+            send_message(&*SocketMessage::CycleFocusWindow(arg.cycle_direction).as_bytes()?)?;
+        }
+        SubCommand::CycleMove(arg) => {
+            send_message(&*SocketMessage::CycleMoveWindow(arg.cycle_direction).as_bytes()?)?;
+        }
        SubCommand::MoveToMonitor(arg) => {
            send_message(&*SocketMessage::MoveContainerToMonitorNumber(arg.target).as_bytes()?)?;
        }
        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::WorkAreaOffset(arg) => {
+            send_message(
+                &*SocketMessage::WorkAreaOffset(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 +634,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,19 +646,32 @@ 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)
                    .as_bytes()?,
            )?;
        }
+        SubCommand::WorkspaceCustomLayout(arg) => {
+            send_message(
+                &*SocketMessage::WorkspaceLayoutCustom(
+                    arg.monitor,
+                    arg.workspace,
+                    resolve_windows_path(&arg.path)?,
+                )
+                .as_bytes()?,
+            )?;
+        }
        SubCommand::WorkspaceTiling(arg) => {
            send_message(
                &*SocketMessage::WorkspaceTiling(arg.monitor, arg.workspace, arg.value.into())
                    .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
@@ -355,21 +684,36 @@ fn main() -> Result<()> {
                        buf.pop(); // %USERPROFILE%\scoop\shims
                        buf.pop(); // %USERPROFILE%\scoop
                        buf.push("apps\\komorebi\\current\\komorebi.exe"); //%USERPROFILE%\scoop\komorebi\current\komorebi.exe
-                        Option::from(
-                            buf.to_str()
-                                .context("cannot create a string from the scoop komorebi path")?,
-                        )
+                        Option::from(buf.to_str().ok_or_else(|| {
+                            anyhow!("cannot create a string from the scoop komorebi path")
+                        })?)
                    }
                }
            } else {
                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 +727,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 +748,16 @@ fn main() -> Result<()> {
        SubCommand::CycleStack(arg) => {
            send_message(&*SocketMessage::CycleStack(arg.cycle_direction).as_bytes()?)?;
        }
+        SubCommand::ChangeLayout(arg) => {
+            send_message(&*SocketMessage::ChangeLayout(arg.default_layout).as_bytes()?)?;
+        }
+        SubCommand::LoadCustomLayout(arg) => {
+            send_message(
+                &*SocketMessage::ChangeLayoutCustom(resolve_windows_path(&arg.path)?).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()?)?;
@@ -412,6 +765,12 @@ fn main() -> Result<()> {
        SubCommand::FocusWorkspace(arg) => {
            send_message(&*SocketMessage::FocusWorkspaceNumber(arg.target).as_bytes()?)?;
        }
+        SubCommand::CycleMonitor(arg) => {
+            send_message(&*SocketMessage::CycleFocusMonitor(arg.cycle_direction).as_bytes()?)?;
+        }
+        SubCommand::CycleWorkspace(arg) => {
+            send_message(&*SocketMessage::CycleFocusWorkspace(arg.cycle_direction).as_bytes()?)?;
+        }
        SubCommand::NewWorkspace => {
            send_message(&*SocketMessage::NewWorkspace.as_bytes()?)?;
        }
@@ -428,7 +787,7 @@ fn main() -> Result<()> {
            )?;
        }
        SubCommand::State => {
-            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 socket = home;
            socket.push("komorebic.sock");
            let socket = socket.as_path();
@@ -451,18 +810,53 @@ 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().ok_or_else(|| anyhow!("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);
                }
            }
        }
        SubCommand::RestoreWindows => {
-            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 = File::open(hwnd_json)?;
@@ -482,7 +876,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,11 +896,88 @@ fn main() -> Result<()> {
                    .as_bytes()?,
            )?;
        }
+        SubCommand::IdentifyBorderOverflow(target) => {
+            send_message(
+                &*SocketMessage::IdentifyBorderOverflow(target.identifier, target.id).as_bytes()?,
+            )?;
+        }
+        SubCommand::RemoveTitleBar(target) => {
+            match target.identifier {
+                ApplicationIdentifier::Exe => {}
+                _ => {
+                    return Err(anyhow!(
+                        "this command requires applications to be identified by their exe"
+                    ))
+                }
+            }
+
+            send_message(
+                &*SocketMessage::RemoveTitleBar(target.identifier, target.id).as_bytes()?,
+            )?;
+        }
+        SubCommand::ToggleTitleBars => {
+            send_message(&*SocketMessage::ToggleTitleBars.as_bytes()?)?;
+        }
+        SubCommand::Manage => {
+            send_message(&*SocketMessage::ManageFocusedWindow.as_bytes()?)?;
+        }
+        SubCommand::Unmanage => {
+            send_message(&*SocketMessage::UnmanageFocusedWindow.as_bytes()?)?;
+        }
+        SubCommand::QuickSave => {
+            send_message(&*SocketMessage::QuickSave.as_bytes()?)?;
+        }
+        SubCommand::QuickLoad => {
+            send_message(&*SocketMessage::QuickLoad.as_bytes()?)?;
+        }
+        SubCommand::Save(arg) => {
+            send_message(&*SocketMessage::Save(resolve_windows_path(&arg.path)?).as_bytes()?)?;
+        }
+        SubCommand::Load(arg) => {
+            send_message(&*SocketMessage::Load(resolve_windows_path(&arg.path)?).as_bytes()?)?;
+        }
+        SubCommand::Subscribe(arg) => {
+            send_message(&*SocketMessage::AddSubscriber(arg.named_pipe).as_bytes()?)?;
+        }
+        SubCommand::Unsubscribe(arg) => {
+            send_message(&*SocketMessage::RemoveSubscriber(arg.named_pipe).as_bytes()?)?;
+        }
    }

    Ok(())
 }

+fn resolve_windows_path(raw_path: &str) -> Result<PathBuf> {
+    let path = if raw_path.starts_with('~') {
+        raw_path.replacen(
+            "~",
+            &dirs::home_dir()
+                .ok_or_else(|| anyhow!("there is no home directory"))?
+                .display()
+                .to_string(),
+            1,
+        )
+    } else {
+        raw_path.to_string()
+    };
+
+    let full_path = PathBuf::from(path);
+
+    let parent = full_path
+        .parent()
+        .ok_or_else(|| anyhow!("cannot parse directory"))?;
+
+    let file = full_path
+        .components()
+        .last()
+        .ok_or_else(|| anyhow!("cannot parse filename"))?;
+
+    let mut canonicalized = std::fs::canonicalize(parent)?;
+    canonicalized.push(file);
+
+    Ok(canonicalized)
+}
+
 fn show_window(hwnd: HWND, command: SHOW_WINDOW_CMD) {
    // BOOL is returned but does not signify whether or not the operation was succesful
    // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-showwindow
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -0,0 +1 @@
+imports_granularity = "Item"