feat(borders): add border manager module

This commit removes all border-related code from process_command, process_event etc. and centralizes it in the new border_manager module. Instead of trying to figure out where in process_event and process_command we should make border-related changes, a notification gets sent to a channel that border_manager listens to whenever an event or command has finished processing. The border_manager listener, upon receiving a notification, acquires a lock on the WindowManager instance and updates borders for the focused workspace on every monitor; this allows us to centralize all edge case handling within the border_manager listener's loop. Borders on workspaces that lose focus are now destroyed and recreated when those workspaces regain focus, instead of trying to share individual border instances across workspaces. A number of common edge cases that have been addressed in this commit are: * Paused window manager * Floating workspaces * Maximized windows * Fullscreen videos * Monocle containers * Ghost borders on workspace switching * Incorrect focused window border colours Global state related to borders has also been moved into the border_manager module, which also tracks the state of border objects (BORDER_STATE), their rects (RECT_STATE) and their focus kinds (FOCUS_STATE). This allows us to now track multiple borders per-container, enabling unfocused border windows for the first time. Additionally, the Z-Order for border windows is now also configurable. ActiveWindowBorderColours has been expanded to include Unfocused, but in order to not introduce a breaking configuration change for end users, all members of this struct have been made Option<Colour>.
2026-02-10 07:17:41 +01:00 · 2024-05-11 17:44:06 -07:00
44 changed files with 1115 additions and 2077 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,21 +26,6 @@ dependencies = [
 "memchr",
 ]

-[[package]]
-name = "android-tzdata"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
-
-[[package]]
-name = "android_system_properties"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "anstream"
 version = "0.6.13"
@@ -182,20 +167,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"

-[[package]]
-name = "chrono"
-version = "0.4.38"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401"
-dependencies = [
- "android-tzdata",
- "iana-time-zone",
- "js-sys",
- "num-traits",
- "wasm-bindgen",
- "windows-targets 0.52.5",
-]
-
 [[package]]
 name = "clap"
 version = "4.5.4"
@@ -752,29 +723,6 @@ dependencies = [
 "tracing",
 ]

-[[package]]
-name = "iana-time-zone"
-version = "0.1.60"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
-dependencies = [
- "android_system_properties",
- "core-foundation-sys",
- "iana-time-zone-haiku",
- "js-sys",
- "wasm-bindgen",
- "windows-core 0.52.0",
-]
-
-[[package]]
-name = "iana-time-zone-haiku"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "idna"
 version = "0.5.0"
@@ -833,15 +781,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45"

-[[package]]
-name = "itertools"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itoa"
 version = "1.0.11"
@@ -891,7 +830,6 @@ dependencies = [
 "uds_windows",
 "which",
 "widestring",
- "win32-display-data",
 "windows 0.54.0",
 "windows-implement",
 "windows-interface",
@@ -929,7 +867,6 @@ dependencies = [
 name = "komorebic"
 version = "0.1.26-dev.0"
 dependencies = [
- "chrono",
 "clap",
 "color-eyre",
 "derive-ahk",
@@ -1220,15 +1157,6 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"

-[[package]]
-name = "num-traits"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "num_cpus"
 version = "1.16.0"
@@ -2475,16 +2403,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7219d36b6eac893fa81e84ebe06485e7dcbb616177469b142df14f1f4deb1311"

-[[package]]
-name = "win32-display-data"
-version = "0.1.0"
-source = "git+https://github.com/LGUG2Z/win32-display-data#2c47b9f1ca1f359ba2481d0b6ea8667ccd9d075c"
-dependencies = [
- "itertools",
- "thiserror",
- "windows 0.54.0",
-]
-
 [[package]]
 name = "winapi"
 version = "0.3.9"
--- a/docs/cli/active-window-border-colour.md
+++ b/docs/cli/active-window-border-colour.md
@@ -0,0 +1,26 @@
+# active-window-border-colour
+
+```
+Set the colour for the active window border
+
+Usage: komorebic.exe active-window-border-colour [OPTIONS] <R> <G> <B>
+
+Arguments:
+  <R>
+          Red
+
+  <G>
+          Green
+
+  <B>
+          Blue
+
+Options:
+  -w, --window-kind <WINDOW_KIND>
+          [default: single]
+          [possible values: single, stack, monocle]
+
+  -h, --help
+          Print help
+
+```
--- a/docs/cli/active-window-border-offset.md
+++ b/docs/cli/active-window-border-offset.md
@@ -0,0 +1,16 @@
+# active-window-border-offset
+
+```
+Set the offset for the active window border
+
+Usage: komorebic.exe active-window-border-offset <OFFSET>
+
+Arguments:
+  <OFFSET>
+          Desired offset of the active window border
+
+Options:
+  -h, --help
+          Print help
+
+```
--- a/docs/cli/active-window-border-width.md
+++ b/docs/cli/active-window-border-width.md
@@ -0,0 +1,16 @@
+# active-window-border-width
+
+```
+Set the width for the active window border
+
+Usage: komorebic.exe active-window-border-width <WIDTH>
+
+Arguments:
+  <WIDTH>
+          Desired width of the active window border
+
+Options:
+  -h, --help
+          Print help
+
+```
--- a/docs/cli/active-window-border.md
+++ b/docs/cli/active-window-border.md
@@ -1,9 +1,9 @@
-# border
+# active-window-border

 ```
-Enable or disable borders
+Enable or disable the active window border

-Usage: komorebic.exe border <BOOLEAN_STATE>
+Usage: komorebic.exe active-window-border <BOOLEAN_STATE>

 Arguments:
  <BOOLEAN_STATE>
--- a/docs/cli/border-colour.md
+++ b/docs/cli/border-colour.md
@@ -1,26 +0,0 @@
-# border-colour
-
-```
-Set the colour for a window border kind
-
-Usage: komorebic.exe border-colour [OPTIONS] <R> <G> <B>
-
-Arguments:
-  <R>
-          Red
-
-  <G>
-          Green
-
-  <B>
-          Blue
-
-Options:
-  -w, --window-kind <WINDOW_KIND>
-          [default: single]
-          [possible values: single, stack, monocle, unfocused]
-
-  -h, --help
-          Print help
-
-```
--- a/docs/cli/border-offset.md
+++ b/docs/cli/border-offset.md
@@ -1,16 +0,0 @@
-# border-offset
-
-```
-Set the border offset
-
-Usage: komorebic.exe border-offset <OFFSET>
-
-Arguments:
-  <OFFSET>
-          Desired offset of the window border
-
-Options:
-  -h, --help
-          Print help
-
-```
--- a/docs/cli/border-width.md
+++ b/docs/cli/border-width.md
@@ -1,16 +0,0 @@
-# border-width
-
-```
-Set the border width
-
-Usage: komorebic.exe border-width <WIDTH>
-
-Arguments:
-  <WIDTH>
-          Desired width of the window border
-
-Options:
-  -h, --help
-          Print help
-
-```
--- a/docs/cli/cross-monitor-move-behaviour.md
+++ b/docs/cli/cross-monitor-move-behaviour.md
@@ -10,7 +10,6 @@ Arguments:
          Possible values:
          - swap:   Swap the window container with the window container at the edge of the adjacent monitor
          - insert: Insert the window container into the focused workspace on the adjacent monitor
-          - no-op:  Do nothing if trying to move a window container in the direction of an adjacent monitor

 Options:
  -h, --help
--- a/docs/common-workflows/active-window-border.md
+++ b/docs/common-workflows/active-window-border.md
@@ -0,0 +1,39 @@
+# Active Window Border
+
+If you would like to add a visual border around the currently focused window,
+ensure the following options are defined in the `komorebi.json` configuration
+file.
+
+```json
+{
+  "active_window_border": true,
+  "active_window_border_style": "Rounded",
+  "active_window_border_colours": {
+    "single": {
+      "r": 66,
+      "g": 165,
+      "b": 245
+    },
+    "stack": {
+      "r": 256,
+      "g": 165,
+      "b": 66
+    },
+    "monocle": {
+      "r": 255,
+      "g": 51,
+      "b": 153
+    }
+  },
+}
+
+```
+
+It is important to note that the active window border will only apply to
+windows managed by `komorebi`.
+
+This feature is not considered stable, and you may encounter visual artifacts
+from time to time.
+
+[![Watch the tutorial
+video](https://img.youtube.com/vi/7_9D22t7KK4/hqdefault.jpg)](https://www.youtube.com/watch?v=7_9D22t7KK4)
--- a/docs/common-workflows/autohotkey.md
+++ b/docs/common-workflows/autohotkey.md
@@ -1,5 +1,7 @@
 # AutoHotKey

+<!-- TODO: Update this completely -->
+
 If you would like to use Autohotkey, please make sure you have AutoHotKey v2
 installed.

@@ -7,16 +9,19 @@ Generally, users who opt for AHK will have specific needs that can only be
 addressed by the advanced functionality of AHK, and so they are assumed to be
 able to craft their own configuration files.

-If you would like to try out AHK, here is a simple sample configuration which
-largely matches the `whkdrc` sample configuration.
+If you would like to try out AHK, a simple sample configuration powered by
+`komorebic.lib.ahk` is provided as a starting point. This sample configuration
+does not take into account the use of a static configuration file; if you
+choose to use a static configuration file alongside AHK, you can remove all the
+configuration options from your `komorebi.ahk` and use it solely to handle
+hotkey bindings.

-```
-{% include "../komorebi.ahk" %}
+
+```powershell
+# save the latest generated komorebic library to ~/komorebic.lib.ahk
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.20/komorebic.lib.ahk -OutFile $Env:USERPROFILE\komorebic.lib.ahk
+
+# save the sample komorebi configuration file to ~/komorebi.ahk
+iwr https://raw.githubusercontent.com/LGUG2Z/komorebi/v0.1.20/komorebi.sample.ahk -OutFile $Env:USERPROFILE\komorebi.ahk
 ```

-By default, the `komorebi.ahk` file should be located in the `$Env:USERPROFILE`
-directory, however, if `$Env:KOMOREBI_CONFIG_HOME` is set, it should be located
-there.
-
-Once the file is in place, you can stop komorebi and whkd by running `komorebic stop --whkd`,
-and then start komorebi with Autohotkey by running `komorebic start --ahk`.
--- a/docs/common-workflows/borders.md
+++ b/docs/common-workflows/borders.md
@@ -1,28 +0,0 @@
-# Borders
-
-If you would like to add a visual border around both the currently focused window
-and unfocused windows ensure the following options are defined in the `komorebi.json`
-configuration file.
-
-```json
-{
-  "border": true,
-  "border_width": 8,
-  "border_offset": -1,
-  "border_style": "System",
-  "border_colours": {
-    "single": "#42a5f5",
-    "stack": "#00a542",
-    "monocle": "#ff3399",
-    "unfocused": "#808080"
-  }
-}
-```
-
-It is important to note that borders will only apply to windows managed by `komorebi`.
-
-This feature is not considered stable, and you may encounter visual artifacts
-from time to time.
-
-[![Watch the tutorial
-video](https://img.youtube.com/vi/7_9D22t7KK4/hqdefault.jpg)](https://www.youtube.com/watch?v=7_9D22t7KK4)
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -30,10 +30,10 @@ to manipulate the window manager, you use
 [WinGet](https://winget.run/pkg/LGUG2Z/komorebi), and you may also built
 it from [source](https://github.com/LGUG2Z/komorebi) if you would prefer.

- [Scoop](#scoop)
- [WinGet](#winget)
- [Building from source](#building-from-source)
- [Offline](#offline)
+ - [Scoop](#scoop)
+ - [WinGet](#winget)
+ - [Building from source](#building-from-source)
+ - [Offline](#offline)

 ## Long path support

@@ -45,12 +45,6 @@ running the following command in an Administrator Terminal before installing
 Set-ItemProperty 'HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem' -Name 'LongPathsEnabled' -Value 1
 ```

-## Disabling Unnecessary System Animations
-
-It is highly recommended that you enable the "Turn off all unnecessary animations (when possible)" option in
-"Control Panel > Ease of Access > Ease of Access Centre / Make the computer easier to see" for the best performance with
-komorebi.
-
 ## Scoop

 Make sure you have installed [`scoop`](https://scoop.sh) and verified that
--- a/docs/komorebi.example.json
+++ b/docs/komorebi.example.json
@@ -5,18 +5,17 @@
  "cross_monitor_move_behaviour": "Insert",
  "default_workspace_padding": 20,
  "default_container_padding": 20,
-  "border": true,
  "border_width": 8,
  "border_offset": -1,
-  "border_colours": {
+  "active_window_border": false,
+  "active_window_border_colours": {
    "single": "#42a5f5",
    "stack": "#00a542",
-    "monocle": "#ff3399",
-    "unfocused": "#808080"
+    "monocle": "#ff3399"
  },
  "stackbar": {
    "height": 40,
-    "mode": "OnStack",
+    "mode": "Never",
    "tabs": {
      "width": 300,
      "focused_text": "#00a542",
--- a/docs/whkdrc.sample
+++ b/docs/whkdrc.sample
@@ -10,9 +10,6 @@ alt + shift + o         : komorebic reload-configuration
 # alt + f                 : if ($wshell.AppActivate('Firefox') -eq $False) { start firefox }
 # alt + b                 : if ($wshell.AppActivate('Chrome') -eq $False) { start chrome }

-alt + q                 : komorebic close
-alt + m                 : komorebic minimize
-
 # Focus windows
 alt + h                 : komorebic focus left
 alt + j                 : komorebic focus down
@@ -59,18 +56,8 @@ alt + y                 : komorebic flip-layout vertical
 alt + 1                 : komorebic focus-workspace 0
 alt + 2                 : komorebic focus-workspace 1
 alt + 3                 : komorebic focus-workspace 2
-alt + 4                 : komorebic focus-workspace 3
-alt + 5                 : komorebic focus-workspace 4
-alt + 6                 : komorebic focus-workspace 5
-alt + 7                 : komorebic focus-workspace 6
-alt + 8                 : komorebic focus-workspace 7

 # Move windows across workspaces
 alt + shift + 1         : komorebic move-to-workspace 0
 alt + shift + 2         : komorebic move-to-workspace 1
 alt + shift + 3         : komorebic move-to-workspace 2
-alt + shift + 4         : komorebic move-to-workspace 3
-alt + shift + 5         : komorebic move-to-workspace 4
-alt + shift + 6         : komorebic move-to-workspace 5
-alt + shift + 7         : komorebic move-to-workspace 6
-alt + shift + 8         : komorebic move-to-workspace 7
--- a/8
+++ b/8
@@ -16,12 +16,19 @@ fmt:
 install-target target:
    cargo +stable install --path {{ target }} --locked

+prepare:
+    komorebic ahk-asc '~/.config/komorebi/applications.yaml'
+    komorebic pwsh-asc '~/.config/komorebi/applications.yaml'
+    cat '~/.config/komorebi/komorebi.generated.ps1' >komorebi.generated.ps1
+    cat '~/.config/komorebi/komorebi.generated.ahk' >komorebi.generated.ahk
+
 install:
    just install-target komorebic
    just install-target komorebic-no-console
    just install-target komorebi

 run:
+    just install-target komorebic
    cargo +stable run --bin komorebi --locked

 warn $RUST_LOG="warn":
@@ -37,6 +44,7 @@ trace $RUST_LOG="trace":
    just run

 deadlock $RUST_LOG="trace":
+    just install-komorebic
    cargo +stable run --bin komorebi --locked --features deadlock_detection

 docgen:
--- a/komorebi-client/src/lib.rs
+++ b/komorebi-client/src/lib.rs
@@ -9,7 +9,7 @@ pub use komorebi::ring::Ring;
 pub use komorebi::window::Window;
 pub use komorebi::window_manager_event::WindowManagerEvent;
 pub use komorebi::workspace::Workspace;
-pub use komorebi::BorderColours;
+pub use komorebi::ActiveWindowBorderColours;
 pub use komorebi::GlobalState;
 pub use komorebi::Notification;
 pub use komorebi::NotificationEvent;
@@ -18,9 +18,9 @@ pub use komorebi::StackbarConfig;
 pub use komorebi::State;
 pub use komorebi::StaticConfig;
 pub use komorebi::TabsConfig;
+pub use komorebi_core::ActiveWindowBorderStyle;
 pub use komorebi_core::Arrangement;
 pub use komorebi_core::Axis;
-pub use komorebi_core::BorderStyle;
 pub use komorebi_core::CustomLayout;
 pub use komorebi_core::CycleDirection;
 pub use komorebi_core::DefaultLayout;
--- a/komorebi-core/src/arrangement.rs
+++ b/komorebi-core/src/arrangement.rs
@@ -26,7 +26,7 @@ pub trait Arrangement {
 }

 impl Arrangement for DefaultLayout {
-    #[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
+    #[allow(clippy::too_many_lines)]
    fn calculate(
        &self,
        area: &Rect,
@@ -58,13 +58,12 @@ impl Arrangement for DefaultLayout {
                        layout.right += adjustment.right;
                    });

-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        columns_reverse(&mut layouts);
-                    }
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        2.. => columns_reverse(&mut layouts),
+                        _ => {}
+                    },
+                    _ => {}
                }

                layouts
@@ -83,13 +82,12 @@ impl Arrangement for DefaultLayout {
                        layout.right += adjustment.right;
                    });

-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        rows_reverse(&mut layouts);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        2.. => rows_reverse(&mut layouts),
+                        _ => {}
+                    },
+                    _ => {}
                }

                layouts
@@ -137,28 +135,28 @@ impl Arrangement for DefaultLayout {
                        layout.right += adjustment.right;
                    });

-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        let (primary, rest) = layouts.split_at_mut(1);
-                        let primary = &mut primary[0];
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        2.. => {
+                            let (primary, rest) = layouts.split_at_mut(1);
+                            let primary = &mut primary[0];

-                        for rect in rest.iter_mut() {
-                            rect.left = primary.left;
+                            for rect in rest.iter_mut() {
+                                rect.left = primary.left;
+                            }
+                            primary.left = rest[0].left + rest[0].right;
                        }
-                        primary.left = rest[0].left + rest[0].right;
-                    }
+                        _ => {}
+                    },
+                    _ => {}
                }

-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 3.. = len {
-                        rows_reverse(&mut layouts[1..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        3.. => rows_reverse(&mut layouts[1..]),
+                        _ => {}
+                    },
+                    _ => {}
                }

                layouts
@@ -209,28 +207,28 @@ impl Arrangement for DefaultLayout {
                        layout.right += adjustment.right;
                    });

-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        let (primary, rest) = layouts.split_at_mut(1);
-                        let primary = &mut primary[0];
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        2.. => {
+                            let (primary, rest) = layouts.split_at_mut(1);
+                            let primary = &mut primary[0];

-                        primary.left = rest[0].left;
-                        for rect in rest.iter_mut() {
-                            rect.left = primary.left + primary.right;
+                            primary.left = rest[0].left;
+                            for rect in rest.iter_mut() {
+                                rect.left = primary.left + primary.right;
+                            }
                        }
-                    }
+                        _ => {}
+                    },
+                    _ => {}
                }

-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 3.. = len {
-                        rows_reverse(&mut layouts[1..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        3.. => rows_reverse(&mut layouts[1..]),
+                        _ => {}
+                    },
+                    _ => {}
                }

                layouts
@@ -278,28 +276,28 @@ impl Arrangement for DefaultLayout {
                        layout.right += adjustment.right;
                    });

-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 2.. = len {
-                        let (primary, rest) = layouts.split_at_mut(1);
-                        let primary = &mut primary[0];
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        2.. => {
+                            let (primary, rest) = layouts.split_at_mut(1);
+                            let primary = &mut primary[0];

-                        for rect in rest.iter_mut() {
-                            rect.top = primary.top;
+                            for rect in rest.iter_mut() {
+                                rect.top = primary.top;
+                            }
+                            primary.top = rest[0].top + rest[0].bottom;
                        }
-                        primary.top = rest[0].top + rest[0].bottom;
-                    }
+                        _ => {}
+                    },
+                    _ => {}
                }

-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    if let 3.. = len {
-                        columns_reverse(&mut layouts[1..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
+                        3.. => columns_reverse(&mut layouts[1..]),
+                        _ => {}
+                    },
+                    _ => {}
                }

                layouts
@@ -376,11 +374,8 @@ impl Arrangement for DefaultLayout {
                        layout.right += adjustment.right;
                    });

-                if matches!(
-                    layout_flip,
-                    Some(Axis::Horizontal | Axis::HorizontalAndVertical)
-                ) {
-                    match len {
+                match layout_flip {
+                    Some(Axis::Horizontal | Axis::HorizontalAndVertical) => match len {
                        2 => {
                            let (primary, secondary) = layouts.split_at_mut(1);
                            let primary = &mut primary[0];
@@ -402,20 +397,20 @@ impl Arrangement for DefaultLayout {
                            secondary.left = primary.left + primary.right;
                        }
                        _ => {}
-                    }
+                    },
+                    _ => {}
                }

-                if matches!(
-                    layout_flip,
-                    Some(Axis::Vertical | Axis::HorizontalAndVertical)
-                ) {
-                    if let 4.. = len {
-                        rows_reverse(&mut layouts[2..]);
-                    }
+                match layout_flip {
+                    Some(Axis::Vertical | Axis::HorizontalAndVertical) => match len {
+                        4.. => rows_reverse(&mut layouts[2..]),
+                        _ => {}
+                    },
+                    _ => {}
                }

                layouts
-            }
+            },
            #[allow(
                clippy::cast_precision_loss,
                clippy::cast_possible_truncation,
--- a/komorebi-core/src/lib.rs
+++ b/komorebi-core/src/lib.rs
@@ -59,7 +59,6 @@ pub enum SocketMessage {
    SendContainerToMonitorWorkspaceNumber(usize, usize),
    MoveContainerToMonitorWorkspaceNumber(usize, usize),
    SendContainerToNamedWorkspace(String),
-    CycleMoveWorkspaceToMonitor(CycleDirection),
    MoveWorkspaceToMonitorNumber(usize),
    SwapWorkspacesToMonitorNumber(usize),
    ForceFocus,
@@ -67,7 +66,6 @@ pub enum SocketMessage {
    Minimize,
    Promote,
    PromoteFocus,
-    PromoteWindow(OperationDirection),
    ToggleFloat,
    ToggleMonocle,
    ToggleMaximize,
@@ -132,17 +130,13 @@ pub enum SocketMessage {
    WatchConfiguration(bool),
    CompleteConfiguration,
    AltFocusHack(bool),
-    #[serde(alias = "ActiveWindowBorder")]
-    Border(bool),
-    #[serde(alias = "ActiveWindowBorderColour")]
-    BorderColour(WindowKind, u32, u32, u32),
-    #[serde(alias = "ActiveWindowBorderStyle")]
-    BorderStyle(BorderStyle),
+    ActiveWindowBorder(bool),
+    ActiveWindowBorderColour(WindowKind, u32, u32, u32),
+    ActiveWindowBorderStyle(ActiveWindowBorderStyle),
    BorderWidth(i32),
    BorderOffset(i32),
    InvisibleBorders(Rect),
    StackbarMode(StackbarMode),
-    StackbarLabel(StackbarLabel),
    StackbarFocusedTextColour(u32, u32, u32),
    StackbarUnfocusedTextColour(u32, u32, u32),
    StackbarBackgroundColour(u32, u32, u32),
@@ -204,19 +198,10 @@ pub enum StackbarMode {
    OnStack,
 }

-#[derive(
-    Debug, Copy, Default, Clone, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema,
-)]
-pub enum StackbarLabel {
-    #[default]
-    Process,
-    Title,
-}
-
 #[derive(
    Default, Copy, Clone, Debug, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema,
 )]
-pub enum BorderStyle {
+pub enum ActiveWindowBorderStyle {
    #[default]
    /// Use the system border style
    System,
@@ -298,8 +283,6 @@ pub enum MoveBehaviour {
    Swap,
    /// Insert the window container into the focused workspace on the adjacent monitor
    Insert,
-    /// Do nothing if trying to move a window container in the direction of an adjacent monitor
-    NoOp,
 }

 #[derive(
--- a/komorebi/Cargo.toml
+++ b/komorebi/Cargo.toml
@@ -48,7 +48,5 @@ windows-interface = { workspace = true }
 winput = "0.2"
 winreg = "0.52"

-win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data" }
-
 [features]
 deadlock_detection = []
--- a/komorebi/src/border_manager/border.rs
+++ b/komorebi/src/border_manager/border.rs
@@ -12,14 +12,13 @@ use crate::border_manager::Z_ORDER;
 use crate::WindowsApi;
 use crate::WINDOWS_11;

-use komorebi_core::BorderStyle;
+use komorebi_core::ActiveWindowBorderStyle;
 use komorebi_core::Rect;

 use std::sync::atomic::Ordering;
 use std::sync::mpsc;
 use std::time::Duration;
 use windows::core::PCWSTR;
-use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::COLORREF;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
@@ -48,29 +47,10 @@ use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;

-pub extern "system" fn border_hwnds(hwnd: HWND, lparam: LPARAM) -> BOOL {
-    let hwnds = unsafe { &mut *(lparam.0 as *mut Vec<isize>) };
-
-    if let Ok(class) = WindowsApi::real_window_class_w(hwnd) {
-        if class.starts_with("komoborder") {
-            hwnds.push(hwnd.0);
-        }
-    }
-
-    true.into()
-}
-
-#[derive(Debug)]
 pub struct Border {
    pub hwnd: isize,
 }

-impl From<isize> for Border {
-    fn from(value: isize) -> Self {
-        Self { hwnd: value }
-    }
-}
-
 impl Border {
    pub const fn hwnd(&self) -> HWND {
        HWND(self.hwnd)
@@ -117,7 +97,7 @@ impl Border {
    }

    pub fn destroy(&self) -> color_eyre::Result<()> {
-        WindowsApi::close_window(self.hwnd())
+        WindowsApi::destroy_window(self.hwnd())
    }

    pub fn update(&self, rect: &Rect) -> color_eyre::Result<()> {
@@ -132,10 +112,8 @@ impl Border {
            rects.insert(self.hwnd, rect);
        }

-        // Update the position of the border if required
-        if !WindowsApi::window_rect(self.hwnd())?.eq(&rect) {
-            WindowsApi::set_border_pos(self.hwnd(), &rect, HWND((*Z_ORDER.lock()).into()))?;
-        }
+        // Update the position of the border
+        WindowsApi::set_border_pos(self.hwnd(), &rect, HWND((*Z_ORDER.lock()).into()))?;

        // Invalidate the rect to trigger the callback to update colours etc.
        self.invalidate();
@@ -195,17 +173,17 @@ impl Border {
                        // wrong size.  In the future we should read the DWM properties
                        // of windows and attempt to match appropriately.
                        match *STYLE.lock() {
-                            BorderStyle::System => {
+                            ActiveWindowBorderStyle::System => {
                                if *WINDOWS_11 {
                                    RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
                                } else {
                                    Rectangle(hdc, 0, 0, rect.right, rect.bottom);
                                }
                            }
-                            BorderStyle::Rounded => {
+                            ActiveWindowBorderStyle::Rounded => {
                                RoundRect(hdc, 0, 0, rect.right, rect.bottom, 20, 20);
                            }
-                            BorderStyle::Square => {
+                            ActiveWindowBorderStyle::Square => {
                                Rectangle(hdc, 0, 0, rect.right, rect.bottom);
                            }
                        }
--- a/komorebi/src/border_manager/mod.rs
+++ b/komorebi/src/border_manager/mod.rs
@@ -1,34 +1,27 @@
-#![deny(clippy::unwrap_used, clippy::expect_used)]
-
 mod border;

 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
 use crossbeam_utils::atomic::AtomicConsume;
-use komorebi_core::BorderStyle;
+use komorebi_core::ActiveWindowBorderStyle;
 use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
-use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
 use std::sync::atomic::AtomicU32;
 use std::sync::Arc;
 use std::sync::OnceLock;
-use std::time::Duration;
-use std::time::Instant;
 use windows::Win32::Foundation::HWND;

-use crate::workspace_reconciliator::ALT_TAB_HWND;
 use crate::Colour;
 use crate::Rect;
 use crate::Rgb;
 use crate::WindowManager;
 use crate::WindowsApi;
-use border::border_hwnds;
 use border::Border;
 use komorebi_core::WindowKind;

@@ -39,7 +32,8 @@ pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(true);

 lazy_static! {
    pub static ref Z_ORDER: Arc<Mutex<ZOrder>> = Arc::new(Mutex::new(ZOrder::Bottom));
-    pub static ref STYLE: Arc<Mutex<BorderStyle>> = Arc::new(Mutex::new(BorderStyle::System));
+    pub static ref STYLE: Arc<Mutex<ActiveWindowBorderStyle>> =
+        Arc::new(Mutex::new(ActiveWindowBorderStyle::System));
    pub static ref FOCUSED: AtomicU32 =
        AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(66, 165, 245))));
    pub static ref UNFOCUSED: AtomicU32 =
@@ -72,283 +66,206 @@ pub fn event_rx() -> Receiver<Notification> {
    channel().1.clone()
 }

-pub fn destroy_all_borders() -> color_eyre::Result<()> {
-    let mut borders = BORDER_STATE.lock();
-    tracing::info!(
-        "purging known borders: {:?}",
-        borders.iter().map(|b| b.1.hwnd).collect::<Vec<_>>()
-    );
-
-    for (_, border) in borders.iter() {
-        border.destroy()?;
-    }
-
-    borders.clear();
-    RECT_STATE.lock().clear();
-    BORDERS_MONITORS.lock().clear();
-    FOCUS_STATE.lock().clear();
-
-    let mut remaining_hwnds = vec![];
-
-    WindowsApi::enum_windows(
-        Some(border_hwnds),
-        &mut remaining_hwnds as *mut Vec<isize> as isize,
-    )?;
-
-    if !remaining_hwnds.is_empty() {
-        tracing::info!("purging unknown borders: {:?}", remaining_hwnds);
-
-        for hwnd in remaining_hwnds {
-            Border::from(hwnd).destroy()?;
-        }
-    }
-
-    Ok(())
-}
-
 pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || loop {
-        match handle_notifications(wm.clone()) {
-            Ok(()) => {
-                tracing::warn!("restarting finished thread");
-            }
-            Err(error) => {
-                tracing::warn!("restarting failed thread: {}", error);
-            }
-        }
-    });
-}
-
-pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
    tracing::info!("listening");
-
    let receiver = event_rx();
-    let mut instant: Option<Instant> = None;
-    event_tx().send(Notification)?;

-    'receiver: for _ in receiver {
-        if let Some(instant) = instant {
-            if instant.elapsed().lt(&Duration::from_millis(50)) {
+    std::thread::spawn(move || -> color_eyre::Result<()> {
+        'receiver: for _ in receiver {
+            let mut borders = BORDER_STATE.lock();
+            let mut borders_monitors = BORDERS_MONITORS.lock();
+
+            // Check the wm state every time we receive a notification
+            let state = wm.lock();
+
+            if !BORDER_ENABLED.load_consume() || state.is_paused {
+                if !borders.is_empty() {
+                    for (_, border) in borders.iter() {
+                        border.destroy()?;
+                    }
+
+                    borders.clear();
+                }
+
                continue 'receiver;
            }
-        }

-        instant = Some(Instant::now());
+            let focused_monitor_idx = state.focused_monitor_idx();

-        let mut borders = BORDER_STATE.lock();
-        let mut borders_monitors = BORDERS_MONITORS.lock();
-
-        // Check the wm state every time we receive a notification
-        let state = wm.lock();
-
-        // If borders are disabled
-        if !BORDER_ENABLED.load_consume()
-           // Or if the wm is paused
-            || state.is_paused
-            // Or if we are handling an alt-tab across workspaces
-            || ALT_TAB_HWND.load().is_some()
-        {
-            // Destroy the borders we know about
-            for (_, border) in borders.iter() {
-                border.destroy()?;
-            }
-
-            borders.clear();
-            continue 'receiver;
-        }
-
-        let focused_monitor_idx = state.focused_monitor_idx();
-
-        'monitors: for (monitor_idx, m) in state.monitors.elements().iter().enumerate() {
-            // Only operate on the focused workspace of each monitor
-            if let Some(ws) = m.focused_workspace() {
-                // Workspaces with tiling disabled don't have borders
-                if !ws.tile() {
-                    let mut to_remove = vec![];
-                    for (id, border) in borders.iter() {
-                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
-                            border.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        borders.remove(id);
-                    }
-
-                    continue 'receiver;
-                }
-
-                // Handle the monocle container separately
-                if let Some(monocle) = ws.monocle_container() {
-                    let border = match borders.entry(monocle.id().clone()) {
-                        Entry::Occupied(entry) => entry.into_mut(),
-                        Entry::Vacant(entry) => {
-                            if let Ok(border) = Border::create(monocle.id()) {
-                                entry.insert(border)
-                            } else {
-                                continue 'receiver;
-                            }
-                        }
-                    };
-
-                    borders_monitors.insert(monocle.id().clone(), monitor_idx);
-
-                    {
-                        let mut focus_state = FOCUS_STATE.lock();
-                        focus_state.insert(
-                            border.hwnd,
-                            if monitor_idx != focused_monitor_idx {
-                                WindowKind::Unfocused
-                            } else {
-                                WindowKind::Monocle
-                            },
-                        );
-                    }
-
-                    let rect = WindowsApi::window_rect(
-                        monocle.focused_window().copied().unwrap_or_default().hwnd(),
-                    )?;
-
-                    border.update(&rect)?;
-
-                    let border_hwnd = border.hwnd;
-                    let mut to_remove = vec![];
-                    for (id, b) in borders.iter() {
-                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
-                            && border_hwnd != b.hwnd
-                        {
-                            b.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        borders.remove(id);
-                    }
-                    continue 'monitors;
-                }
-
-                let is_maximized = WindowsApi::is_zoomed(HWND(
-                    WindowsApi::foreground_window().unwrap_or_default(),
-                ));
-
-                if is_maximized {
-                    let mut to_remove = vec![];
-                    for (id, border) in borders.iter() {
-                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
-                            border.destroy()?;
-                            to_remove.push(id.clone());
-                        }
-                    }
-
-                    for id in &to_remove {
-                        borders.remove(id);
-                    }
-
-                    continue 'monitors;
-                }
-
-                // Destroy any borders not associated with the focused workspace
-                let container_ids = ws
-                    .containers()
-                    .iter()
-                    .map(|c| c.id().clone())
-                    .collect::<Vec<_>>();
-
-                let mut to_remove = vec![];
-                for (id, border) in borders.iter() {
-                    if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
-                        && !container_ids.contains(id)
-                    {
-                        border.destroy()?;
-                        to_remove.push(id.clone());
-                    }
-                }
-
-                for id in &to_remove {
-                    borders.remove(id);
-                }
-
-                for (idx, c) in ws.containers().iter().enumerate() {
-                    // Update border when moving or resizing with mouse
-                    if state.pending_move_op.is_some() && idx == ws.focused_container_idx() {
-                        let restore_z_order = *Z_ORDER.lock();
-                        *Z_ORDER.lock() = ZOrder::TopMost;
-
-                        let mut rect = WindowsApi::window_rect(
-                            c.focused_window().copied().unwrap_or_default().hwnd(),
-                        )?;
-
-                        while WindowsApi::lbutton_is_pressed() {
-                            let border = match borders.entry(c.id().clone()) {
-                                Entry::Occupied(entry) => entry.into_mut(),
-                                Entry::Vacant(entry) => {
-                                    if let Ok(border) = Border::create(c.id()) {
-                                        entry.insert(border)
-                                    } else {
-                                        continue 'receiver;
-                                    }
-                                }
-                            };
-
-                            let new_rect = WindowsApi::window_rect(
-                                c.focused_window().copied().unwrap_or_default().hwnd(),
-                            )?;
-
-                            if rect != new_rect {
-                                rect = new_rect;
-                                border.update(&rect)?;
+            for (monitor_idx, m) in state.monitors.elements().iter().enumerate() {
+                // Only operate on the focused workspace of each monitor
+                if let Some(ws) = m.focused_workspace() {
+                    // Workspaces with tiling disabled don't have borders
+                    if !ws.tile() {
+                        let mut to_remove = vec![];
+                        for (id, border) in borders.iter() {
+                            if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+                            {
+                                border.destroy()?;
+                                to_remove.push(id.clone());
                            }
                        }

-                        *Z_ORDER.lock() = restore_z_order;
+                        for id in &to_remove {
+                            borders.remove(id);
+                        }

                        continue 'receiver;
                    }

-                    // Get the border entry for this container from the map or create one
-                    let border = match borders.entry(c.id().clone()) {
-                        Entry::Occupied(entry) => entry.into_mut(),
-                        Entry::Vacant(entry) => {
-                            if let Ok(border) = Border::create(c.id()) {
-                                entry.insert(border)
-                            } else {
-                                continue 'receiver;
+                    // Handle the monocle container separately
+                    if let Some(monocle) = ws.monocle_container() {
+                        let mut to_remove = vec![];
+                        for (id, border) in borders.iter() {
+                            if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+                            {
+                                border.destroy()?;
+                                to_remove.push(id.clone());
                            }
                        }
-                    };

-                    borders_monitors.insert(c.id().clone(), monitor_idx);
+                        for id in &to_remove {
+                            borders.remove(id);
+                        }

-                    // Update the focused state for all containers on this workspace
-                    {
-                        let mut focus_state = FOCUS_STATE.lock();
-                        focus_state.insert(
-                            border.hwnd,
-                            if idx != ws.focused_container_idx()
-                                || monitor_idx != focused_monitor_idx
-                            {
-                                WindowKind::Unfocused
-                            } else if c.windows().len() > 1 {
-                                WindowKind::Stack
-                            } else {
-                                WindowKind::Single
-                            },
-                        );
+                        let border = borders.entry(monocle.id().clone()).or_insert_with(|| {
+                            Border::create(monocle.id()).expect("border creation failed")
+                        });
+
+                        borders_monitors.insert(monocle.id().clone(), monitor_idx);
+
+                        {
+                            let mut focus_state = FOCUS_STATE.lock();
+                            focus_state.insert(border.hwnd, WindowKind::Monocle);
+                        }
+
+                        let rect = WindowsApi::window_rect(
+                            monocle
+                                .focused_window()
+                                .expect("monocle container has no focused window")
+                                .hwnd(),
+                        )?;
+
+                        border.update(&rect)?;
+                        continue 'receiver;
                    }

-                    let rect = WindowsApi::window_rect(
-                        c.focused_window().copied().unwrap_or_default().hwnd(),
-                    )?;
+                    let is_maximized = WindowsApi::is_zoomed(HWND(
+                        WindowsApi::foreground_window().unwrap_or_default(),
+                    ));

-                    border.update(&rect)?;
+                    if is_maximized {
+                        let mut to_remove = vec![];
+                        for (id, border) in borders.iter() {
+                            if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
+                            {
+                                border.destroy()?;
+                                to_remove.push(id.clone());
+                            }
+                        }
+
+                        for id in &to_remove {
+                            borders.remove(id);
+                        }
+
+                        continue 'receiver;
+                    }
+
+                    // Destroy any borders not associated with the focused workspace
+                    let container_ids = ws
+                        .containers()
+                        .iter()
+                        .map(|c| c.id().clone())
+                        .collect::<Vec<_>>();
+
+                    let mut to_remove = vec![];
+                    for (id, border) in borders.iter() {
+                        if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx {
+                            if !container_ids.contains(id) {
+                                border.destroy()?;
+                                to_remove.push(id.clone());
+                            }
+                        }
+                    }
+
+                    for id in &to_remove {
+                        borders.remove(id);
+                    }
+
+                    for (idx, c) in ws.containers().iter().enumerate() {
+                        // Update border when moving or resizing with mouse
+                        if state.pending_move_op.is_some() && idx == ws.focused_container_idx() {
+                            let restore_z_order = *Z_ORDER.lock();
+                            *Z_ORDER.lock() = ZOrder::TopMost;
+
+                            let mut rect = WindowsApi::window_rect(
+                                c.focused_window()
+                                    .expect("container has no focused window")
+                                    .hwnd(),
+                            )?;
+
+                            while WindowsApi::lbutton_is_pressed() {
+                                let border = borders.entry(c.id().clone()).or_insert_with(|| {
+                                    Border::create(c.id()).expect("border creation failed")
+                                });
+
+                                let new_rect = WindowsApi::window_rect(
+                                    c.focused_window()
+                                        .expect("container has no focused window")
+                                        .hwnd(),
+                                )?;
+
+                                if rect != new_rect {
+                                    rect = new_rect;
+                                    border.update(&rect)?;
+                                }
+                            }
+
+                            *Z_ORDER.lock() = restore_z_order;
+
+                            continue 'receiver;
+                        }
+
+                        // Get the border entry for this container from the map or create one
+                        let border = borders.entry(c.id().clone()).or_insert_with(|| {
+                            Border::create(c.id()).expect("border creation failed")
+                        });
+
+                        borders_monitors.insert(c.id().clone(), monitor_idx);
+
+                        // Update the focused state for all containers on this workspace
+                        {
+                            let mut focus_state = FOCUS_STATE.lock();
+                            focus_state.insert(
+                                border.hwnd,
+                                if idx != ws.focused_container_idx()
+                                    || monitor_idx != focused_monitor_idx
+                                {
+                                    WindowKind::Unfocused
+                                } else {
+                                    if c.windows().len() > 1 {
+                                        WindowKind::Stack
+                                    } else {
+                                        WindowKind::Single
+                                    }
+                                },
+                            );
+                        }
+
+                        let rect = WindowsApi::window_rect(
+                            c.focused_window()
+                                .expect("container has no focused window")
+                                .hwnd(),
+                        )?;
+
+                        border.update(&rect)?;
+                    }
                }
            }
        }
-    }

-    Ok(())
+        Ok(())
+    });
 }

 #[derive(Debug, Copy, Clone, Serialize, Deserialize, JsonSchema)]
@@ -359,9 +276,9 @@ pub enum ZOrder {
    TopMost,
 }

-impl From<ZOrder> for isize {
-    fn from(val: ZOrder) -> Self {
-        match val {
+impl Into<isize> for ZOrder {
+    fn into(self) -> isize {
+        match self {
            ZOrder::Top => 0,
            ZOrder::NoTopMost => -2,
            ZOrder::Bottom => 1,
--- a/komorebi/src/container.rs
+++ b/komorebi/src/container.rs
@@ -30,7 +30,7 @@ impl Default for Container {
        Self {
            id: nanoid!(),
            windows: Ring::default(),
-            stackbar: match STACKBAR_MODE.load() {
+            stackbar: match *STACKBAR_MODE.lock() {
                StackbarMode::Always => Stackbar::create().ok(),
                StackbarMode::Never | StackbarMode::OnStack => None,
            },
@@ -124,7 +124,7 @@ impl Container {
    pub fn remove_window_by_idx(&mut self, idx: usize) -> Option<Window> {
        let window = self.windows_mut().remove(idx);

-        if matches!(STACKBAR_MODE.load(), StackbarMode::OnStack) && self.windows().len() <= 1 {
+        if matches!(*STACKBAR_MODE.lock(), StackbarMode::OnStack) && self.windows().len() <= 1 {
            if let Some(stackbar) = &self.stackbar {
                let _ = WindowsApi::close_window(stackbar.hwnd());
                self.stackbar = None;
@@ -146,7 +146,7 @@ impl Container {
    pub fn add_window(&mut self, window: Window) {
        self.windows_mut().push_back(window);

-        if matches!(STACKBAR_MODE.load(), StackbarMode::OnStack)
+        if matches!(*STACKBAR_MODE.lock(), StackbarMode::OnStack)
            && self.windows().len() > 1
            && self.stackbar.is_none()
        {
--- a/komorebi/src/hidden.rs
+++ b/komorebi/src/hidden.rs
@@ -0,0 +1,75 @@
+use std::sync::atomic::Ordering;
+
+use color_eyre::Result;
+use windows::core::PCWSTR;
+use windows::Win32::Foundation::HWND;
+use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
+use windows::Win32::UI::WindowsAndMessaging::FindWindowW;
+use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
+use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
+use windows::Win32::UI::WindowsAndMessaging::MSG;
+use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
+
+use crate::windows_callbacks;
+use crate::WindowsApi;
+use crate::HIDDEN_HWND;
+
+#[derive(Debug, Clone, Copy)]
+pub struct Hidden {
+    pub(crate) hwnd: isize,
+}
+
+impl From<isize> for Hidden {
+    fn from(hwnd: isize) -> Self {
+        Self { hwnd }
+    }
+}
+
+impl Hidden {
+    pub const fn hwnd(self) -> HWND {
+        HWND(self.hwnd)
+    }
+
+    pub fn create(name: &str) -> Result<()> {
+        let name: Vec<u16> = format!("{name}\0").encode_utf16().collect();
+        let instance = WindowsApi::module_handle_w()?;
+        let class_name = PCWSTR(name.as_ptr());
+        let brush = WindowsApi::create_solid_brush(0);
+        let window_class = WNDCLASSW {
+            hInstance: instance.into(),
+            lpszClassName: class_name,
+            style: CS_HREDRAW | CS_VREDRAW,
+            lpfnWndProc: Some(windows_callbacks::hidden_window),
+            hbrBackground: brush,
+            ..Default::default()
+        };
+
+        let _atom = WindowsApi::register_class_w(&window_class)?;
+
+        let name_cl = name.clone();
+        std::thread::spawn(move || -> Result<()> {
+            let hwnd = WindowsApi::create_hidden_window(PCWSTR(name_cl.as_ptr()), instance)?;
+            let hidden = Self::from(hwnd);
+
+            let mut message = MSG::default();
+
+            unsafe {
+                while GetMessageW(&mut message, hidden.hwnd(), 0, 0).into() {
+                    DispatchMessageW(&message);
+                }
+            }
+
+            Ok(())
+        });
+
+        let mut hwnd = HWND(0);
+        while hwnd == HWND(0) {
+            hwnd = unsafe { FindWindowW(PCWSTR(name.as_ptr()), PCWSTR::null()) };
+        }
+
+        HIDDEN_HWND.store(hwnd.0, Ordering::SeqCst);
+
+        Ok(())
+    }
+}
--- a/komorebi/src/lib.rs
+++ b/komorebi/src/lib.rs
@@ -4,8 +4,8 @@ pub mod com;
 pub mod ring;
 pub mod colour;
 pub mod container;
+pub mod hidden;
 pub mod monitor;
-pub mod monitor_reconciliator;
 pub mod process_command;
 pub mod process_event;
 pub mod process_movement;
@@ -21,7 +21,6 @@ pub mod windows_callbacks;
 pub mod winevent;
 pub mod winevent_listener;
 pub mod workspace;
-pub mod workspace_reconciliator;

 use lazy_static::lazy_static;
 use std::collections::HashMap;
@@ -33,11 +32,13 @@ use std::path::PathBuf;
 use std::process::Command;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicI32;
+use std::sync::atomic::AtomicIsize;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;

 pub use colour::*;
+pub use hidden::*;
 pub use process_command::*;
 pub use process_event::*;
 pub use stackbar::*;
@@ -49,7 +50,6 @@ pub use windows_api::WindowsApi;
 pub use windows_api::*;

 use color_eyre::Result;
-use crossbeam_utils::atomic::AtomicCell;
 use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
@@ -57,7 +57,6 @@ use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
 use komorebi_core::Rect;
 use komorebi_core::SocketMessage;
-use komorebi_core::StackbarLabel;
 use komorebi_core::StackbarMode;
 use os_info::Version;
 use parking_lot::Mutex;
@@ -201,6 +200,7 @@ lazy_static! {
    // eg. Windows Terminal, IntelliJ IDEA, Firefox
    static ref NO_TITLEBAR: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![]));

+    static ref STACKBAR_MODE: Arc<Mutex<StackbarMode >> = Arc::new(Mutex::new(StackbarMode::Never));
    static ref WINDOWS_BY_BAR_HWNDS: Arc<Mutex<HashMap<isize, VecDeque<isize>>>> =
        Arc::new(Mutex::new(HashMap::new()));

@@ -215,13 +215,13 @@ pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);

 pub static REMOVE_TITLEBARS: AtomicBool = AtomicBool::new(false);

+pub static HIDDEN_HWND: AtomicIsize = AtomicIsize::new(0);
+
 pub static STACKBAR_FOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(16777215); // white
 pub static STACKBAR_UNFOCUSED_TEXT_COLOUR: AtomicU32 = AtomicU32::new(11776947); // gray text
 pub static STACKBAR_TAB_BACKGROUND_COLOUR: AtomicU32 = AtomicU32::new(3355443); // gray
 pub static STACKBAR_TAB_HEIGHT: AtomicI32 = AtomicI32::new(40);
 pub static STACKBAR_TAB_WIDTH: AtomicI32 = AtomicI32::new(200);
-pub static STACKBAR_LABEL: AtomicCell<StackbarLabel> = AtomicCell::new(StackbarLabel::Process);
-pub static STACKBAR_MODE: AtomicCell<StackbarMode> = AtomicCell::new(StackbarMode::Never);

 #[must_use]
 pub fn current_virtual_desktop() -> Option<Vec<u8>> {
--- a/komorebi/src/main.rs
+++ b/komorebi/src/main.rs
@@ -24,8 +24,8 @@ use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::EnvFilter;

 use komorebi::border_manager;
+use komorebi::hidden::Hidden;
 use komorebi::load_configuration;
-use komorebi::monitor_reconciliator;
 use komorebi::process_command::listen_for_commands;
 use komorebi::process_command::listen_for_commands_tcp;
 use komorebi::process_event::listen_for_events;
@@ -34,7 +34,6 @@ use komorebi::static_config::StaticConfig;
 use komorebi::window_manager::WindowManager;
 use komorebi::windows_api::WindowsApi;
 use komorebi::winevent_listener;
-use komorebi::workspace_reconciliator;
 use komorebi::CUSTOM_FFM;
 use komorebi::DATA_DIR;
 use komorebi::HOME_DIR;
@@ -52,8 +51,8 @@ fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
        std::env::set_var("RUST_LOG", "info");
    }

-    let appender = tracing_appender::rolling::daily(std::env::temp_dir(), "komorebi_plaintext.log");
-    let color_appender = tracing_appender::rolling::daily(std::env::temp_dir(), "komorebi.log");
+    let appender = tracing_appender::rolling::never(std::env::temp_dir(), "komorebi_plaintext.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);

@@ -188,6 +187,8 @@ fn main() -> Result<()> {
    #[cfg(feature = "deadlock_detection")]
    detect_deadlocks();

+    Hidden::create("komorebi-hidden")?;
+
    let static_config = opts.config.map_or_else(
        || {
            let komorebi_json = HOME_DIR.join("komorebi.json");
@@ -254,8 +255,6 @@ fn main() -> Result<()> {
    }

    border_manager::listen_for_notifications(wm.clone());
-    workspace_reconciliator::listen_for_notifications(wm.clone());
-    monitor_reconciliator::listen_for_notifications(wm.clone())?;

    let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
    ctrlc::set_handler(move || {
--- a/komorebi/src/monitor.rs
+++ b/komorebi/src/monitor.rs
@@ -27,19 +27,15 @@ pub struct Monitor {
    #[getset(get = "pub", set = "pub")]
    name: String,
    #[getset(get = "pub", set = "pub")]
-    device: String,
+    device: Option<String>,
    #[getset(get = "pub", set = "pub")]
-    device_id: String,
+    device_id: Option<String>,
    #[getset(get = "pub", set = "pub")]
    size: Rect,
    #[getset(get = "pub", set = "pub")]
    work_area_size: Rect,
    #[getset(get_copy = "pub", set = "pub")]
    work_area_offset: Option<Rect>,
-    #[getset(get_copy = "pub", set = "pub")]
-    window_based_work_area_offset: Option<Rect>,
-    #[getset(get_copy = "pub", set = "pub")]
-    window_based_work_area_offset_limit: isize,
    workspaces: Ring<Workspace>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[getset(get_copy = "pub", set = "pub")]
@@ -50,27 +46,18 @@ pub struct Monitor {

 impl_ring_elements!(Monitor, Workspace);

-pub fn new(
-    id: isize,
-    size: Rect,
-    work_area_size: Rect,
-    name: String,
-    device: String,
-    device_id: String,
-) -> Monitor {
+pub fn new(id: isize, size: Rect, work_area_size: Rect, name: String) -> Monitor {
    let mut workspaces = Ring::default();
    workspaces.elements_mut().push_back(Workspace::default());

    Monitor {
        id,
        name,
-        device,
-        device_id,
+        device: None,
+        device_id: None,
        size,
        work_area_size,
        work_area_offset: None,
-        window_based_work_area_offset: None,
-        window_based_work_area_offset_limit: 1,
        workspaces,
        last_focused_workspace: None,
        workspace_names: HashMap::default(),
@@ -207,11 +194,6 @@ impl Monitor {

    pub fn update_focused_workspace(&mut self, offset: Option<Rect>) -> Result<()> {
        let work_area = *self.work_area_size();
-        let window_based_work_area_offset = (
-            self.window_based_work_area_offset_limit(),
-            self.window_based_work_area_offset(),
-        );
-
        let offset = if self.work_area_offset().is_some() {
            self.work_area_offset()
        } else {
@@ -220,7 +202,7 @@ impl Monitor {

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

        Ok(())
    }
--- a/komorebi/src/monitor_reconciliator/hidden.rs
+++ b/komorebi/src/monitor_reconciliator/hidden.rs
@@ -1,190 +0,0 @@
-use std::sync::mpsc;
-
-use windows::core::PCWSTR;
-use windows::Win32::Foundation::HWND;
-use windows::Win32::Foundation::LPARAM;
-use windows::Win32::Foundation::LRESULT;
-use windows::Win32::Foundation::WPARAM;
-use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
-use windows::Win32::UI::WindowsAndMessaging::DispatchMessageW;
-use windows::Win32::UI::WindowsAndMessaging::GetMessageW;
-use windows::Win32::UI::WindowsAndMessaging::TranslateMessage;
-use windows::Win32::UI::WindowsAndMessaging::CS_HREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::CS_VREDRAW;
-use windows::Win32::UI::WindowsAndMessaging::DBT_DEVNODES_CHANGED;
-use windows::Win32::UI::WindowsAndMessaging::MSG;
-use windows::Win32::UI::WindowsAndMessaging::PBT_APMRESUMEAUTOMATIC;
-use windows::Win32::UI::WindowsAndMessaging::PBT_APMRESUMESUSPEND;
-use windows::Win32::UI::WindowsAndMessaging::PBT_APMSUSPEND;
-use windows::Win32::UI::WindowsAndMessaging::SPI_SETWORKAREA;
-use windows::Win32::UI::WindowsAndMessaging::WM_DEVICECHANGE;
-use windows::Win32::UI::WindowsAndMessaging::WM_DISPLAYCHANGE;
-use windows::Win32::UI::WindowsAndMessaging::WM_POWERBROADCAST;
-use windows::Win32::UI::WindowsAndMessaging::WM_SETTINGCHANGE;
-use windows::Win32::UI::WindowsAndMessaging::WM_WTSSESSION_CHANGE;
-use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
-use windows::Win32::UI::WindowsAndMessaging::WTS_SESSION_LOCK;
-use windows::Win32::UI::WindowsAndMessaging::WTS_SESSION_UNLOCK;
-
-use crate::monitor_reconciliator;
-use crate::WindowsApi;
-
-// This is a hidden window specifically spawned to listen to system-wide events related to monitors
-#[derive(Debug, Clone, Copy)]
-pub struct Hidden {
-    pub hwnd: isize,
-}
-
-impl From<isize> for Hidden {
-    fn from(hwnd: isize) -> Self {
-        Self { hwnd }
-    }
-}
-
-impl Hidden {
-    pub const fn hwnd(self) -> HWND {
-        HWND(self.hwnd)
-    }
-
-    pub fn create(name: &str) -> color_eyre::Result<Self> {
-        let name: Vec<u16> = format!("{name}\0").encode_utf16().collect();
-        let class_name = PCWSTR(name.as_ptr());
-
-        let h_module = WindowsApi::module_handle_w()?;
-        let window_class = WNDCLASSW {
-            hInstance: h_module.into(),
-            lpszClassName: class_name,
-            style: CS_HREDRAW | CS_VREDRAW,
-            lpfnWndProc: Some(Self::callback),
-            hbrBackground: WindowsApi::create_solid_brush(0),
-            ..Default::default()
-        };
-
-        let _ = WindowsApi::register_class_w(&window_class)?;
-
-        let (hwnd_sender, hwnd_receiver) = mpsc::channel();
-
-        std::thread::spawn(move || -> color_eyre::Result<()> {
-            let hwnd = WindowsApi::create_hidden_window(PCWSTR(name.as_ptr()), h_module)?;
-            hwnd_sender.send(hwnd)?;
-
-            let mut message = MSG::default();
-
-            unsafe {
-                while GetMessageW(&mut message, HWND(hwnd), 0, 0).into() {
-                    TranslateMessage(&message);
-                    DispatchMessageW(&message);
-                }
-            }
-
-            Ok(())
-        });
-
-        let hwnd = hwnd_receiver.recv()?;
-
-        WindowsApi::wts_register_session_notification(hwnd)?;
-
-        Ok(Self { hwnd })
-    }
-
-    pub extern "system" fn callback(
-        window: HWND,
-        message: u32,
-        wparam: WPARAM,
-        lparam: LPARAM,
-    ) -> LRESULT {
-        unsafe {
-            match message {
-                WM_POWERBROADCAST => {
-                    match wparam.0 as u32 {
-                        // Automatic: System resumed itself from sleep or hibernation
-                        // Suspend: User resumed system from sleep or hibernation
-                        PBT_APMRESUMEAUTOMATIC | PBT_APMRESUMESUSPEND => {
-                            tracing::debug!(
-                                "WM_POWERBROADCAST event received - resume from suspend"
-                            );
-                            let _ = monitor_reconciliator::event_tx().send(
-                                monitor_reconciliator::Notification::ResumingFromSuspendedState,
-                            );
-                            LRESULT(0)
-                        }
-                        // Computer is entering a suspended state
-                        PBT_APMSUSPEND => {
-                            tracing::debug!(
-                                "WM_POWERBROADCAST event received - entering suspended state"
-                            );
-                            let _ = monitor_reconciliator::event_tx()
-                                .send(monitor_reconciliator::Notification::EnteringSuspendedState);
-                            LRESULT(0)
-                        }
-                        _ => LRESULT(0),
-                    }
-                }
-                WM_WTSSESSION_CHANGE => {
-                    match wparam.0 as u32 {
-                        WTS_SESSION_LOCK => {
-                            tracing::debug!("WM_WTSSESSION_CHANGE event received with WTS_SESSION_LOCK - screen locked");
-
-                            let _ = monitor_reconciliator::event_tx()
-                                .send(monitor_reconciliator::Notification::SessionLocked);
-                        }
-                        WTS_SESSION_UNLOCK => {
-                            tracing::debug!("WM_WTSSESSION_CHANGE event received with WTS_SESSION_UNLOCK - screen unlocked");
-
-                            let _ = monitor_reconciliator::event_tx()
-                                .send(monitor_reconciliator::Notification::SessionUnlocked);
-                        }
-                        _ => {}
-                    }
-
-                    LRESULT(0)
-                }
-                // This event gets sent when:
-                // - The scaling factor on a display changes
-                // - The resolution on a display changes
-                // - A monitor is added
-                // - A monitor is removed
-                // Since WM_DEVICECHANGE also notifies on monitor changes, we only handle scaling
-                // and resolution changes here
-                WM_DISPLAYCHANGE => {
-                    tracing::debug!(
-                        "WM_DISPLAYCHANGE event received with wparam: {}- work area or display resolution changed", wparam.0
-                    );
-
-                    let _ = monitor_reconciliator::event_tx()
-                        .send(monitor_reconciliator::Notification::ResolutionScalingChanged);
-                    LRESULT(0)
-                }
-                // Unfortunately this is the event sent with ButteryTaskbar which I use a lot
-                // Original idea from https://stackoverflow.com/a/33762334
-                WM_SETTINGCHANGE => {
-                    #[allow(clippy::cast_possible_truncation)]
-                    if wparam.0 as u32 == SPI_SETWORKAREA.0 {
-                        tracing::debug!(
-                                "WM_SETTINGCHANGE event received with SPI_SETWORKAREA - work area changed (probably butterytaskbar or something similar)"
-                            );
-
-                        let _ = monitor_reconciliator::event_tx()
-                            .send(monitor_reconciliator::Notification::WorkAreaChanged);
-                    }
-                    LRESULT(0)
-                }
-                // This event + wparam combo is sent 4 times when a monitor is added based on my testing on win11
-                // Original idea from https://stackoverflow.com/a/33762334
-                WM_DEVICECHANGE => {
-                    #[allow(clippy::cast_possible_truncation)]
-                    if wparam.0 as u32 == DBT_DEVNODES_CHANGED {
-                        tracing::debug!(
-                                "WM_DEVICECHANGE event received with DBT_DEVNODES_CHANGED - display added or removed"
-                            );
-                        let _ = monitor_reconciliator::event_tx()
-                            .send(monitor_reconciliator::Notification::DisplayConnectionChange);
-                    }
-
-                    LRESULT(0)
-                }
-                _ => DefWindowProcW(window, message, wparam, lparam),
-            }
-        }
-    }
-}
--- a/komorebi/src/monitor_reconciliator/mod.rs
+++ b/komorebi/src/monitor_reconciliator/mod.rs
@@ -1,404 +0,0 @@
-#![deny(clippy::unwrap_used, clippy::expect_used)]
-
-use crate::border_manager;
-use crate::monitor;
-use crate::monitor::Monitor;
-use crate::monitor_reconciliator::hidden::Hidden;
-use crate::MonitorConfig;
-use crate::WindowManager;
-use crate::WindowsApi;
-use crossbeam_channel::Receiver;
-use crossbeam_channel::Sender;
-use crossbeam_utils::atomic::AtomicConsume;
-use komorebi_core::Rect;
-use parking_lot::Mutex;
-use std::collections::HashMap;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering;
-use std::sync::Arc;
-use std::sync::OnceLock;
-
-pub mod hidden;
-
-pub enum Notification {
-    ResolutionScalingChanged,
-    WorkAreaChanged,
-    DisplayConnectionChange,
-    EnteringSuspendedState,
-    ResumingFromSuspendedState,
-    SessionLocked,
-    SessionUnlocked,
-}
-
-static ACTIVE: AtomicBool = AtomicBool::new(true);
-
-static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
-
-static MONITOR_CACHE: OnceLock<Mutex<HashMap<String, MonitorConfig>>> = OnceLock::new();
-
-pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
-    CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
-}
-
-pub fn event_tx() -> Sender<Notification> {
-    channel().0.clone()
-}
-
-pub fn event_rx() -> Receiver<Notification> {
-    channel().1.clone()
-}
-
-pub fn insert_in_monitor_cache(device_id: &str, config: MonitorConfig) {
-    let mut monitor_cache = MONITOR_CACHE
-        .get_or_init(|| Mutex::new(HashMap::new()))
-        .lock();
-
-    monitor_cache.insert(device_id.to_string(), config);
-}
-
-pub fn attached_display_devices() -> color_eyre::Result<Vec<Monitor>> {
-    Ok(win32_display_data::connected_displays()
-        .flatten()
-        .map(|display| {
-            let path = display.device_path;
-            let mut split: Vec<_> = path.split('#').collect();
-            split.remove(0);
-            split.remove(split.len() - 1);
-            let device = split[0].to_string();
-            let device_id = split.join("-");
-
-            let name = display.device_name.trim_start_matches(r"\\.\").to_string();
-            let name = name.split('\\').collect::<Vec<_>>()[0].to_string();
-
-            monitor::new(
-                display.hmonitor,
-                display.size.into(),
-                display.work_area_size.into(),
-                name,
-                device,
-                device_id,
-            )
-        })
-        .collect::<Vec<_>>())
-}
-pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
-    #[allow(clippy::expect_used)]
-    Hidden::create("komorebi-hidden")?;
-
-    tracing::info!("created hidden window to listen for monitor-related events");
-
-    std::thread::spawn(move || loop {
-        match handle_notifications(wm.clone()) {
-            Ok(()) => {
-                tracing::warn!("restarting finished thread");
-            }
-            Err(error) => {
-                if cfg!(debug_assertions) {
-                    tracing::error!("restarting failed thread: {:?}", error)
-                } else {
-                    tracing::error!("restarting failed thread: {}", error)
-                }
-            }
-        }
-    });
-
-    Ok(())
-}
-pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
-    tracing::info!("listening");
-
-    let receiver = event_rx();
-
-    'receiver: for notification in receiver {
-        if !ACTIVE.load_consume() {
-            if matches!(
-                notification,
-                Notification::ResumingFromSuspendedState | Notification::SessionUnlocked
-            ) {
-                tracing::debug!(
-                    "reactivating reconciliator - system has resumed from suspended state or session has been unlocked"
-                );
-
-                ACTIVE.store(true, Ordering::SeqCst);
-            }
-
-            continue 'receiver;
-        }
-
-        let mut wm = wm.lock();
-
-        match notification {
-            Notification::EnteringSuspendedState | Notification::SessionLocked => {
-                tracing::debug!(
-                    "deactivating reconciliator until system resumes from suspended state or session is unlocked"
-                );
-                ACTIVE.store(false, Ordering::SeqCst);
-            }
-            Notification::ResumingFromSuspendedState | Notification::SessionUnlocked => {
-                // this is only handled above if the reconciliator is paused
-            }
-            Notification::WorkAreaChanged => {
-                tracing::debug!("handling work area changed notification");
-                let offset = wm.work_area_offset;
-                for monitor in wm.monitors_mut() {
-                    let mut should_update = false;
-
-                    // Update work areas as necessary
-                    if let Ok(reference) = WindowsApi::monitor(monitor.id()) {
-                        if reference.work_area_size() != monitor.work_area_size() {
-                            monitor.set_work_area_size(Rect {
-                                left: reference.work_area_size().left,
-                                top: reference.work_area_size().top,
-                                right: reference.work_area_size().right,
-                                bottom: reference.work_area_size().bottom,
-                            });
-
-                            should_update = true;
-                        }
-                    }
-
-                    if should_update {
-                        tracing::info!("updated work area for {}", monitor.device_id());
-                        monitor.update_focused_workspace(offset)?;
-                        border_manager::event_tx().send(border_manager::Notification)?;
-                    } else {
-                        tracing::debug!(
-                            "work areas match, reconciliation not required for {}",
-                            monitor.device_id()
-                        );
-                    }
-                }
-            }
-            Notification::ResolutionScalingChanged => {
-                tracing::debug!("handling resolution/scaling changed notification");
-                let offset = wm.work_area_offset;
-                for monitor in wm.monitors_mut() {
-                    let mut should_update = false;
-
-                    // Update sizes and work areas as necessary
-                    if let Ok(reference) = WindowsApi::monitor(monitor.id()) {
-                        if reference.work_area_size() != monitor.work_area_size() {
-                            monitor.set_work_area_size(Rect {
-                                left: reference.work_area_size().left,
-                                top: reference.work_area_size().top,
-                                right: reference.work_area_size().right,
-                                bottom: reference.work_area_size().bottom,
-                            });
-
-                            should_update = true;
-                        }
-
-                        if reference.size() != monitor.size() {
-                            monitor.set_size(Rect {
-                                left: reference.size().left,
-                                top: reference.size().top,
-                                right: reference.size().right,
-                                bottom: reference.size().bottom,
-                            });
-
-                            should_update = true;
-                        }
-                    }
-
-                    if should_update {
-                        tracing::info!(
-                            "updated monitor resolution/scaling for {}",
-                            monitor.device_id()
-                        );
-
-                        monitor.update_focused_workspace(offset)?;
-                        border_manager::event_tx().send(border_manager::Notification)?;
-                    } else {
-                        tracing::debug!(
-                            "resolutions match, reconciliation not required for {}",
-                            monitor.device_id()
-                        );
-                    }
-                }
-            }
-            Notification::DisplayConnectionChange => {
-                tracing::debug!("handling display connection change notification");
-                let mut monitor_cache = MONITOR_CACHE
-                    .get_or_init(|| Mutex::new(HashMap::new()))
-                    .lock();
-
-                let initial_monitor_count = wm.monitors().len();
-
-                // Get the currently attached display devices
-                let attached_devices = attached_display_devices()?;
-
-                // Make sure that in our state any attached displays have the latest Win32 data
-                for monitor in wm.monitors_mut() {
-                    for attached in &attached_devices {
-                        if attached.device_id().eq(monitor.device_id()) {
-                            monitor.set_id(attached.id());
-                            monitor.set_name(attached.name().clone());
-                            monitor.set_size(*attached.size());
-                            monitor.set_work_area_size(*attached.work_area_size());
-                        }
-                    }
-                }
-
-                if initial_monitor_count == attached_devices.len() {
-                    tracing::debug!("monitor counts match, reconciliation not required");
-                    continue 'receiver;
-                }
-
-                if attached_devices.is_empty() {
-                    tracing::debug!(
-                        "no devices found, skipping reconciliation to avoid breaking state"
-                    );
-                    continue 'receiver;
-                }
-
-                if initial_monitor_count > attached_devices.len() {
-                    tracing::info!(
-                        "monitor count mismatch ({initial_monitor_count} vs {}), removing disconnected monitors",
-                        attached_devices.len()
-                    );
-
-                    // Gather all the containers that will be orphaned from disconnected and invalid displays
-                    let mut orphaned_containers = vec![];
-
-                    // Collect the ids in our state which aren't in the current attached display ids
-                    // These are monitors that have been removed
-                    let mut newly_removed_displays = vec![];
-
-                    for m in wm.monitors().iter() {
-                        if !attached_devices
-                            .iter()
-                            .any(|attached| attached.device_id().eq(m.device_id()))
-                        {
-                            newly_removed_displays.push(m.device_id().clone());
-                            for workspace in m.workspaces() {
-                                for container in workspace.containers() {
-                                    // Save the orphaned containers from the removed monitor
-                                    orphaned_containers.push(container.clone());
-                                }
-                            }
-
-                            // Let's add their state to the cache for later
-                            monitor_cache.insert(m.device_id().clone(), m.into());
-                        }
-                    }
-
-                    if !orphaned_containers.is_empty() {
-                        tracing::info!(
-                            "removed orphaned containers from: {newly_removed_displays:?}"
-                        );
-                    }
-
-                    if !newly_removed_displays.is_empty() {
-                        // After we have cached them, remove them from our state
-                        wm.monitors_mut()
-                            .retain(|m| !newly_removed_displays.contains(m.device_id()));
-                    }
-
-                    let post_removal_monitor_count = wm.monitors().len();
-                    let focused_monitor_idx = wm.focused_monitor_idx();
-                    if focused_monitor_idx >= post_removal_monitor_count {
-                        wm.focus_monitor(0)?;
-                    }
-
-                    if !orphaned_containers.is_empty() {
-                        if let Some(primary) = wm.monitors_mut().front_mut() {
-                            if let Some(focused_ws) = primary.focused_workspace_mut() {
-                                let focused_container_idx = focused_ws.focused_container_idx();
-
-                                // Put the orphaned containers somewhere visible
-                                for container in orphaned_containers {
-                                    focused_ws.add_container(container);
-                                }
-
-                                // Gotta reset the focus or the movement will feel "off"
-                                if initial_monitor_count != post_removal_monitor_count {
-                                    focused_ws.focus_container(focused_container_idx);
-                                }
-                            }
-                        }
-                    }
-
-                    let offset = wm.work_area_offset;
-
-                    for monitor in wm.monitors_mut() {
-                        // If we have lost a monitor, update everything to filter out any jank
-                        if initial_monitor_count != post_removal_monitor_count {
-                            monitor.update_focused_workspace(offset)?;
-                        }
-                    }
-                }
-
-                let post_removal_monitor_count = wm.monitors().len();
-
-                // This is the list of device ids after we have removed detached displays
-                let post_removal_device_ids = wm
-                    .monitors()
-                    .iter()
-                    .map(Monitor::device_id)
-                    .cloned()
-                    .collect::<Vec<_>>();
-
-                // Check for and add any new monitors that may have been plugged in
-                // Monitor and display index preferences get applied in this function
-                WindowsApi::load_monitor_information(&mut wm.monitors)?;
-
-                let post_addition_monitor_count = wm.monitors().len();
-
-                if post_addition_monitor_count > post_removal_monitor_count {
-                    tracing::info!(
-                        "monitor count mismatch ({post_removal_monitor_count} vs {post_addition_monitor_count}), adding connected monitors",
-                    );
-
-                    // Look in the updated state for new monitors
-                    for m in wm.monitors_mut() {
-                        let device_id = m.device_id().clone();
-                        // We identify a new monitor when we encounter a new device id
-                        if !post_removal_device_ids.contains(&device_id) {
-                            let mut cache_hit = false;
-                            // Check if that device id exists in the cache for this session
-                            if let Some(cached) = monitor_cache.get(&device_id) {
-                                cache_hit = true;
-
-                                tracing::info!("found monitor and workspace configuration for {device_id} in the monitor cache, applying");
-
-                                // If it does, load all the monitor settings from the cache entry
-                                m.ensure_workspace_count(cached.workspaces.len());
-                                m.set_work_area_offset(cached.work_area_offset);
-                                m.set_window_based_work_area_offset(
-                                    cached.window_based_work_area_offset,
-                                );
-                                m.set_window_based_work_area_offset_limit(
-                                    cached.window_based_work_area_offset_limit.unwrap_or(1),
-                                );
-
-                                for (w_idx, workspace) in m.workspaces_mut().iter_mut().enumerate()
-                                {
-                                    if let Some(cached_workspace) = cached.workspaces.get(w_idx) {
-                                        workspace.load_static_config(cached_workspace)?;
-                                    }
-                                }
-                            }
-
-                            // Entries in the cache should only be used once; remove the entry there was a cache hit
-                            if cache_hit {
-                                monitor_cache.remove(&device_id);
-                            }
-                        }
-                    }
-                }
-
-                let final_count = wm.monitors().len();
-
-                if post_removal_monitor_count != final_count {
-                    wm.retile_all(true)?;
-                    // Second retile to fix DPI/resolution related jank
-                    wm.retile_all(true)?;
-                    // Border updates to fix DPI/resolution related jank
-                    border_manager::event_tx().send(border_manager::Notification)?;
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
--- a/komorebi/src/process_command.rs
+++ b/komorebi/src/process_command.rs
@@ -65,7 +65,6 @@ use crate::NO_TITLEBAR;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REMOVE_TITLEBARS;
 use crate::STACKBAR_FOCUSED_TEXT_COLOUR;
-use crate::STACKBAR_LABEL;
 use crate::STACKBAR_MODE;
 use crate::STACKBAR_TAB_BACKGROUND_COLOUR;
 use crate::STACKBAR_TAB_HEIGHT;
@@ -186,10 +185,6 @@ impl WindowManager {
        match message {
            SocketMessage::Promote => self.promote_container_to_front()?,
            SocketMessage::PromoteFocus => self.promote_focus_to_front()?,
-            SocketMessage::PromoteWindow(direction) => {
-                self.focus_container_in_direction(direction)?;
-                self.promote_container_to_front()?
-            }
            SocketMessage::FocusWindow(direction) => {
                self.focus_container_in_direction(direction)?;
            }
@@ -470,15 +465,6 @@ impl WindowManager {
            SocketMessage::MoveWorkspaceToMonitorNumber(monitor_idx) => {
                self.move_workspace_to_monitor(monitor_idx)?;
            }
-            SocketMessage::CycleMoveWorkspaceToMonitor(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.move_workspace_to_monitor(monitor_idx)?;
-            }
            SocketMessage::TogglePause => {
                if self.is_paused {
                    tracing::info!("resuming");
@@ -506,10 +492,7 @@ impl WindowManager {
                self.focus_monitor(monitor_idx)?;
                self.update_focused_workspace(self.mouse_follows_focus, true)?;
            }
-            SocketMessage::Retile => {
-                border_manager::destroy_all_borders()?;
-                self.retile_all(false)?
-            }
+            SocketMessage::Retile => self.retile_all(false)?,
            SocketMessage::FlipLayout(layout_flip) => self.flip_layout(layout_flip)?,
            SocketMessage::ChangeLayout(layout) => self.change_workspace_layout_default(layout)?,
            SocketMessage::CycleLayout(direction) => self.cycle_layout(direction)?,
@@ -664,9 +647,7 @@ impl WindowManager {
                    self.focus_monitor(monitor_idx)?;
                }

-                if self.focused_workspace_idx().unwrap_or_default() != workspace_idx {
-                    self.focus_workspace(workspace_idx)?;
-                }
+                self.focus_workspace(workspace_idx)?;
            }
            SocketMessage::FocusWorkspaceNumbers(workspace_idx) => {
                // This is to ensure that even on an empty workspace on a secondary monitor, the
@@ -688,15 +669,8 @@ impl WindowManager {
                self.focus_workspace(workspace_idx)?;
            }
            SocketMessage::FocusMonitorWorkspaceNumber(monitor_idx, workspace_idx) => {
-                let focused_monitor_idx = self.focused_monitor_idx();
-                let focused_workspace_idx = self.focused_workspace_idx().unwrap_or_default();
-
-                let focused_pair = (focused_monitor_idx, focused_workspace_idx);
-
-                if focused_pair != (monitor_idx, workspace_idx) {
-                    self.focus_monitor(monitor_idx)?;
-                    self.focus_workspace(workspace_idx)?;
-                }
+                self.focus_monitor(monitor_idx)?;
+                self.focus_workspace(workspace_idx)?;
            }
            SocketMessage::FocusNamedWorkspace(ref name) => {
                if let Some((monitor_idx, workspace_idx)) =
@@ -774,10 +748,13 @@ impl WindowManager {
            SocketMessage::VisibleWindows => {
                let mut monitor_visible_windows = HashMap::new();

-                for monitor in self.monitors() {
+                for (index, monitor) in self.monitors().iter().enumerate() {
                    if let Some(ws) = monitor.focused_workspace() {
                        monitor_visible_windows.insert(
-                            monitor.device_id().clone(),
+                            monitor
+                                .device_id()
+                                .clone()
+                                .unwrap_or_else(|| format!("{index}")),
                            ws.visible_window_details().clone(),
                        );
                    }
@@ -1207,7 +1184,6 @@ impl WindowManager {
                    MoveBehaviour::Insert => {
                        self.cross_monitor_move_behaviour = MoveBehaviour::Swap;
                    }
-                    _ => {}
                }
            }
            SocketMessage::CrossMonitorMoveBehaviour(behaviour) => {
@@ -1216,10 +1192,10 @@ impl WindowManager {
            SocketMessage::UnmanagedWindowOperationBehaviour(behaviour) => {
                self.unmanaged_window_operation_behaviour = behaviour;
            }
-            SocketMessage::Border(enable) => {
+            SocketMessage::ActiveWindowBorder(enable) => {
                border_manager::BORDER_ENABLED.store(enable, Ordering::SeqCst);
            }
-            SocketMessage::BorderColour(kind, r, g, b) => match kind {
+            SocketMessage::ActiveWindowBorderColour(kind, r, g, b) => match kind {
                WindowKind::Single => {
                    border_manager::FOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                }
@@ -1233,9 +1209,9 @@ impl WindowManager {
                    border_manager::UNFOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                }
            },
-            SocketMessage::BorderStyle(style) => {
-                let mut border_style = STYLE.lock();
-                *border_style = style;
+            SocketMessage::ActiveWindowBorderStyle(style) => {
+                let mut active_window_border_style = STYLE.lock();
+                *active_window_border_style = style;
            }
            SocketMessage::BorderWidth(width) => {
                border_manager::BORDER_WIDTH.store(width, Ordering::SeqCst);
@@ -1244,7 +1220,8 @@ impl WindowManager {
                border_manager::BORDER_OFFSET.store(offset, Ordering::SeqCst);
            }
            SocketMessage::StackbarMode(mode) => {
-                STACKBAR_MODE.store(mode);
+                let mut stackbar_mode = STACKBAR_MODE.lock();
+                *stackbar_mode = mode;

                for m in self.monitors_mut() {
                    for w in m.workspaces_mut() {
@@ -1254,9 +1231,6 @@ impl WindowManager {
                    }
                }
            }
-            SocketMessage::StackbarLabel(label) => {
-                STACKBAR_LABEL.store(label);
-            }
            SocketMessage::StackbarFocusedTextColour(r, g, b) => {
                let rgb = Rgb::new(r, g, b);
                STACKBAR_FOCUSED_TEXT_COLOUR.store(rgb.into(), Ordering::SeqCst);
--- a/komorebi/src/process_event.rs
+++ b/komorebi/src/process_event.rs
@@ -1,8 +1,6 @@
 use std::fs::OpenOptions;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::time::Duration;
-use std::time::Instant;

 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -11,7 +9,6 @@ use parking_lot::Mutex;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
 use komorebi_core::Sizing;
-use komorebi_core::StackbarLabel;
 use komorebi_core::WindowContainerBehaviour;

 use crate::border_manager;
@@ -25,15 +22,11 @@ use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
-use crate::workspace_reconciliator;
-use crate::workspace_reconciliator::ALT_TAB_HWND;
-use crate::workspace_reconciliator::ALT_TAB_HWND_INSTANT;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::DATA_DIR;
 use crate::HIDDEN_HWNDS;
 use crate::REGEX_IDENTIFIERS;
-use crate::STACKBAR_LABEL;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;

 #[tracing::instrument]
@@ -74,7 +67,7 @@ impl WindowManager {

        // All event handlers below this point should only be processed if the event is
        // related to a window that should be managed by the WindowManager.
-        if !should_manage {
+        if !should_manage && !matches!(event, WindowManagerEvent::DisplayChange(_)) {
            return Ok(());
        }

@@ -94,29 +87,31 @@ impl WindowManager {
        match event {
            WindowManagerEvent::FocusChange(_, window)
            | WindowManagerEvent::Show(_, window)
+            | WindowManagerEvent::DisplayChange(window)
            | WindowManagerEvent::MoveResizeEnd(_, window) => {
-                if let Some(monitor_idx) = self.monitor_idx_from_window(window) {
-                    // This is a hidden window apparently associated with COM support mechanisms (based
-                    // on a post from http://www.databaseteam.org/1-ms-sql-server/a5bb344836fb889c.htm)
-                    //
-                    // The hidden window, OLEChannelWnd, associated with this class (spawned by
-                    // explorer.exe), after some debugging, is observed to always be tied to the primary
-                    // display monitor, or (usually) monitor 0 in the WindowManager state.
-                    //
-                    // Due to this, at least one user in the Discord has witnessed behaviour where, when
-                    // a MonitorPoll event is triggered by OLEChannelWnd, the focused monitor index gets
-                    // set repeatedly to 0, regardless of where the current foreground window is actually
-                    // located.
-                    //
-                    // This check ensures that we only update the focused monitor when the window
-                    // triggering monitor reconciliation is known to not be tied to a specific monitor.
-                    if let Ok(class) = window.class() {
-                        if class != "OleMainThreadWndClass"
-                            && self.focused_monitor_idx() != monitor_idx
-                        {
-                            self.focus_monitor(monitor_idx)?;
-                        }
-                    }
+                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"))?;
+
+                // This is a hidden window apparently associated with COM support mechanisms (based
+                // on a post from http://www.databaseteam.org/1-ms-sql-server/a5bb344836fb889c.htm)
+                //
+                // The hidden window, OLEChannelWnd, associated with this class (spawned by
+                // explorer.exe), after some debugging, is observed to always be tied to the primary
+                // display monitor, or (usually) monitor 0 in the WindowManager state.
+                //
+                // Due to this, at least one user in the Discord has witnessed behaviour where, when
+                // a MonitorPoll event is triggered by OLEChannelWnd, the focused monitor index gets
+                // set repeatedly to 0, regardless of where the current foreground window is actually
+                // located.
+                //
+                // This check ensures that we only update the focused monitor when the window
+                // triggering monitor reconciliation is known to not be tied to a specific monitor.
+                if window.class()? != "OleMainThreadWndClass"
+                    && self.focused_monitor_idx() != monitor_idx
+                {
+                    self.focus_monitor(monitor_idx)?;
                }
            }
            _ => {}
@@ -126,11 +121,6 @@ impl WindowManager {

        for (i, monitor) in self.monitors_mut().iter_mut().enumerate() {
            let work_area = *monitor.work_area_size();
-            let window_based_work_area_offset = (
-                monitor.window_based_work_area_offset_limit(),
-                monitor.window_based_work_area_offset(),
-            );
-
            let offset = if monitor.work_area_offset().is_some() {
                monitor.work_area_offset()
            } else {
@@ -144,7 +134,7 @@ impl WindowManager {

                let reaped_orphans = workspace.reap_orphans()?;
                if reaped_orphans.0 > 0 || reaped_orphans.1 > 0 {
-                    workspace.update(&work_area, offset, window_based_work_area_offset)?;
+                    workspace.update(&work_area, offset)?;
                    tracing::info!(
                        "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
                        reaped_orphans.0,
@@ -269,103 +259,74 @@ impl WindowManager {
            WindowManagerEvent::Show(_, window)
            | WindowManagerEvent::Manage(window)
            | WindowManagerEvent::Uncloak(_, window) => {
-                if matches!(
-                    event,
-                    WindowManagerEvent::Show(WinEvent::ObjectNameChange, _)
-                ) {
-                    if matches!(STACKBAR_LABEL.load(), StackbarLabel::Title) {
-                        for m in self.monitors() {
-                            for ws in m.workspaces() {
-                                if let Some(container) = ws.container_for_window(window.hwnd) {
-                                    if let Some(stackbar) = container.stackbar() {
-                                        stackbar.update(container.windows(), window.hwnd)?;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-
-                let focused_monitor_idx = self.focused_monitor_idx();
-                let focused_workspace_idx =
-                    self.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;
-
-                let focused_pair = (focused_monitor_idx, focused_workspace_idx);
-
-                let mut needs_reconciliation = false;
-
+                let mut switch_to = None;
                for (i, monitors) in self.monitors().iter().enumerate() {
                    for (j, workspace) in monitors.workspaces().iter().enumerate() {
-                        if workspace.contains_window(window.hwnd) && focused_pair != (i, j) {
-                            // At this point we know we are going to send a notification to the workspace reconciliator
-                            // So we get the topmost window returned by EnumWindows, which is almost always the window
-                            // that has been selected by alt-tab
-                            if let Ok(alt_tab_windows) = WindowsApi::alt_tab_windows() {
-                                if let Some(first) =
-                                    alt_tab_windows.iter().find(|w| w.title().is_ok())
-                                {
-                                    // If our record of this HWND hasn't been updated in over a minute
-                                    let mut instant = ALT_TAB_HWND_INSTANT.lock();
-                                    if instant.elapsed().gt(&Duration::from_secs(1)) {
-                                        // Update our record with the HWND we just found
-                                        ALT_TAB_HWND.store(Some(first.hwnd));
-                                        // Update the timestamp of our record
-                                        *instant = Instant::now();
-                                    }
-                                }
-                            }
-
-                            workspace_reconciliator::event_tx().send(
-                                workspace_reconciliator::Notification {
-                                    monitor_idx: i,
-                                    workspace_idx: j,
-                                },
-                            )?;
-
-                            needs_reconciliation = true;
+                        if workspace.contains_window(window.hwnd) {
+                            switch_to = Some((i, j));
                        }
                    }
                }

-                // There are some applications such as Firefox where, if they are focused when a
-                // workspace switch takes place, it will fire an additional Show event, which will
-                // result in them being associated with both the original workspace and the workspace
-                // being switched to. This loop is to try to ensure that we don't end up with
-                // duplicates across multiple workspaces, as it results in ghost layout tiles.
-                let mut proceed = true;
+                match switch_to {
+                    Some((known_monitor_idx, known_workspace_idx)) => {
+                        if !matches!(event, WindowManagerEvent::Uncloak(_, _)) {
+                            if self.focused_monitor_idx() != known_monitor_idx
+                                || self
+                                    .focused_monitor()
+                                    .ok_or_else(|| anyhow!("there is no monitor"))?
+                                    .focused_workspace_idx()
+                                    != known_workspace_idx
+                            {
+                                self.focus_monitor(known_monitor_idx)?;
+                                self.focus_workspace(known_workspace_idx)?;
+                            }
+                        }
+                    }
+                    None => {
+                        // There are some applications such as Firefox where, if they are focused when a
+                        // workspace switch takes place, it will fire an additional Show event, which will
+                        // result in them being associated with both the original workspace and the workspace
+                        // being switched to. This loop is to try to ensure that we don't end up with
+                        // duplicates across multiple workspaces, as it results in ghost layout tiles.
+                        let mut proceed = true;

-                for (i, monitor) in self.monitors().iter().enumerate() {
-                    for (j, workspace) in monitor.workspaces().iter().enumerate() {
-                        if workspace.container_for_window(window.hwnd).is_some()
-                            && i != self.focused_monitor_idx()
-                            && j != monitor.focused_workspace_idx()
-                        {
-                            tracing::debug!(
+                        for (i, monitor) in self.monitors().iter().enumerate() {
+                            for (j, workspace) in monitor.workspaces().iter().enumerate() {
+                                if workspace.container_for_window(window.hwnd).is_some()
+                                    && i != self.focused_monitor_idx()
+                                    && j != monitor.focused_workspace_idx()
+                                {
+                                    tracing::debug!(
                                "ignoring show event for window already associated with another workspace"
                            );

-                            window.hide();
-                            proceed = false;
-                        }
-                    }
-                }
-
-                if proceed {
-                    let behaviour = self.window_container_behaviour;
-                    let workspace = self.focused_workspace_mut()?;
-
-                    if !workspace.contains_window(window.hwnd) && !needs_reconciliation {
-                        match behaviour {
-                            WindowContainerBehaviour::Create => {
-                                workspace.new_container_for_window(window);
-                                self.update_focused_workspace(false, false)?;
+                                    window.hide();
+                                    proceed = false;
+                                }
                            }
-                            WindowContainerBehaviour::Append => {
-                                workspace
-                                    .focused_container_mut()
-                                    .ok_or_else(|| anyhow!("there is no focused container"))?
-                                    .add_window(window);
-                                self.update_focused_workspace(true, false)?;
+                        }
+
+                        if proceed {
+                            let behaviour = self.window_container_behaviour;
+                            let workspace = self.focused_workspace_mut()?;
+
+                            if !workspace.contains_window(window.hwnd) && switch_to.is_none() {
+                                match behaviour {
+                                    WindowContainerBehaviour::Create => {
+                                        workspace.new_container_for_window(window);
+                                        self.update_focused_workspace(false, false)?;
+                                    }
+                                    WindowContainerBehaviour::Append => {
+                                        workspace
+                                            .focused_container_mut()
+                                            .ok_or_else(|| {
+                                                anyhow!("there is no focused container")
+                                            })?
+                                            .add_window(window);
+                                        self.update_focused_workspace(true, false)?;
+                                    }
+                                }
                            }
                        }
                    }
@@ -604,7 +565,9 @@ impl WindowManager {
            WindowManagerEvent::ForceUpdate(_) => {
                self.update_focused_workspace(false, true)?;
            }
-            WindowManagerEvent::MouseCapture(..) | WindowManagerEvent::Cloak(..) => {}
+            WindowManagerEvent::DisplayChange(..)
+            | WindowManagerEvent::MouseCapture(..)
+            | WindowManagerEvent::Cloak(..) => {}
        };

        // If we unmanaged a window, it shouldn't be immediately hidden behind managed windows
@@ -638,8 +601,15 @@ impl WindowManager {
            state: self.as_ref().into(),
        };

-        notify_subscribers(&serde_json::to_string(&notification)?)?;
-        border_manager::event_tx().send(border_manager::Notification)?;
+        // Avoid unnecessary updates, this fires every single time you interact
+        // with something on JetBrains IDEs
+        if !matches!(
+            event,
+            WindowManagerEvent::Show(WinEvent::ObjectNameChange, _)
+        ) {
+            notify_subscribers(&serde_json::to_string(&notification)?)?;
+            border_manager::event_tx().send(border_manager::Notification)?;
+        }

        tracing::info!("processed: {}", event.window().to_string());
        Ok(())
--- a/komorebi/src/stackbar.rs
+++ b/komorebi/src/stackbar.rs
@@ -55,10 +55,8 @@ use komorebi_core::Rect;

 use crate::window::Window;
 use crate::windows_api::WindowsApi;
-use crate::StackbarLabel;
 use crate::DEFAULT_CONTAINER_PADDING;
 use crate::STACKBAR_FOCUSED_TEXT_COLOUR;
-use crate::STACKBAR_LABEL;
 use crate::STACKBAR_TAB_BACKGROUND_COLOUR;
 use crate::STACKBAR_TAB_HEIGHT;
 use crate::STACKBAR_TAB_WIDTH;
@@ -67,7 +65,7 @@ use crate::WINDOWS_BY_BAR_HWNDS;

 #[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
 pub struct Stackbar {
-    pub hwnd: isize,
+    pub(crate) hwnd: isize,
 }

 impl Stackbar {
@@ -231,15 +229,9 @@ impl Stackbar {

                WindowsApi::round_rect(hdc, &tab_box, 8);

-                let label = match STACKBAR_LABEL.load() {
-                    StackbarLabel::Process => {
-                        let exe = window.exe()?;
-                        exe.trim_end_matches(".exe").to_string()
-                    }
-                    StackbarLabel::Title => window.title()?,
-                };
-
-                let mut tab_title: Vec<u16> = label.encode_utf16().collect();
+                let exe = window.exe()?;
+                let exe_trimmed = exe.trim_end_matches(".exe");
+                let mut tab_title: Vec<u16> = exe_trimmed.encode_utf16().collect();

                tab_box.left_padding(10);
                tab_box.right_padding(10);
--- a/komorebi/src/static_config.rs
+++ b/komorebi/src/static_config.rs
@@ -5,7 +5,6 @@ use crate::border_manager::Z_ORDER;
 use crate::colour::Colour;
 use crate::current_virtual_desktop;
 use crate::monitor::Monitor;
-use crate::monitor_reconciliator;
 use crate::ring::Ring;
 use crate::window_manager::WindowManager;
 use crate::window_manager_event::WindowManagerEvent;
@@ -23,7 +22,6 @@ use crate::MONITOR_INDEX_PREFERENCES;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REGEX_IDENTIFIERS;
 use crate::STACKBAR_FOCUSED_TEXT_COLOUR;
-use crate::STACKBAR_LABEL;
 use crate::STACKBAR_MODE;
 use crate::STACKBAR_TAB_BACKGROUND_COLOUR;
 use crate::STACKBAR_TAB_HEIGHT;
@@ -31,7 +29,6 @@ use crate::STACKBAR_TAB_WIDTH;
 use crate::STACKBAR_UNFOCUSED_TEXT_COLOUR;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WORKSPACE_RULES;
-use komorebi_core::StackbarLabel;
 use komorebi_core::StackbarMode;

 use color_eyre::Result;
@@ -45,8 +42,8 @@ use komorebi_core::config_generation::IdWithIdentifier;
 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::config_generation::MatchingStrategy;
 use komorebi_core::resolve_home_path;
+use komorebi_core::ActiveWindowBorderStyle;
 use komorebi_core::ApplicationIdentifier;
-use komorebi_core::BorderStyle;
 use komorebi_core::DefaultLayout;
 use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::HidingBehaviour;
@@ -72,7 +69,7 @@ use uds_windows::UnixListener;
 use uds_windows::UnixStream;

 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
-pub struct BorderColours {
+pub struct ActiveWindowBorderColours {
    /// Border colour when the container contains a single window
    pub single: Option<Colour>,
    /// Border colour when the container contains multiple windows
@@ -83,7 +80,7 @@ pub struct BorderColours {
    pub unfocused: Option<Colour>,
 }

-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct WorkspaceConfig {
    /// Name
    pub name: String,
@@ -197,19 +194,13 @@ impl From<&Workspace> for WorkspaceConfig {
    }
 }

-#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct MonitorConfig {
    /// Workspace configurations
    pub workspaces: Vec<WorkspaceConfig>,
    /// Monitor-specific work area offset (default: None)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_area_offset: Option<Rect>,
-    /// Window based work area offset (default: None)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub window_based_work_area_offset: Option<Rect>,
-    /// Open window limit after which the window based work area offset will no longer be applied (default: 1)
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub window_based_work_area_offset_limit: Option<isize>,
 }

 impl From<&Monitor> for MonitorConfig {
@@ -222,8 +213,6 @@ impl From<&Monitor> for MonitorConfig {
        Self {
            workspaces,
            work_area_offset: value.work_area_offset(),
-            window_based_work_area_offset: value.window_based_work_area_offset(),
-            window_based_work_area_offset_limit: Some(value.window_based_work_area_offset_limit()),
        }
    }
 }
@@ -265,19 +254,16 @@ pub struct StaticConfig {
    pub border_offset: Option<i32>,
    /// Display an active window border (default: false)
    #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(alias = "active_window_border")]
-    pub border: Option<bool>,
+    pub active_window_border: Option<bool>,
    /// Active window border colours for different container types
    #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(alias = "active_window_border_colours")]
-    pub border_colours: Option<BorderColours>,
+    pub active_window_border_colours: Option<ActiveWindowBorderColours>,
    /// Active window border style (default: System)
    #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(alias = "active_window_border_style")]
-    pub border_style: Option<BorderStyle>,
+    pub active_window_border_style: Option<ActiveWindowBorderStyle>,
    /// Active window border z-order (default: System)
    #[serde(skip_serializing_if = "Option::is_none")]
-    pub border_z_order: Option<ZOrder>,
+    pub active_window_border_z_order: Option<ZOrder>,
    /// Global default workspace padding (default: 10)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_workspace_padding: Option<i32>,
@@ -333,12 +319,11 @@ pub struct TabsConfig {
    /// Tab background colour
    background: Option<Colour>,
 }
+
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct StackbarConfig {
    /// Stackbar height
    pub height: Option<i32>,
-    /// Stackbar height
-    pub label: Option<StackbarLabel>,
    /// Stackbar mode
    pub mode: Option<StackbarMode>,
    /// Stackbar tab configuration options
@@ -401,7 +386,7 @@ impl From<&WindowManager> for StaticConfig {
        let border_colours = if border_manager::FOCUSED.load(Ordering::SeqCst) == 0 {
            None
        } else {
-            Option::from(BorderColours {
+            Option::from(ActiveWindowBorderColours {
                single: Option::from(Colour::from(border_manager::FOCUSED.load(Ordering::SeqCst))),
                stack: Option::from(Colour::from(border_manager::STACK.load(Ordering::SeqCst))),
                monocle: Option::from(Colour::from(border_manager::MONOCLE.load(Ordering::SeqCst))),
@@ -424,10 +409,12 @@ impl From<&WindowManager> for StaticConfig {
            app_specific_configuration_path: None,
            border_width: Option::from(border_manager::BORDER_WIDTH.load(Ordering::SeqCst)),
            border_offset: Option::from(border_manager::BORDER_OFFSET.load(Ordering::SeqCst)),
-            border: Option::from(border_manager::BORDER_ENABLED.load(Ordering::SeqCst)),
-            border_colours,
-            border_style: Option::from(*STYLE.lock()),
-            border_z_order: Option::from(*Z_ORDER.lock()),
+            active_window_border: Option::from(
+                border_manager::BORDER_ENABLED.load(Ordering::SeqCst),
+            ),
+            active_window_border_colours: border_colours,
+            active_window_border_style: Option::from(*STYLE.lock()),
+            active_window_border_z_order: Option::from(*Z_ORDER.lock()),
            default_workspace_padding: Option::from(
                DEFAULT_WORKSPACE_PADDING.load(Ordering::SeqCst),
            ),
@@ -479,11 +466,11 @@ impl StaticConfig {
        border_manager::BORDER_WIDTH.store(self.border_width.unwrap_or(8), Ordering::SeqCst);
        border_manager::BORDER_OFFSET.store(self.border_offset.unwrap_or(-1), Ordering::SeqCst);

-        if let Some(enabled) = &self.border {
+        if let Some(enabled) = &self.active_window_border {
            border_manager::BORDER_ENABLED.store(*enabled, Ordering::SeqCst);
        }

-        if let Some(colours) = &self.border_colours {
+        if let Some(colours) = &self.active_window_border_colours {
            if let Some(single) = colours.single {
                border_manager::FOCUSED.store(u32::from(single), Ordering::SeqCst);
            }
@@ -501,8 +488,8 @@ impl StaticConfig {
            }
        }

-        let border_style = self.border_style.unwrap_or_default();
-        *STYLE.lock() = border_style;
+        let active_window_border_style = self.active_window_border_style.unwrap_or_default();
+        *STYLE.lock() = active_window_border_style;

        let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
        let mut regex_identifiers = REGEX_IDENTIFIERS.lock();
@@ -544,12 +531,9 @@ impl StaticConfig {
                STACKBAR_TAB_HEIGHT.store(*height, Ordering::SeqCst);
            }

-            if let Some(label) = &stackbar.label {
-                STACKBAR_LABEL.store(*label);
-            }
-
            if let Some(mode) = &stackbar.mode {
-                STACKBAR_MODE.store(*mode);
+                let mut stackbar_mode = STACKBAR_MODE.lock();
+                *stackbar_mode = *mode;
            }

            if let Some(tabs) = &stackbar.tabs {
@@ -649,6 +633,7 @@ impl StaticConfig {

        let mut wm = WindowManager {
            monitors: Ring::default(),
+            monitor_cache: HashMap::new(),
            incoming_events: incoming,
            command_listener: listener,
            is_paused: false,
@@ -706,20 +691,9 @@ impl StaticConfig {

        if let Some(monitors) = value.monitors {
            for (i, monitor) in monitors.iter().enumerate() {
-                {
-                    let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
-                    if let Some(device_id) = display_index_preferences.get(&i) {
-                        monitor_reconciliator::insert_in_monitor_cache(device_id, monitor.clone());
-                    }
-                }
-
                if let Some(m) = wm.monitors_mut().get_mut(i) {
                    m.ensure_workspace_count(monitor.workspaces.len());
                    m.set_work_area_offset(monitor.work_area_offset);
-                    m.set_window_based_work_area_offset(monitor.window_based_work_area_offset);
-                    m.set_window_based_work_area_offset_limit(
-                        monitor.window_based_work_area_offset_limit.unwrap_or(1),
-                    );

                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
                        ws.load_static_config(
@@ -747,7 +721,7 @@ impl StaticConfig {
            }
        }

-        if value.border == Some(true) {
+        if value.active_window_border == Some(true) {
            border_manager::BORDER_ENABLED.store(true, Ordering::SeqCst);
        }

@@ -760,7 +734,7 @@ impl StaticConfig {

        value.apply_globals()?;

-        let stackbar_mode = STACKBAR_MODE.load();
+        let stackbar_mode = *STACKBAR_MODE.lock();

        for m in wm.monitors_mut() {
            for w in m.workspaces_mut() {
@@ -775,10 +749,6 @@ impl StaticConfig {
                if let Some(m) = wm.monitors_mut().get_mut(i) {
                    m.ensure_workspace_count(monitor.workspaces.len());
                    m.set_work_area_offset(monitor.work_area_offset);
-                    m.set_window_based_work_area_offset(monitor.window_based_work_area_offset);
-                    m.set_window_based_work_area_offset_limit(
-                        monitor.window_based_work_area_offset_limit.unwrap_or(1),
-                    );

                    for (j, ws) in m.workspaces_mut().iter_mut().enumerate() {
                        ws.load_static_config(
@@ -806,7 +776,7 @@ impl StaticConfig {
            }
        }

-        if let Some(enabled) = value.border {
+        if let Some(enabled) = value.active_window_border {
            border_manager::BORDER_ENABLED.store(enabled, Ordering::SeqCst);
        }

--- a/komorebi/src/window.rs
+++ b/komorebi/src/window.rs
@@ -38,7 +38,7 @@ use crate::PERMAIGNORE_CLASSES;
 use crate::REGEX_IDENTIFIERS;
 use crate::WSL2_UI_PROCESSES;

-#[derive(Debug, Default, Clone, Copy, Deserialize, JsonSchema)]
+#[derive(Debug, Clone, Copy, Deserialize, JsonSchema)]
 pub struct Window {
    pub hwnd: isize,
 }
@@ -139,10 +139,6 @@ impl Window {
    }

    pub fn set_position(&self, layout: &Rect, top: bool) -> Result<()> {
-        if WindowsApi::window_rect(self.hwnd())?.eq(layout) {
-            return Ok(());
-        }
-
        let rect = *layout;
        WindowsApi::position_window(self.hwnd(), &rect, top)
    }
@@ -227,11 +223,6 @@ impl Window {
        // If the target window is already focused, do nothing.
        if let Ok(ihwnd) = WindowsApi::foreground_window() {
            if HWND(ihwnd) == self.hwnd() {
-                // Center cursor in Window
-                if mouse_follows_focus {
-                    WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(self.hwnd())?)?;
-                }
-
                return Ok(());
            }
        }
--- a/komorebi/src/window_manager.rs
+++ b/komorebi/src/window_manager.rs
@@ -24,9 +24,9 @@ use uds_windows::UnixListener;

 use komorebi_core::config_generation::MatchingRule;
 use komorebi_core::custom_layout::CustomLayout;
+use komorebi_core::ActiveWindowBorderStyle;
 use komorebi_core::Arrangement;
 use komorebi_core::Axis;
-use komorebi_core::BorderStyle;
 use komorebi_core::CycleDirection;
 use komorebi_core::DefaultLayout;
 use komorebi_core::FocusFollowsMouseImplementation;
@@ -52,7 +52,7 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent_listener;
 use crate::workspace::Workspace;
-use crate::BorderColours;
+use crate::ActiveWindowBorderColours;
 use crate::Colour;
 use crate::Rgb;
 use crate::WorkspaceRule;
@@ -81,6 +81,7 @@ use komorebi_core::StackbarMode;
 #[derive(Debug)]
 pub struct WindowManager {
    pub monitors: Ring<Monitor>,
+    pub monitor_cache: HashMap<usize, Monitor>,
    pub incoming_events: Receiver<WindowManagerEvent>,
    pub command_listener: UnixListener,
    pub is_paused: bool,
@@ -116,9 +117,9 @@ pub struct State {
 #[allow(clippy::struct_excessive_bools)]
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct GlobalState {
-    pub border_enabled: bool,
-    pub border_colours: BorderColours,
-    pub border_style: BorderStyle,
+    pub active_window_border_enabled: bool,
+    pub active_window_border_colours: ActiveWindowBorderColours,
+    pub active_window_border_style: ActiveWindowBorderStyle,
    pub border_offset: i32,
    pub border_width: i32,
    pub stackbar_mode: StackbarMode,
@@ -145,8 +146,8 @@ pub struct GlobalState {
 impl Default for GlobalState {
    fn default() -> Self {
        Self {
-            border_enabled: border_manager::BORDER_ENABLED.load(Ordering::SeqCst),
-            border_colours: BorderColours {
+            active_window_border_enabled: border_manager::BORDER_ENABLED.load(Ordering::SeqCst),
+            active_window_border_colours: ActiveWindowBorderColours {
                single: Option::from(Colour::Rgb(Rgb::from(
                    border_manager::FOCUSED.load(Ordering::SeqCst),
                ))),
@@ -160,10 +161,10 @@ impl Default for GlobalState {
                    border_manager::UNFOCUSED.load(Ordering::SeqCst),
                ))),
            },
-            border_style: *STYLE.lock(),
+            active_window_border_style: *STYLE.lock(),
            border_offset: border_manager::BORDER_OFFSET.load(Ordering::SeqCst),
            border_width: border_manager::BORDER_WIDTH.load(Ordering::SeqCst),
-            stackbar_mode: STACKBAR_MODE.load(),
+            stackbar_mode: *STACKBAR_MODE.lock(),
            stackbar_focused_text_colour: Colour::Rgb(Rgb::from(
                STACKBAR_FOCUSED_TEXT_COLOUR.load(Ordering::SeqCst),
            )),
@@ -261,6 +262,7 @@ impl WindowManager {

        Ok(Self {
            monitors: Ring::default(),
+            monitor_cache: HashMap::new(),
            incoming_events: incoming,
            command_listener: listener,
            is_paused: false,
@@ -383,6 +385,155 @@ impl WindowManager {
        None
    }

+    #[tracing::instrument(skip(self))]
+    pub fn reconcile_monitors(&mut self) -> Result<()> {
+        if self.pending_move_op.is_some() {
+            return Ok(());
+        }
+
+        let valid_hmonitors = WindowsApi::valid_hmonitors()?;
+        let mut valid_names = vec![];
+        let before_count = self.monitors().len();
+
+        for monitor in self.monitors_mut() {
+            for (valid_name, valid_id) in &valid_hmonitors {
+                let actual_name = monitor.name().clone();
+                if actual_name == *valid_name {
+                    monitor.set_id(*valid_id);
+                    valid_names.push(actual_name);
+                }
+            }
+        }
+
+        let mut orphaned_containers = vec![];
+        let mut invalid_indices = vec![];
+
+        for (i, invalid) in self
+            .monitors()
+            .iter()
+            .enumerate()
+            .filter(|(_, m)| !valid_names.contains(m.name()))
+        {
+            invalid_indices.push(i);
+            for workspace in invalid.workspaces() {
+                for container in workspace.containers() {
+                    // Save the orphaned containers from an invalid monitor
+                    // (which has most likely been disconnected)
+                    orphaned_containers.push(container.clone());
+                }
+            }
+        }
+
+        for i in invalid_indices {
+            if let Some(monitor) = self.monitors().get(i) {
+                self.monitor_cache.insert(i, monitor.clone());
+            }
+        }
+
+        // Remove any invalid monitors from our state
+        self.monitors_mut()
+            .retain(|m| valid_names.contains(m.name()));
+
+        let after_count = self.monitors().len();
+
+        if let Some(primary) = self.monitors_mut().front_mut() {
+            if let Some(focused_ws) = primary.focused_workspace_mut() {
+                let focused_container_idx = focused_ws.focused_container_idx();
+
+                // Put the orphaned containers somewhere visible
+                for container in orphaned_containers {
+                    focused_ws.add_container(container);
+                }
+
+                // Gotta reset the focus or the movement will feel "off"
+                if before_count != after_count {
+                    focused_ws.focus_container(focused_container_idx);
+                }
+            }
+        }
+
+        let offset = self.work_area_offset;
+
+        for monitor in self.monitors_mut() {
+            // If we have lost a monitor, update everything to filter out any jank
+            let mut should_update = before_count != after_count;
+
+            let reference = WindowsApi::monitor(monitor.id())?;
+            if reference.work_area_size() != monitor.work_area_size() {
+                monitor.set_work_area_size(Rect {
+                    left: reference.work_area_size().left,
+                    top: reference.work_area_size().top,
+                    right: reference.work_area_size().right,
+                    bottom: reference.work_area_size().bottom,
+                });
+
+                should_update = true;
+            }
+
+            if reference.size() != monitor.size() {
+                monitor.set_size(Rect {
+                    left: reference.size().left,
+                    top: reference.size().top,
+                    right: reference.size().right,
+                    bottom: reference.size().bottom,
+                });
+
+                should_update = true;
+            }
+
+            if should_update {
+                monitor.update_focused_workspace(offset)?;
+            }
+        }
+
+        #[allow(clippy::needless_collect)]
+        let old_sizes = self
+            .monitors()
+            .iter()
+            .map(Monitor::size)
+            .copied()
+            .collect::<Vec<_>>();
+
+        // Check for and add any new monitors that may have been plugged in
+        WindowsApi::load_monitor_information(&mut self.monitors)?;
+
+        let mut check_cache = vec![];
+
+        for (i, m) in self.monitors().iter().enumerate() {
+            if !old_sizes.contains(m.size()) {
+                check_cache.push(i);
+            }
+        }
+
+        for i in check_cache {
+            if let Some(cached) = self.monitor_cache.get(&i).cloned() {
+                if let Some(monitor) = self.monitors_mut().get_mut(i) {
+                    for (w_idx, workspace) in monitor.workspaces_mut().iter_mut().enumerate() {
+                        if let Some(cached_workspace) = cached.workspaces().get(w_idx) {
+                            workspace.set_layout(cached_workspace.layout().clone());
+                            workspace.set_layout_rules(cached_workspace.layout_rules().clone());
+                            workspace.set_layout_flip(cached_workspace.layout_flip());
+                            workspace.set_workspace_padding(cached_workspace.workspace_padding());
+                            workspace.set_container_padding(cached_workspace.container_padding());
+                        }
+                    }
+                }
+            }
+        }
+
+        let final_count = self.monitors().len();
+        if after_count != final_count {
+            self.retile_all(true)?;
+            // Second retile to fix DPI/resolution related jank when a window
+            // moves between monitors with different resolutions - this doesn't
+            // really get seen by the user since the screens are flickering anyway
+            // as a result of the display connections / disconnections
+            self.retile_all(true)?;
+        }
+
+        Ok(())
+    }
+
    #[allow(clippy::too_many_arguments)]
    #[tracing::instrument(skip(self), level = "debug")]
    fn add_window_handle_to_move_based_on_workspace_rule(
@@ -562,11 +713,6 @@ impl WindowManager {

        for monitor in self.monitors_mut() {
            let work_area = *monitor.work_area_size();
-            let window_based_work_area_offset = (
-                monitor.window_based_work_area_offset_limit(),
-                monitor.window_based_work_area_offset(),
-            );
-
            let offset = if monitor.work_area_offset().is_some() {
                monitor.work_area_offset()
            } else {
@@ -584,7 +730,7 @@ impl WindowManager {
                }
            }

-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
        }

        Ok(())
@@ -1131,9 +1277,6 @@ impl WindowManager {

        let new_idx = workspace.new_idx_for_direction(direction);

-        // TODO: clean this up, this is awful
-        let mut cross_monitor_monocle = false;
-
        // if there is no container in that direction for this workspace
        match new_idx {
            None => {
@@ -1142,19 +1285,6 @@ impl WindowManager {
                    .ok_or_else(|| anyhow!("there is no container or monitor in this direction"))?;

                self.focus_monitor(monitor_idx)?;
-
-                if let Ok(focused_workspace) = self.focused_workspace() {
-                    if let Some(monocle) = focused_workspace.monocle_container() {
-                        if let Some(window) = monocle.focused_window() {
-                            window.focus(self.mouse_follows_focus)?;
-                            WindowsApi::center_cursor_in_rect(&WindowsApi::window_rect(
-                                window.hwnd(),
-                            )?)?;
-
-                            cross_monitor_monocle = true;
-                        }
-                    }
-                }
            }
            Some(idx) => {
                let workspace = self.focused_workspace_mut()?;
@@ -1169,16 +1299,13 @@ impl WindowManager {
        // With this piece of code, we check if we have changed focus to a container stack with
        // a stackbar, and if we have, we run a quick update to make sure the focused text colour
        // has been applied
-        if !cross_monitor_monocle {
-            if let Ok(focused_window) = self.focused_window_mut() {
-                let focused_window_hwnd = focused_window.hwnd;
-                focused_window.focus(self.mouse_follows_focus)?;
+        let focused_window = self.focused_window_mut()?;
+        let focused_window_hwnd = focused_window.hwnd;
+        focused_window.focus(self.mouse_follows_focus)?;

-                let focused_container = self.focused_container()?;
-                if let Some(stackbar) = focused_container.stackbar() {
-                    stackbar.update(focused_container.windows(), focused_window_hwnd)?;
-                }
-            }
+        let focused_container = self.focused_container()?;
+        if let Some(stackbar) = focused_container.stackbar() {
+            stackbar.update(focused_container.windows(), focused_window_hwnd)?;
        }

        Ok(())
@@ -1206,11 +1333,6 @@ impl WindowManager {
            // If there is nowhere to move on the current workspace, try to move it onto the monitor
            // in that direction if there is one
            None => {
-                // Don't do anything if the user has set the MoveBehaviour to NoOp
-                if matches!(self.cross_monitor_move_behaviour, MoveBehaviour::NoOp) {
-                    return Ok(());
-                }
-
                let target_monitor_idx = self
                    .monitor_idx_in_direction(direction)
                    .ok_or_else(|| anyhow!("there is no container or monitor in this direction"))?;
@@ -1229,19 +1351,7 @@ impl WindowManager {
                    // focus the target monitor
                    self.focus_monitor(target_monitor_idx)?;

-                    // unset monocle container on target workspace if there is one
-                    let mut target_workspace_has_monocle = false;
-                    if let Ok(target_workspace) = self.focused_workspace() {
-                        if target_workspace.monocle_container().is_some() {
-                            target_workspace_has_monocle = true;
-                        }
-                    }
-
-                    if target_workspace_has_monocle {
-                        self.toggle_monocle()?;
-                    }
-
-                    // get a mutable ref to the focused workspace on the target monitor
+                    // get the focused workspace on the target monitor
                    let target_workspace = self.focused_workspace_mut()?;

                    // insert the origin container into the focused workspace on the target monitor
@@ -1438,11 +1548,8 @@ impl WindowManager {
            })?;

            let adjusted_new_index = if new_idx > current_container_idx
-                && !matches!(
-                    workspace.layout(),
-                    Layout::Default(DefaultLayout::Grid)
-                        | Layout::Default(DefaultLayout::UltrawideVerticalStack)
-                ) {
+                && !matches!(workspace.layout(), Layout::Default(DefaultLayout::Grid))
+            {
                new_idx - 1
            } else {
                new_idx
@@ -1598,18 +1705,7 @@ impl WindowManager {
        tracing::info!("enabling monocle");

        let workspace = self.focused_workspace_mut()?;
-        workspace.new_monocle_container()?;
-
-        if let Some(monocle) = workspace.monocle_container_mut() {
-            monocle.set_stackbar_mode(StackbarMode::Never);
-        }
-
-        for container in workspace.containers_mut() {
-            container.set_stackbar_mode(StackbarMode::Never);
-            container.hide(None);
-        }
-
-        Ok(())
+        workspace.new_monocle_container()
    }

    #[tracing::instrument(skip(self))]
@@ -1617,16 +1713,6 @@ impl WindowManager {
        tracing::info!("disabling monocle");

        let workspace = self.focused_workspace_mut()?;
-
-        if let Some(monocle) = workspace.monocle_container_mut() {
-            monocle.set_stackbar_mode(STACKBAR_MODE.load());
-        }
-
-        for container in workspace.containers_mut() {
-            container.set_stackbar_mode(STACKBAR_MODE.load());
-            container.restore();
-        }
-
        workspace.reintegrate_monocle_container()
    }

@@ -1852,11 +1938,6 @@ impl WindowManager {
            .ok_or_else(|| anyhow!("there is no monitor"))?;

        let work_area = *monitor.work_area_size();
-        let window_based_work_area_offset = (
-            monitor.window_based_work_area_offset_limit(),
-            monitor.window_based_work_area_offset(),
-        );
-
        let focused_workspace_idx = monitor.focused_workspace_idx();
        let offset = if monitor.work_area_offset().is_some() {
            monitor.work_area_offset()
@@ -1876,7 +1957,7 @@ impl WindowManager {

        // If this is the focused workspace on a non-focused screen, let's update it
        if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
            Ok(())
        } else {
            Ok(self.update_focused_workspace(false, false)?)
@@ -1905,11 +1986,6 @@ impl WindowManager {
            .ok_or_else(|| anyhow!("there is no monitor"))?;

        let work_area = *monitor.work_area_size();
-        let window_based_work_area_offset = (
-            monitor.window_based_work_area_offset_limit(),
-            monitor.window_based_work_area_offset(),
-        );
-
        let focused_workspace_idx = monitor.focused_workspace_idx();
        let offset = if monitor.work_area_offset().is_some() {
            monitor.work_area_offset()
@@ -1931,7 +2007,7 @@ impl WindowManager {

        // If this is the focused workspace on a non-focused screen, let's update it
        if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
            Ok(())
        } else {
            Ok(self.update_focused_workspace(false, false)?)
@@ -1955,11 +2031,6 @@ impl WindowManager {
            .ok_or_else(|| anyhow!("there is no monitor"))?;

        let work_area = *monitor.work_area_size();
-        let window_based_work_area_offset = (
-            monitor.window_based_work_area_offset_limit(),
-            monitor.window_based_work_area_offset(),
-        );
-
        let focused_workspace_idx = monitor.focused_workspace_idx();
        let offset = if monitor.work_area_offset().is_some() {
            monitor.work_area_offset()
@@ -1977,7 +2048,7 @@ impl WindowManager {

        // If this is the focused workspace on a non-focused screen, let's update it
        if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
            Ok(())
        } else {
            Ok(self.update_focused_workspace(false, false)?)
@@ -2002,11 +2073,6 @@ impl WindowManager {
            .ok_or_else(|| anyhow!("there is no monitor"))?;

        let work_area = *monitor.work_area_size();
-        let window_based_work_area_offset = (
-            monitor.window_based_work_area_offset_limit(),
-            monitor.window_based_work_area_offset(),
-        );
-
        let focused_workspace_idx = monitor.focused_workspace_idx();
        let offset = if monitor.work_area_offset().is_some() {
            monitor.work_area_offset()
@@ -2023,7 +2089,7 @@ impl WindowManager {

        // If this is the focused workspace on a non-focused screen, let's update it
        if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
            Ok(())
        } else {
            Ok(self.update_focused_workspace(false, false)?)
@@ -2051,11 +2117,6 @@ impl WindowManager {
            .ok_or_else(|| anyhow!("there is no monitor"))?;

        let work_area = *monitor.work_area_size();
-        let window_based_work_area_offset = (
-            monitor.window_based_work_area_offset_limit(),
-            monitor.window_based_work_area_offset(),
-        );
-
        let focused_workspace_idx = monitor.focused_workspace_idx();
        let offset = if monitor.work_area_offset().is_some() {
            monitor.work_area_offset()
@@ -2073,7 +2134,7 @@ impl WindowManager {

        // If this is the focused workspace on a non-focused screen, let's update it
        if focused_monitor_idx != monitor_idx && focused_workspace_idx == workspace_idx {
-            workspace.update(&work_area, offset, window_based_work_area_offset)?;
+            workspace.update(&work_area, offset)?;
            Ok(())
        } else {
            Ok(self.update_focused_workspace(false, false)?)
@@ -2231,21 +2292,10 @@ impl WindowManager {
            }
        }

-        // our hmonitor might be stale, so if we didn't return above, try querying via the latest
-        // info taken from win32_display_data and update our hmonitor while we're at it
-        if let Ok(latest) = WindowsApi::monitor(hmonitor) {
-            for (i, monitor) in self.monitors_mut().iter_mut().enumerate() {
-                if monitor.device_id() == latest.device_id() {
-                    monitor.set_id(latest.id());
-                    return Option::from(i);
-                }
-            }
-        }
-
        None
    }

-    pub fn monitor_idx_from_current_pos(&mut self) -> Option<usize> {
+    pub fn monitor_idx_from_current_pos(&self) -> Option<usize> {
        let hmonitor = WindowsApi::monitor_from_point(WindowsApi::cursor_pos().ok()?);

        for (i, monitor) in self.monitors().iter().enumerate() {
@@ -2254,27 +2304,9 @@ impl WindowManager {
            }
        }

-        // our hmonitor might be stale, so if we didn't return above, try querying via the latest
-        // info taken from win32_display_data and update our hmonitor while we're at it
-        if let Ok(latest) = WindowsApi::monitor(hmonitor) {
-            for (i, monitor) in self.monitors_mut().iter_mut().enumerate() {
-                if monitor.device_id() == latest.device_id() {
-                    monitor.set_id(latest.id());
-                    return Option::from(i);
-                }
-            }
-        }
-
        None
    }

-    pub fn focused_workspace_idx(&self) -> Result<usize> {
-        Ok(self
-            .focused_monitor()
-            .ok_or_else(|| anyhow!("there is no monitor"))?
-            .focused_workspace_idx())
-    }
-
    pub fn focused_workspace(&self) -> Result<&Workspace> {
        self.focused_monitor()
            .ok_or_else(|| anyhow!("there is no monitor"))?
--- a/komorebi/src/window_manager_event.rs
+++ b/komorebi/src/window_manager_event.rs
@@ -27,6 +27,7 @@ pub enum WindowManagerEvent {
    Manage(Window),
    Unmanage(Window),
    Raise(Window),
+    DisplayChange(Window),
    ForceUpdate(Window),
 }

@@ -75,6 +76,9 @@ impl Display for WindowManagerEvent {
            Self::Raise(window) => {
                write!(f, "Raise (Window: {window})")
            }
+            Self::DisplayChange(window) => {
+                write!(f, "DisplayChange (Window: {window})")
+            }
            Self::ForceUpdate(window) => {
                write!(f, "ForceUpdate (Window: {window})")
            }
@@ -97,6 +101,7 @@ impl WindowManagerEvent {
            | Self::MouseCapture(_, window)
            | Self::Raise(window)
            | Self::Manage(window)
+            | Self::DisplayChange(window)
            | Self::Unmanage(window)
            | Self::ForceUpdate(window) => window,
        }
--- a/komorebi/src/windows_api.rs
+++ b/komorebi/src/windows_api.rs
@@ -4,9 +4,9 @@ use std::ffi::c_void;
 use std::mem::size_of;

 use color_eyre::eyre::anyhow;
-use color_eyre::eyre::bail;
 use color_eyre::eyre::Error;
 use color_eyre::Result;
+use widestring::U16CStr;
 use windows::core::Result as WindowsCrateResult;
 use windows::core::PCWSTR;
 use windows::core::PWSTR;
@@ -30,12 +30,14 @@ use windows::Win32::Graphics::Dwm::DWM_CLOAKED_APP;
 use windows::Win32::Graphics::Dwm::DWM_CLOAKED_INHERITED;
 use windows::Win32::Graphics::Dwm::DWM_CLOAKED_SHELL;
 use windows::Win32::Graphics::Gdi::CreateSolidBrush;
+use windows::Win32::Graphics::Gdi::EnumDisplayDevicesW;
 use windows::Win32::Graphics::Gdi::EnumDisplayMonitors;
 use windows::Win32::Graphics::Gdi::GetMonitorInfoW;
 use windows::Win32::Graphics::Gdi::MonitorFromPoint;
 use windows::Win32::Graphics::Gdi::MonitorFromWindow;
 use windows::Win32::Graphics::Gdi::Rectangle;
 use windows::Win32::Graphics::Gdi::RoundRect;
+use windows::Win32::Graphics::Gdi::DISPLAY_DEVICEW;
 use windows::Win32::Graphics::Gdi::HBRUSH;
 use windows::Win32::Graphics::Gdi::HDC;
 use windows::Win32::Graphics::Gdi::HMONITOR;
@@ -44,7 +46,6 @@ use windows::Win32::Graphics::Gdi::MONITORINFOEXW;
 use windows::Win32::Graphics::Gdi::MONITOR_DEFAULTTONEAREST;
 use windows::Win32::System::LibraryLoader::GetModuleHandleW;
 use windows::Win32::System::RemoteDesktop::ProcessIdToSessionId;
-use windows::Win32::System::RemoteDesktop::WTSRegisterSessionNotification;
 use windows::Win32::System::Threading::GetCurrentProcessId;
 use windows::Win32::System::Threading::OpenProcess;
 use windows::Win32::System::Threading::QueryFullProcessImageNameW;
@@ -94,6 +95,7 @@ use windows::Win32::UI::WindowsAndMessaging::ShowWindow;
 use windows::Win32::UI::WindowsAndMessaging::SystemParametersInfoW;
 use windows::Win32::UI::WindowsAndMessaging::WindowFromPoint;
 use windows::Win32::UI::WindowsAndMessaging::CW_USEDEFAULT;
+use windows::Win32::UI::WindowsAndMessaging::EDD_GET_DEVICE_INTERFACE_NAME;
 use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
 use windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
 use windows::Win32::UI::WindowsAndMessaging::GW_HWNDNEXT;
@@ -119,6 +121,7 @@ use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_ACTION;
 use windows::Win32::UI::WindowsAndMessaging::SYSTEM_PARAMETERS_INFO_UPDATE_FLAGS;
 use windows::Win32::UI::WindowsAndMessaging::WINDOW_LONG_PTR_INDEX;
 use windows::Win32::UI::WindowsAndMessaging::WM_CLOSE;
+use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
 use windows::Win32::UI::WindowsAndMessaging::WNDCLASSW;
 use windows::Win32::UI::WindowsAndMessaging::WNDENUMPROC;
 use windows::Win32::UI::WindowsAndMessaging::WS_DISABLED;
@@ -137,9 +140,6 @@ use crate::monitor::Monitor;
 use crate::ring::Ring;
 use crate::set_window_position::SetWindowPosition;
 use crate::windows_callbacks;
-use crate::Window;
-use crate::DISPLAY_INDEX_PREFERENCES;
-use crate::MONITOR_INDEX_PREFERENCES;

 pub enum WindowsResult<T, E> {
    Err(E),
@@ -220,74 +220,58 @@ impl WindowsApi {
    }

    pub fn valid_hmonitors() -> Result<Vec<(String, isize)>> {
-        Ok(win32_display_data::connected_displays()
-            .flatten()
-            .map(|d| {
-                let name = d.device_name.trim_start_matches(r"\\.\").to_string();
-                let name = name.split('\\').collect::<Vec<_>>()[0].to_string();
+        let mut monitors: Vec<(String, isize)> = vec![];
+        let monitors_ref: &mut Vec<(String, isize)> = monitors.as_mut();
+        Self::enum_display_monitors(
+            Some(windows_callbacks::valid_display_monitors),
+            monitors_ref as *mut Vec<(String, isize)> as isize,
+        )?;

-                (name, d.hmonitor)
-            })
-            .collect::<Vec<_>>())
+        Ok(monitors)
    }

    pub fn load_monitor_information(monitors: &mut Ring<Monitor>) -> Result<()> {
-        'read: for display in win32_display_data::connected_displays().flatten() {
-            let path = display.device_path.clone();
-            let mut split: Vec<_> = path.split('#').collect();
-            split.remove(0);
-            split.remove(split.len() - 1);
-            let device = split[0].to_string();
-            let device_id = split.join("-");
+        Self::enum_display_monitors(
+            Some(windows_callbacks::enum_display_monitor),
+            monitors as *mut Ring<Monitor> as isize,
+        )?;

-            let name = display.device_name.trim_start_matches(r"\\.\").to_string();
-            let name = name.split('\\').collect::<Vec<_>>()[0].to_string();
+        Ok(())
+    }

-            for monitor in monitors.elements() {
-                if device_id.eq(monitor.device_id()) {
-                    continue 'read;
-                }
-            }
+    pub fn enum_display_devices(
+        index: u32,
+        lp_device: Option<*const u16>,
+    ) -> Result<DISPLAY_DEVICEW> {
+        #[allow(clippy::option_if_let_else)]
+        let lp_device = match lp_device {
+            None => PCWSTR::null(),
+            Some(lp_device) => PCWSTR(lp_device),
+        };

-            let m = monitor::new(
-                display.hmonitor,
-                display.size.into(),
-                display.work_area_size.into(),
-                name,
-                device,
-                device_id,
-            );
+        let mut display_device = DISPLAY_DEVICEW {
+            cb: u32::try_from(std::mem::size_of::<DISPLAY_DEVICEW>())?,
+            ..Default::default()
+        };

-            let mut index_preference = None;
-            let monitor_index_preferences = MONITOR_INDEX_PREFERENCES.lock();
-            for (index, monitor_size) in &*monitor_index_preferences {
-                if m.size() == monitor_size {
-                    index_preference = Option::from(index);
-                }
-            }
-
-            let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
-            for (index, id) in &*display_index_preferences {
-                if id.eq(m.device_id()) {
-                    index_preference = Option::from(index);
-                }
-            }
-
-            if monitors.elements().is_empty() {
-                monitors.elements_mut().push_back(m);
-            } else if let Some(preference) = index_preference {
-                let current_len = monitors.elements().len();
-                if *preference > current_len {
-                    monitors.elements_mut().reserve(1);
-                }
-
-                monitors.elements_mut().insert(*preference, m);
-            } else {
-                monitors.elements_mut().push_back(m);
+        match unsafe {
+            EnumDisplayDevicesW(
+                lp_device,
+                index,
+                std::ptr::addr_of_mut!(display_device),
+                EDD_GET_DEVICE_INTERFACE_NAME,
+            )
+        }
+        .ok()
+        {
+            Ok(()) => {}
+            Err(error) => {
+                tracing::error!("enum_display_devices: {}", error);
+                return Err(error.into());
            }
        }

-        Ok(())
+        Ok(display_device)
    }

    pub fn enum_windows(callback: WNDENUMPROC, callback_data_address: isize) -> Result<()> {
@@ -449,6 +433,13 @@ impl WindowsApi {
        }
    }

+    pub fn destroy_window(hwnd: HWND) -> Result<()> {
+        match Self::post_message(hwnd, WM_DESTROY, WPARAM(0), LPARAM(0)) {
+            Ok(()) => Ok(()),
+            Err(_) => Err(anyhow!("could not close window")),
+        }
+    }
+
    pub fn hide_window(hwnd: HWND) {
        Self::show_window(hwnd, SW_HIDE);
    }
@@ -510,16 +501,6 @@ impl WindowsApi {
        unsafe { GetWindow(hwnd, GW_HWNDNEXT) }.process()
    }

-    pub fn alt_tab_windows() -> Result<Vec<Window>> {
-        let mut hwnds = vec![];
-        Self::enum_windows(
-            Some(windows_callbacks::alt_tab_windows),
-            &mut hwnds as *mut Vec<Window> as isize,
-        )?;
-
-        Ok(hwnds)
-    }
-
    #[allow(dead_code)]
    pub fn top_visible_window() -> Result<isize> {
        let hwnd = Self::top_window()?;
@@ -791,32 +772,20 @@ impl WindowsApi {
    }

    pub fn monitor(hmonitor: isize) -> Result<Monitor> {
-        for display in win32_display_data::connected_displays().flatten() {
-            if display.hmonitor == hmonitor {
-                let path = display.device_path;
-                let mut split: Vec<_> = path.split('#').collect();
-                split.remove(0);
-                split.remove(split.len() - 1);
-                let device = split[0].to_string();
-                let device_id = split.join("-");
+        let ex_info = Self::monitor_info_w(HMONITOR(hmonitor))?;
+        let name = U16CStr::from_slice_truncate(&ex_info.szDevice)
+            .expect("monitor name was not a valid u16 c string")
+            .to_ustring()
+            .to_string_lossy()
+            .trim_start_matches(r"\\.\")
+            .to_string();

-                let name = display.device_name.trim_start_matches(r"\\.\").to_string();
-                let name = name.split('\\').collect::<Vec<_>>()[0].to_string();
-
-                let monitor = monitor::new(
-                    hmonitor,
-                    display.size.into(),
-                    display.work_area_size.into(),
-                    name,
-                    device,
-                    device_id,
-                );
-
-                return Ok(monitor);
-            }
-        }
-
-        bail!("could not find device_id for hmonitor: {hmonitor}");
+        Ok(monitor::new(
+            hmonitor,
+            ex_info.monitorInfo.rcMonitor.into(),
+            ex_info.monitorInfo.rcWork.into(),
+            name,
+        ))
    }

    pub fn set_process_dpi_awareness_context() -> Result<()> {
@@ -1059,8 +1028,4 @@ impl WindowsApi {
            SendInput(&inputs, std::mem::size_of::<INPUT>() as i32)
        }
    }
-
-    pub fn wts_register_session_notification(hwnd: isize) -> Result<()> {
-        unsafe { WTSRegisterSessionNotification(HWND(hwnd), 1) }.process()
-    }
 }
--- a/komorebi/src/windows_callbacks.rs
+++ b/komorebi/src/windows_callbacks.rs
@@ -1,17 +1,129 @@
 use std::collections::VecDeque;
+use widestring::U16CStr;

 use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
+use windows::Win32::Foundation::LRESULT;
+use windows::Win32::Foundation::RECT;
+use windows::Win32::Foundation::WPARAM;
+use windows::Win32::Graphics::Gdi::HDC;
+use windows::Win32::Graphics::Gdi::HMONITOR;
 use windows::Win32::UI::Accessibility::HWINEVENTHOOK;
+use windows::Win32::UI::WindowsAndMessaging::DefWindowProcW;
+use windows::Win32::UI::WindowsAndMessaging::DBT_DEVNODES_CHANGED;
+use windows::Win32::UI::WindowsAndMessaging::SPI_ICONVERTICALSPACING;
+use windows::Win32::UI::WindowsAndMessaging::SPI_SETWORKAREA;
+use windows::Win32::UI::WindowsAndMessaging::WM_DEVICECHANGE;
+use windows::Win32::UI::WindowsAndMessaging::WM_DISPLAYCHANGE;
+use windows::Win32::UI::WindowsAndMessaging::WM_SETTINGCHANGE;

 use crate::container::Container;
+use crate::monitor::Monitor;
+use crate::ring::Ring;
 use crate::window::RuleDebug;
 use crate::window::Window;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
 use crate::winevent_listener;
+use crate::DISPLAY_INDEX_PREFERENCES;
+use crate::MONITOR_INDEX_PREFERENCES;
+
+pub extern "system" fn valid_display_monitors(
+    hmonitor: HMONITOR,
+    _: HDC,
+    _: *mut RECT,
+    lparam: LPARAM,
+) -> BOOL {
+    let monitors = unsafe { &mut *(lparam.0 as *mut Vec<(String, isize)>) };
+    if let Ok(m) = WindowsApi::monitor(hmonitor.0) {
+        monitors.push((m.name().to_string(), hmonitor.0));
+    }
+
+    true.into()
+}
+
+pub extern "system" fn enum_display_monitor(
+    hmonitor: HMONITOR,
+    _: HDC,
+    _: *mut RECT,
+    lparam: LPARAM,
+) -> BOOL {
+    let monitors = unsafe { &mut *(lparam.0 as *mut Ring<Monitor>) };
+
+    // Don't duplicate a monitor that is already being managed
+    for monitor in monitors.elements() {
+        if monitor.id() == hmonitor.0 {
+            return true.into();
+        }
+    }
+
+    let current_index = monitors.elements().len();
+
+    if let Ok(mut m) = WindowsApi::monitor(hmonitor.0) {
+        #[allow(clippy::cast_possible_truncation)]
+        if let Ok(d) = WindowsApi::enum_display_devices(current_index as u32, None) {
+            let name = U16CStr::from_slice_truncate(d.DeviceName.as_ref())
+                .expect("display device name was not a valid u16 c string")
+                .to_ustring()
+                .to_string_lossy()
+                .trim_start_matches(r"\\.\")
+                .to_string();
+
+            if name.eq(m.name()) {
+                if let Ok(device) = WindowsApi::enum_display_devices(0, Some(d.DeviceName.as_ptr()))
+                {
+                    let id = U16CStr::from_slice_truncate(device.DeviceID.as_ref())
+                        .expect("display device id was not a valid u16 c string")
+                        .to_ustring()
+                        .to_string_lossy()
+                        .trim_start_matches(r"\\?\")
+                        .to_string();
+
+                    let mut split: Vec<_> = id.split('#').collect();
+                    split.remove(0);
+                    split.remove(split.len() - 1);
+
+                    m.set_device(Option::from(split[0].to_string()));
+                    m.set_device_id(Option::from(split.join("-")));
+                }
+            }
+        }
+
+        let monitor_index_preferences = MONITOR_INDEX_PREFERENCES.lock();
+        let mut index_preference = None;
+        for (index, monitor_size) in &*monitor_index_preferences {
+            if m.size() == monitor_size {
+                index_preference = Option::from(index);
+            }
+        }
+
+        let display_index_preferences = DISPLAY_INDEX_PREFERENCES.lock();
+        for (index, device) in &*display_index_preferences {
+            if let Some(known_device) = m.device_id() {
+                if device == known_device {
+                    index_preference = Option::from(index);
+                }
+            }
+        }
+
+        if monitors.elements().is_empty() {
+            monitors.elements_mut().push_back(m);
+        } else if let Some(preference) = index_preference {
+            let current_len = monitors.elements().len();
+            if *preference > current_len {
+                monitors.elements_mut().reserve(1);
+            }
+
+            monitors.elements_mut().insert(*preference, m);
+        } else {
+            monitors.elements_mut().push_back(m);
+        }
+    }
+
+    true.into()
+}

 pub extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
    let containers = unsafe { &mut *(lparam.0 as *mut VecDeque<Container>) };
@@ -40,26 +152,6 @@ pub extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
    true.into()
 }

-pub extern "system" fn alt_tab_windows(hwnd: HWND, lparam: LPARAM) -> BOOL {
-    let windows = unsafe { &mut *(lparam.0 as *mut Vec<Window>) };
-
-    let is_visible = WindowsApi::is_window_visible(hwnd);
-    let is_window = WindowsApi::is_window(hwnd);
-    let is_minimized = WindowsApi::is_iconic(hwnd);
-
-    if is_visible && is_window && !is_minimized {
-        let window = Window { hwnd: hwnd.0 };
-
-        if let Ok(should_manage) = window.should_manage(None, &mut RuleDebug::default()) {
-            if should_manage {
-                windows.push(window);
-            }
-        }
-    }
-
-    true.into()
-}
-
 pub extern "system" fn win_event_hook(
    _h_win_event_hook: HWINEVENTHOOK,
    event: u32,
@@ -89,3 +181,48 @@ pub extern "system" fn win_event_hook(
        .send(event_type)
        .expect("could not send message on winevent_listener::event_tx");
 }
+
+pub extern "system" fn hidden_window(
+    window: HWND,
+    message: u32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+) -> LRESULT {
+    unsafe {
+        match message {
+            WM_DISPLAYCHANGE => {
+                let event_type = WindowManagerEvent::DisplayChange(Window { hwnd: window.0 });
+                winevent_listener::event_tx()
+                    .send(event_type)
+                    .expect("could not send message on winevent_listener::event_tx");
+
+                LRESULT(0)
+            }
+            // Added based on this https://stackoverflow.com/a/33762334
+            WM_SETTINGCHANGE => {
+                #[allow(clippy::cast_possible_truncation)]
+                if wparam.0 as u32 == SPI_SETWORKAREA.0
+                    || wparam.0 as u32 == SPI_ICONVERTICALSPACING.0
+                {
+                    let event_type = WindowManagerEvent::DisplayChange(Window { hwnd: window.0 });
+                    winevent_listener::event_tx()
+                        .send(event_type)
+                        .expect("could not send message on winevent_listener::event_tx");
+                }
+                LRESULT(0)
+            }
+            // Added based on this https://stackoverflow.com/a/33762334
+            WM_DEVICECHANGE => {
+                #[allow(clippy::cast_possible_truncation)]
+                if wparam.0 as u32 == DBT_DEVNODES_CHANGED {
+                    let event_type = WindowManagerEvent::DisplayChange(Window { hwnd: window.0 });
+                    winevent_listener::event_tx()
+                        .send(event_type)
+                        .expect("could not send message on winevent_listener::event_tx");
+                }
+                LRESULT(0)
+            }
+            _ => DefWindowProcW(window, message, wparam, lparam),
+        }
+    }
+}
--- a/komorebi/src/workspace.rs
+++ b/komorebi/src/workspace.rs
@@ -179,14 +179,6 @@ impl Workspace {
    }

    pub fn restore(&mut self, mouse_follows_focus: bool) -> Result<()> {
-        if let Some(container) = self.monocle_container_mut() {
-            if let Some(window) = container.focused_window() {
-                container.restore();
-                window.focus(mouse_follows_focus)?;
-                return Ok(());
-            }
-        }
-
        let idx = self.focused_container_idx();
        let mut to_focus = None;

@@ -204,6 +196,10 @@ impl Workspace {
            container.restore();
        }

+        if let Some(container) = self.monocle_container_mut() {
+            container.restore();
+        }
+
        for window in self.floating_windows() {
            window.restore();
        }
@@ -223,21 +219,13 @@ impl Workspace {
        Ok(())
    }

-    pub fn update(
-        &mut self,
-        work_area: &Rect,
-        work_area_offset: Option<Rect>,
-        window_based_work_area_offset: (isize, Option<Rect>),
-    ) -> Result<()> {
+    pub fn update(&mut self, work_area: &Rect, offset: Option<Rect>) -> Result<()> {
        if !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
            return Ok(());
        }

-        let (window_based_work_area_offset_limit, window_based_work_area_offset) =
-            window_based_work_area_offset;
-
        let container_padding = self.container_padding();
-        let mut adjusted_work_area = work_area_offset.map_or_else(
+        let mut adjusted_work_area = offset.map_or_else(
            || *work_area,
            |offset| {
                let mut with_offset = *work_area;
@@ -250,21 +238,6 @@ impl Workspace {
            },
        );

-        if self.containers().len() <= window_based_work_area_offset_limit as usize {
-            adjusted_work_area = window_based_work_area_offset.map_or_else(
-                || adjusted_work_area,
-                |offset| {
-                    let mut with_offset = adjusted_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().unwrap_or_default());

        self.enforce_resize_constraints();
--- a/komorebi/src/workspace_reconciliator.rs
+++ b/komorebi/src/workspace_reconciliator.rs
@@ -1,116 +0,0 @@
-#![deny(clippy::unwrap_used, clippy::expect_used)]
-
-use crate::border_manager;
-use crate::WindowManager;
-use crossbeam_channel::Receiver;
-use crossbeam_channel::Sender;
-use crossbeam_utils::atomic::AtomicCell;
-use lazy_static::lazy_static;
-use parking_lot::Mutex;
-use std::sync::Arc;
-use std::sync::OnceLock;
-use std::time::Duration;
-use std::time::Instant;
-
-#[derive(Copy, Clone)]
-pub struct Notification {
-    pub monitor_idx: usize,
-    pub workspace_idx: usize,
-}
-
-pub static ALT_TAB_HWND: AtomicCell<Option<isize>> = AtomicCell::new(None);
-
-lazy_static! {
-    pub static ref ALT_TAB_HWND_INSTANT: Arc<Mutex<Instant>> = Arc::new(Mutex::new(Instant::now()));
-}
-
-static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
-
-pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
-    CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
-}
-
-pub fn event_tx() -> Sender<Notification> {
-    channel().0.clone()
-}
-
-pub fn event_rx() -> Receiver<Notification> {
-    channel().1.clone()
-}
-
-pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || loop {
-        match handle_notifications(wm.clone()) {
-            Ok(()) => {
-                tracing::warn!("restarting finished thread");
-            }
-            Err(error) => {
-                if cfg!(debug_assertions) {
-                    tracing::error!("restarting failed thread: {:?}", error)
-                } else {
-                    tracing::error!("restarting failed thread: {}", error)
-                }
-            }
-        }
-    });
-}
-pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
-    tracing::info!("listening");
-
-    let receiver = event_rx();
-    let arc = wm.clone();
-
-    for notification in receiver {
-        tracing::info!("running reconciliation");
-
-        let mut wm = wm.lock();
-        let focused_monitor_idx = wm.focused_monitor_idx();
-        let focused_workspace_idx =
-            wm.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;
-
-        let focused_pair = (focused_monitor_idx, focused_workspace_idx);
-        let updated_pair = (notification.monitor_idx, notification.workspace_idx);
-
-        if focused_pair != updated_pair {
-            wm.focus_monitor(notification.monitor_idx)?;
-            let mouse_follows_focus = wm.mouse_follows_focus;
-
-            if let Some(monitor) = wm.focused_monitor_mut() {
-                monitor.focus_workspace(notification.workspace_idx)?;
-                monitor.load_focused_workspace(mouse_follows_focus)?;
-            }
-
-            // Drop our lock on the window manager state here to not slow down updates
-            drop(wm);
-
-            // Check if there was an alt-tab across workspaces in the last second
-            if let Some(hwnd) = ALT_TAB_HWND.load() {
-                if ALT_TAB_HWND_INSTANT
-                    .lock()
-                    .elapsed()
-                    .lt(&Duration::from_secs(1))
-                {
-                    // Sleep for 100 millis to let other events pass
-                    std::thread::sleep(Duration::from_millis(100));
-                    tracing::info!("focusing alt-tabbed window");
-
-                    // Take a new lock on the wm and try to focus the container with
-                    // the recorded HWND from the alt-tab
-                    let mut wm = arc.lock();
-                    if let Ok(workspace) = wm.focused_workspace_mut() {
-                        // Regardless of if this fails, we need to get past this part
-                        // to unblock the border manager below
-                        let _ = workspace.focus_container_by_window(hwnd);
-                    }
-
-                    // Unblock the border manager
-                    ALT_TAB_HWND.store(None);
-                    // Send a notification to the border manager to update the borders
-                    border_manager::event_tx().send(border_manager::Notification)?;
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
--- a/komorebic/Cargo.toml
+++ b/komorebic/Cargo.toml
@@ -16,7 +16,6 @@ komorebi-core = { path = "../komorebi-core" }
 komorebi-client = { path = "../komorebi-client" }

 clap = { version = "4", features = ["derive", "wrap_help"] }
-chrono = "0.4"
 color-eyre = { workspace = true }
 dirs = { workspace = true }
 dunce = { workspace = true }
--- a/komorebic/src/main.rs
+++ b/komorebic/src/main.rs
@@ -1,7 +1,6 @@
 #![warn(clippy::all, clippy::nursery, clippy::pedantic)]
 #![allow(clippy::missing_errors_doc)]

-use chrono::Local;
 use std::fs::File;
 use std::fs::OpenOptions;
 use std::io::BufRead;
@@ -161,7 +160,6 @@ gen_enum_subcommand_args! {
    CycleMoveToMonitor: CycleDirection,
    CycleMonitor: CycleDirection,
    CycleWorkspace: CycleDirection,
-    CycleMoveWorkspaceToMonitor: CycleDirection,
    Stack: OperationDirection,
    CycleStack: CycleDirection,
    FlipLayout: Axis,
@@ -173,7 +171,6 @@ gen_enum_subcommand_args! {
    WindowHidingBehaviour: HidingBehaviour,
    CrossMonitorMoveBehaviour: MoveBehaviour,
    UnmanagedWindowOperationBehaviour: OperationBehaviour,
-    PromoteWindow: OperationDirection,
 }

 macro_rules! gen_target_subcommand_args {
@@ -654,13 +651,13 @@ struct FocusFollowsMouse {
 }

 #[derive(Parser, AhkFunction)]
-struct Border {
+struct ActiveWindowBorder {
    #[clap(value_enum)]
    boolean_state: BooleanState,
 }

 #[derive(Parser, AhkFunction)]
-struct BorderColour {
+struct ActiveWindowBorderColour {
    #[clap(value_enum, short, long, default_value = "single")]
    window_kind: WindowKind,
    /// Red
@@ -672,14 +669,14 @@ struct BorderColour {
 }

 #[derive(Parser, AhkFunction)]
-struct BorderWidth {
-    /// Desired width of the window border
+struct ActiveWindowBorderWidth {
+    /// Desired width of the active window border
    width: i32,
 }

 #[derive(Parser, AhkFunction)]
-struct BorderOffset {
-    /// Desired offset of the window border
+struct ActiveWindowBorderOffset {
+    /// Desired offset of the active window border
    offset: i32,
 }

@@ -958,9 +955,6 @@ enum SubCommand {
    /// Move the focused workspace to the specified monitor
    #[clap(arg_required_else_help = true)]
    MoveWorkspaceToMonitor(MoveWorkspaceToMonitor),
-    /// Move the focused workspace monitor in the given cycle direction
-    #[clap(arg_required_else_help = true)]
-    CycleMoveWorkspaceToMonitor(CycleMoveWorkspaceToMonitor),
    /// Swap focused monitor workspaces with specified monitor
    #[clap(arg_required_else_help = true)]
    SwapWorkspacesWithMonitor(SwapWorkspacesWithMonitor),
@@ -1006,8 +1000,6 @@ enum SubCommand {
    Promote,
    /// Promote the user focus to the top of the tree
    PromoteFocus,
-    /// Promote the window in the specified direction
-    PromoteWindow(PromoteWindow),
    /// Force the retiling of all managed windows
    Retile,
    /// Set the monitor index preference for a monitor identified using its size
@@ -1149,22 +1141,18 @@ enum SubCommand {
    #[clap(hide = true)]
    #[clap(alias = "identify-border-overflow")]
    IdentifyBorderOverflowApplication(IdentifyBorderOverflowApplication),
-    /// Enable or disable borders
+    /// Enable or disable the active window border
    #[clap(arg_required_else_help = true)]
-    #[clap(alias = "active-window-border")]
-    Border(Border),
-    /// Set the colour for a window border kind
+    ActiveWindowBorder(ActiveWindowBorder),
+    /// Set the colour for the active window border
    #[clap(arg_required_else_help = true)]
-    #[clap(alias = "active-window-border-colour")]
-    BorderColour(BorderColour),
-    /// Set the border width
+    ActiveWindowBorderColour(ActiveWindowBorderColour),
+    /// Set the width for the active window border
    #[clap(arg_required_else_help = true)]
-    #[clap(alias = "active-window-border-width")]
-    BorderWidth(BorderWidth),
-    /// Set the border offset
+    ActiveWindowBorderWidth(ActiveWindowBorderWidth),
+    /// Set the offset for the active window border
    #[clap(arg_required_else_help = true)]
-    #[clap(alias = "active-window-border-offset")]
-    BorderOffset(BorderOffset),
+    ActiveWindowBorderOffset(ActiveWindowBorderOffset),
    /// Enable or disable focus follows mouse for the operating system
    #[clap(arg_required_else_help = true)]
    FocusFollowsMouse(FocusFollowsMouse),
@@ -1491,8 +1479,7 @@ fn main() -> Result<()> {
            println!("\n#Include komorebic.lib.ahk");
        }
        SubCommand::Log => {
-            let timestamp = Local::now().format("%Y-%m-%d").to_string();
-            let color_log = std::env::temp_dir().join(format!("komorebi.log.{timestamp}"));
+            let color_log = std::env::temp_dir().join("komorebi.log");
            let file = TailedFile::new(File::open(color_log)?);
            let locked = file.lock();
            #[allow(clippy::significant_drop_in_scrutinee, clippy::lines_filter_map_ok)]
@@ -1518,9 +1505,6 @@ fn main() -> Result<()> {
        SubCommand::PromoteFocus => {
            send_message(&SocketMessage::PromoteFocus.as_bytes()?)?;
        }
-        SubCommand::PromoteWindow(arg) => {
-            send_message(&SocketMessage::PromoteWindow(arg.operation_direction).as_bytes()?)?;
-        }
        SubCommand::TogglePause => {
            send_message(&SocketMessage::TogglePause.as_bytes()?)?;
        }
@@ -1595,11 +1579,6 @@ fn main() -> Result<()> {
        SubCommand::MoveWorkspaceToMonitor(arg) => {
            send_message(&SocketMessage::MoveWorkspaceToMonitorNumber(arg.target).as_bytes()?)?;
        }
-        SubCommand::CycleMoveWorkspaceToMonitor(arg) => {
-            send_message(
-                &SocketMessage::CycleMoveWorkspaceToMonitor(arg.cycle_direction).as_bytes()?,
-            )?;
-        }
        SubCommand::SwapWorkspacesWithMonitor(arg) => {
            send_message(&SocketMessage::SwapWorkspacesToMonitorNumber(arg.target).as_bytes()?)?;
        }
@@ -1951,7 +1930,6 @@ if (!(Get-Process whkd -ErrorAction SilentlyContinue))
                "* Subscribe to https://youtube.com/@LGUG2Z - Live dev videos and feature previews"
            );
            println!("* Join the Discord https://discord.gg/mGkn66PHkx - Chat, ask questions, share your desktops");
-            println!("* Read the docs https://lgug2z.github.io/komorebi - Quickly search through all komorebic commands");
        }
        SubCommand::Stop(arg) => {
            if arg.whkd {
@@ -2234,18 +2212,19 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
        SubCommand::MouseFollowsFocus(arg) => {
            send_message(&SocketMessage::MouseFollowsFocus(arg.boolean_state.into()).as_bytes()?)?;
        }
-        SubCommand::Border(arg) => {
-            send_message(&SocketMessage::Border(arg.boolean_state.into()).as_bytes()?)?;
+        SubCommand::ActiveWindowBorder(arg) => {
+            send_message(&SocketMessage::ActiveWindowBorder(arg.boolean_state.into()).as_bytes()?)?;
        }
-        SubCommand::BorderColour(arg) => {
+        SubCommand::ActiveWindowBorderColour(arg) => {
            send_message(
-                &SocketMessage::BorderColour(arg.window_kind, arg.r, arg.g, arg.b).as_bytes()?,
+                &SocketMessage::ActiveWindowBorderColour(arg.window_kind, arg.r, arg.g, arg.b)
+                    .as_bytes()?,
            )?;
        }
-        SubCommand::BorderWidth(arg) => {
+        SubCommand::ActiveWindowBorderWidth(arg) => {
            send_message(&SocketMessage::BorderWidth(arg.width).as_bytes()?)?;
        }
-        SubCommand::BorderOffset(arg) => {
+        SubCommand::ActiveWindowBorderOffset(arg) => {
            send_message(&SocketMessage::BorderOffset(arg.offset).as_bytes()?)?;
        }
        SubCommand::ResizeDelta(arg) => {
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -57,7 +57,7 @@ nav:
      - Troubleshooting: troubleshooting.md
  - Common workflows:
      - common-workflows/komorebi-config-home.md
-      - common-workflows/borders.md
+      - common-workflows/active-window-border.md
      - common-workflows/stackbar.md
      - common-workflows/remove-gaps.md
      - common-workflows/ignore-windows.md
@@ -67,7 +67,7 @@ nav:
      - common-workflows/mouse-follows-focus.md
      - common-workflows/custom-layouts.md
      - common-workflows/dynamic-layout-switching.md
-      - common-workflows/autohotkey.md
+  #    - common-workflows/autohotkey.md
  - Release notes:
      - release/v0-1-22.md
  - Configuration reference: https://komorebi.lgug2z.com/schema
@@ -189,10 +189,10 @@ nav:
      - cli/identify-layered-application.md
      - cli/remove-title-bar.md
      - cli/toggle-title-bars.md
-      - cli/border.md
-      - cli/border-colour.md
-      - cli/border-width.md
-      - cli/border-offset.md
+      - cli/active-window-border.md
+      - cli/active-window-border-colour.md
+      - cli/active-window-border-width.md
+      - cli/active-window-border-offset.md
      - cli/focus-follows-mouse.md
      - cli/toggle-focus-follows-mouse.md
      - cli/mouse-follows-focus.md
--- a/schema.json
+++ b/schema.json
@@ -4,17 +4,18 @@
  "description": "The `komorebi.json` static configuration file reference for `v0.1.25`",
  "type": "object",
  "properties": {
-    "app_specific_configuration_path": {
-      "description": "Path to applications.yaml from komorebi-application-specific-configurations (default: None)",
-      "type": "string"
-    },
-    "border": {
+    "active_window_border": {
      "description": "Display an active window border (default: false)",
      "type": "boolean"
    },
-    "border_colours": {
+    "active_window_border_colours": {
      "description": "Active window border colours for different container types",
      "type": "object",
+      "required": [
+        "monocle",
+        "single",
+        "stack"
+      ],
      "properties": {
        "monocle": {
          "description": "Border colour when the container is in monocle mode",
@@ -129,47 +130,39 @@
              "type": "string"
            }
          ]
-        },
-        "unfocused": {
-          "description": "Border colour when the container is unfocused",
-          "anyOf": [
-            {
-              "description": "Colour represented as RGB",
-              "type": "object",
-              "required": [
-                "b",
-                "g",
-                "r"
-              ],
-              "properties": {
-                "b": {
-                  "description": "Blue",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                },
-                "g": {
-                  "description": "Green",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                },
-                "r": {
-                  "description": "Red",
-                  "type": "integer",
-                  "format": "uint32",
-                  "minimum": 0.0
-                }
-              }
-            },
-            {
-              "description": "Colour represented as Hex",
-              "type": "string"
-            }
-          ]
        }
      }
    },
+    "active_window_border_style": {
+      "description": "Active window border style (default: System)",
+      "oneOf": [
+        {
+          "description": "Use the system border style",
+          "type": "string",
+          "enum": [
+            "System"
+          ]
+        },
+        {
+          "description": "Use the Windows 11-style rounded borders",
+          "type": "string",
+          "enum": [
+            "Rounded"
+          ]
+        },
+        {
+          "description": "Use the Windows 10-style square borders",
+          "type": "string",
+          "enum": [
+            "Square"
+          ]
+        }
+      ]
+    },
+    "app_specific_configuration_path": {
+      "description": "Path to applications.yaml from komorebi-application-specific-configurations (default: None)",
+      "type": "string"
+    },
    "border_offset": {
      "description": "Offset of the window border (default: -1)",
      "type": "integer",
@@ -258,47 +251,11 @@
        ]
      }
    },
-    "border_style": {
-      "description": "Active window border style (default: System)",
-      "oneOf": [
-        {
-          "description": "Use the system border style",
-          "type": "string",
-          "enum": [
-            "System"
-          ]
-        },
-        {
-          "description": "Use the Windows 11-style rounded borders",
-          "type": "string",
-          "enum": [
-            "Rounded"
-          ]
-        },
-        {
-          "description": "Use the Windows 10-style square borders",
-          "type": "string",
-          "enum": [
-            "Square"
-          ]
-        }
-      ]
-    },
    "border_width": {
      "description": "Width of the window border (default: 8)",
      "type": "integer",
      "format": "int32"
    },
-    "border_z_order": {
-      "description": "Active window border z-order (default: System)",
-      "type": "string",
-      "enum": [
-        "Top",
-        "NoTopMost",
-        "Bottom",
-        "TopMost"
-      ]
-    },
    "cross_monitor_move_behaviour": {
      "description": "Determine what happens when a window is moved across a monitor boundary (default: Swap)",
      "oneOf": [
@@ -315,13 +272,6 @@
          "enum": [
            "Insert"
          ]
-        },
-        {
-          "description": "Do nothing if trying to move a window container in the direction of an adjacent monitor",
-          "type": "string",
-          "enum": [
-            "NoOp"
-          ]
        }
      ]
    },
@@ -718,43 +668,6 @@
          "workspaces"
        ],
        "properties": {
-          "window_based_work_area_offset": {
-            "description": "Window based work area offset (default: None)",
-            "type": "object",
-            "required": [
-              "bottom",
-              "left",
-              "right",
-              "top"
-            ],
-            "properties": {
-              "bottom": {
-                "description": "The bottom point in a Win32 Rect",
-                "type": "integer",
-                "format": "int32"
-              },
-              "left": {
-                "description": "The left point in a Win32 Rect",
-                "type": "integer",
-                "format": "int32"
-              },
-              "right": {
-                "description": "The right point in a Win32 Rect",
-                "type": "integer",
-                "format": "int32"
-              },
-              "top": {
-                "description": "The top point in a Win32 Rect",
-                "type": "integer",
-                "format": "int32"
-              }
-            }
-          },
-          "window_based_work_area_offset_limit": {
-            "description": "Open window limit after which the window based work area offset will no longer be applied (default: 1)",
-            "type": "integer",
-            "format": "int"
-          },
          "work_area_offset": {
            "description": "Monitor-specific work area offset (default: None)",
            "type": "object",