fix(wm): ensure await-configuration is opt-in

chore(release): v0.1.11
fix(wm): enforce active border enabled checks
2026-01-19 14:26:58 +01:00 · 2022-08-11 20:02:45 -07:00 · 2022-08-11 13:35:47 -07:00 · 2022-08-11 10:50:44 -07:00 · 2022-08-11 08:37:19 -07:00 · 2022-08-11 06:53:35 -07:00
29 changed files with 1692 additions and 593 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: LGUG2Z
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: "[BUG]: Short descriptive title"
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See bug
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots and Videos**
+Add screenshots and videos to help explain your problem.
+
+**Operating System**
+Provide the output of `systeminfo | grep "^OS Name\|^OS Version"`
+
+For example:
+```
+OS Name:                   Microsoft Windows 11 Pro
+OS Version:                10.0.22000 N/A Build 22000
+```
+
+**Additional context**
+Add any other context about the problem here.
+
+In particular, if you have any other AHK scripts or software running that handle any aspect of window management or manipulation
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: "[FEAT]: Short descriptive title"
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
--- a/.github/workflows/windows.yaml
+++ b/.github/workflows/windows.yaml
@@ -93,7 +93,7 @@ jobs:
          if ! type kokai >/dev/null; then cargo install --locked kokai --force; fi
          kokai release --no-emoji --add-links github:commits,issues --ref "$(git tag --points-at HEAD)" >"CHANGELOG.md"
      - name: Run GoReleaser
-        uses: goreleaser/goreleaser-action@v2
+        uses: goreleaser/goreleaser-action@v3
        if: startsWith(github.ref, 'refs/tags/')
        with:
          version: latest
--- a/.goreleaser.yml
+++ b/.goreleaser.yml
@@ -16,7 +16,7 @@ builds:
    hooks:
      post:
        - mkdir -p dist/windows_amd64
-        - cp ".\target\x86_64-pc-windows-msvc\release\komorebi.exe" ".\dist\komorebi_windows_amd64\komorebi.exe"
+        - cp ".\target\x86_64-pc-windows-msvc\release\komorebi.exe" ".\dist\komorebi_windows_amd64_v1\komorebi.exe"
  - id: komorebic
    main: dummy.go
    goos: ["windows"]
@@ -25,7 +25,7 @@ builds:
    hooks:
      post:
        - mkdir -p dist/windows_amd64
-        - cp ".\target\x86_64-pc-windows-msvc\release\komorebic.exe" ".\dist\komorebic_windows_amd64\komorebic.exe"
+        - cp ".\target\x86_64-pc-windows-msvc\release\komorebic.exe" ".\dist\komorebic_windows_amd64_v1\komorebic.exe"

 archives:
  - replacements:
@@ -42,19 +42,4 @@ checksum:
  name_template: checksums.txt

 changelog:
-  sort: asc
-
-scoop:
-  bucket:
-    owner: LGUG2Z
-    name: komorebi-bucket
-    token: "{{ .Env.SCOOP_TOKEN }}"
-  homepage: https://github.com/LGUG2Z/komorebi
-  description: A tiling window manager for Windows
-  license: MIT
-  pre_install:
-    - if (Get-Process -Name komorebi -ErrorAction SilentlyContinue) { komorebic stop }
-  post_install:
-    - Write-Host "`nRun 'cp $original_dir\komorebi.sample.ahk $Env:UserProfile\komorebi.ahk' to get started with the sample configuration"
-    - Write-Host "`nRun 'komorebic ahk-library' if you would like to generate an AHK helper library to use in your configuration"
-    - Write-Host "`nOnce you have a configuration file in place, you can run 'komorebic start' to start the window manager"
+  sort: asc
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,5 +4,5 @@ members = [
    "derive-ahk",
    "komorebi",
    "komorebi-core",
-    "komorebic"
+    "komorebic",
 ]
--- a/README.md
+++ b/README.md
@@ -2,7 +2,14 @@

 Tiling Window Management for Windows.

-![screenshot](https://i.ibb.co/BTqNS45/komorebi.png)
+![GitHub Workflow Status (branch)](https://img.shields.io/github/workflow/status/LGUG2Z/komorebi/Windows/master)
+![GitHub](https://img.shields.io/github/license/LGUG2Z/komorebi)
+![GitHub all releases](https://img.shields.io/github/downloads/LGUG2Z/komorebi/total)
+![GitHub commits since latest release (by date) for a branch](https://img.shields.io/github/commits-since/LGUG2Z/komorebi/latest/master)
+![Discord](https://img.shields.io/discord/898554690126630914?label=discord)
+![GitHub Sponsors](https://img.shields.io/github/sponsors/LGUG2Z)
+
+![screenshot](https://user-images.githubusercontent.com/13164844/184027064-f5a6cec2-2865-4d65-a549-a1f1da589abf.png)

 ## About

@@ -27,6 +34,18 @@ Articles, blog posts, demos, and videos about _komorebi_ can be added to this li
 - [Moving to Windows from Linux Pt 1](https://kvwu.io/posts/moving-to-windows/)
 - [Windows 下的现代化平铺窗口管理器 komorebi](https://zhuanlan.zhihu.com/p/455064481)

+## GitHub Sponsors Early Access
+
+[GitHub Sponsors is enabled for this project](https://github.com/sponsors/LGUG2Z). Users who sponsor my work
+on `komorebi` at any of the predefined monthly tiers will be given access to a private fork of this repository where I
+push features-in-progress that are not yet quite ready to be pushed on the main repository.
+
+There will never be any feature of `komorebi` that is gated behind sponsorship; every new feature will always be
+available for free in the public repository once it meets the requisite level of code quality and completion.
+
+Features-in-progress that are available in early access will be tagged in the issues with
+an ["early access" label](https://github.com/LGUG2Z/komorebi/issues?q=is%3Aopen+is%3Aissue+label%3A%22early+access%22).
+
 ## Demonstrations

 [@haxibami](https://github.com/haxibami) showing _komorebi_ running on Windows
@@ -155,6 +174,26 @@ the `AutoHotKey64.exe` executable for AutoHotKey v2 is in your `Path`. If both `
 exist in your home directory, only `komorebi.ahk` will be loaded. An example of an AutoHotKey v2 configuration file
 for _komorebi_ can be found [here](https://gist.github.com/crosstyan/dafacc0778dabf693ce9236c57b201cd).

+#### Using Different AHK Executables
+
+The preferred way to install AutoHotKey for use with `komorebi` is to install it via `scoop`:
+
+```powershell
+scoop install autohotkey
+```
+
+If you install AutoHotKey using a different method, the name of the executable file may differ from the name given by
+`scoop`, and thus what is expected by default in `komorebi`.
+
+You may override the executables that `komorebi` looks for to launch and reload `komorebi.ahk` configuration files using
+by setting one of the following two environment variables depending on which version of AutoHotKey you wish to use:
+
+- `$Env:KOMOREBI_AHK_V1_EXE`
+- `$Env:KOMOREBI_AHK_V2_EXE`
+
+Please keep in mind that even when setting a custom executable name using these environment variables, the executables
+are still required to be in your `Path`.
+
 ### Common First-Time Tips

 #### Generating Common Application-Specific Configurations
@@ -219,6 +258,39 @@ If you already have configuration files that you wish to keep, move them to the
 The next time you run `komorebic start`, any files created by or loaded by _komorebi_ will be placed or expected to
 exist in this folder.

+#### Adding an Active Window Border
+
+If you would like to add a visual border around the currently focused window, two commands are available:
+
+```powershell
+komorebic.exe active-window-border [enable|disable]
+komorebic.exe active-window-border-colour [R G B]
+```
+
+It is important to note that the active window border will only apply to windows managed by `komorebi`.
+
+#### Removing Gaps
+
+If you would like to remove all gaps from a given workspace, both between windows themselves, and between the monitor edges and the windows, you can set the following two configuration options to `0` for the desired monitors and workspaces:
+
+```powershell
+komorebic.exe container-padding <MONITOR_INDEX> <WORKSPACE_INDEX> 0
+komorebic.exe workspace padding <MONITOR_INDEX> <WORKSPACE_INDEX> 0
+```
+
+#### Multiple Layout Changes on Startup
+
+Depending on what is in your configuration, when `komorebi` is started, you may experience the layout rapidly being adjusted
+with many retile events.
+
+If you would like to avoid this, you can start `komorebi` with a flag which tells `komorebi` to wait until all configuration
+has been loaded before listening to and responding to window manager events: `komorebic start --await-configuration`.
+
+If you start `komorebi` with the `--await-configuration` flag, you _must_ send the `komorebic complete-configuration`
+command at the end of the configuration section of your `komorebi.ahk` config (before you start defining the key
+bindings). The layout will not be updated and `komorebi` will not respond to `komorebic` commands until this command has
+been received.
+
 #### Floating Windows

 Sometimes you will want a specific application to never be tiled, and instead float all the time. You add add rules to
@@ -366,11 +438,9 @@ YAML

 ```yaml
 - column: Secondary
-  configuration:
-    Horizontal: 2 # max number of rows,
+  configuration: !Horizontal 2 # max number of rows
 - column: Primary
-  configuration:
-    WidthPercentage: 45 # percentage of screen
+  configuration: !WidthPercentage 50 # percentage of screen
 - column: Tertiary
  configuration: Horizontal
 ```
@@ -474,7 +544,10 @@ manage                                     Force komorebi to manage the focused
 unmanage                                   Unmanage a window that was forcibly managed
 reload-configuration                       Reload ~/komorebi.ahk (if it exists)
 watch-configuration                        Enable or disable watching of ~/komorebi.ahk (if it exists)
+complete-configuration                     Signal that the final configuration option has been sent
 window-hiding-behaviour                    Set the window behaviour when switching workspaces / cycling stacks
+cross-monitor-move-behaviour               Set the behaviour when moving windows across monitor boundaries
+toggle-cross-monitor-move-behaviour        Toggle the behaviour when moving windows across monitor boundaries
 unmanaged-window-operation-behaviour       Set the operation behaviour when the focused window is not managed
 float-rule                                 Add a rule to always float the specified application
 manage-rule                                Add a rule to always manage the specified application
@@ -483,6 +556,8 @@ identify-object-name-change-application    Identify an application that sends EV
 identify-tray-application                  Identify an application that closes to the system tray
 identify-layered-application               Identify an application that has WS_EX_LAYERED, but should still be managed
 identify-border-overflow-application       Identify an application that has overflowing borders
+active-window-border                       Enable or disable the active window border
+active-window-border-colour                Set the colour for the active window border
 focus-follows-mouse                        Enable or disable focus follows mouse for the operating system
 toggle-focus-follows-mouse                 Toggle focus follows mouse for the operating system
 mouse-follows-focus                        Enable or disable mouse follows focus on all workspaces
@@ -511,7 +586,9 @@ used [is available here](komorebi.sample.with.lib.ahk).
 - [x] Window stacks
 - [x] Cycle through stacked windows
 - [x] Change focused window by direction
+- [x] Change focused window by direction across monitor boundary
 - [x] Move focused window container in direction
+- [x] Move focused window container in direction across monitor boundary
 - [x] Move focused window container to monitor and follow
 - [x] Move focused window container to workspace follow
 - [x] Send focused window container to monitor
@@ -584,14 +661,14 @@ the IDE for completions and navigation:

 ## Logs and Debugging

-Logs from `komorebi` will be appended to `~/komorebi.log`; this file is never rotated or overwritten, so it will keep
+Logs from `komorebi` will be appended to `%LOCALAPPDATA%/komorebi/komorebi.log`; this file is never rotated or overwritten, so it will keep
 growing until it is deleted by the user.

 Whenever running the `komorebic stop` command or sending a Ctrl-C signal to `komorebi` directly, the `komorebi` process
 ensures that all hidden windows are restored before termination.

 If however, you ever end up with windows that are hidden and cannot be restored, a list of window handles known
-to `komorebi` are stored and continuously updated in `~/komorebi.hwnd.json`.
+to `komorebi` are stored and continuously updated in `%LOCALAPPDATA%/komorebi//komorebi.hwnd.json`.

 ### Restoring Windows

--- a/2
+++ b/2
@@ -6,7 +6,7 @@ clean:

 fmt:
    cargo +nightly fmt
-    cargo +nightly clippy
+    cargo +stable clippy
    prettier --write README.md

 install-komorebic:
--- a/komorebi-core/Cargo.toml
+++ b/komorebi-core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-core"
-version = "0.1.8"
+version = "0.1.12"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -10,12 +10,12 @@ clap = { version = "3", features = ["derive"] }
 color-eyre = "0.6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-serde_yaml = "0.8"
+serde_yaml = "0.9"
 strum = { version = "0.24", features = ["derive"] }
 schemars = "0.8"

 [dependencies.windows]
-version = "0.35"
+version = "0.39"
 features = [
    "Win32_Foundation",
 ]
--- a/komorebi-core/src/lib.rs
+++ b/komorebi-core/src/lib.rs
@@ -57,6 +57,8 @@ pub enum SocketMessage {
    ToggleMaximize,
    ToggleWindowContainerBehaviour,
    WindowHidingBehaviour(HidingBehaviour),
+    ToggleCrossMonitorMoveBehaviour,
+    CrossMonitorMoveBehaviour(MoveBehaviour),
    UnmanagedWindowOperationBehaviour(OperationBehaviour),
    // Current Workspace Commands
    ManageFocusedWindow,
@@ -94,6 +96,9 @@ pub enum SocketMessage {
    // Configuration
    ReloadConfiguration,
    WatchConfiguration(bool),
+    CompleteConfiguration,
+    ActiveWindowBorder(bool),
+    ActiveWindowBorderColour(u32, u32, u32),
    InvisibleBorders(Rect),
    WorkAreaOffset(Rect),
    ResizeDelta(i32),
@@ -129,7 +134,7 @@ impl FromStr for SocketMessage {
    }
 }

-#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 pub enum StateQuery {
    FocusedMonitorIndex,
@@ -138,7 +143,7 @@ pub enum StateQuery {
    FocusedWindowIndex,
 }

-#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 #[serde(rename_all = "snake_case")]
 pub enum ApplicationIdentifier {
@@ -147,7 +152,7 @@ pub enum ApplicationIdentifier {
    Title,
 }

-#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 pub enum FocusFollowsMouseImplementation {
    Komorebi,
@@ -161,7 +166,14 @@ pub enum WindowContainerBehaviour {
    Append,
 }

-#[derive(Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
+#[strum(serialize_all = "snake_case")]
+pub enum MoveBehaviour {
+    Swap,
+    Insert,
+}
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ArgEnum, JsonSchema)]
 #[strum(serialize_all = "snake_case")]
 pub enum HidingBehaviour {
    Hide,
--- a/komorebi/Cargo.toml
+++ b/komorebi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.8"
+version = "0.1.12"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "A tiling window manager for Windows"
 categories = ["tiling-window-manager", "windows"]
@@ -23,33 +23,38 @@ dirs = "4"
 getset = "0.1"
 hotwatch = "0.4"
 lazy_static = "1"
+miow = "0.4"
 nanoid = "0.4"
+os_info = "3.4"
 parking_lot = { version = "0.12", features = ["deadlock_detection"] }
 paste = "1"
+schemars = "0.8"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 strum = { version = "0.24", features = ["derive"] }
-sysinfo = "0.23"
+sysinfo = "0.25"
 tracing = "0.1"
 tracing-appender = "0.2"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 uds_windows = "1"
 which = "4"
 winput = "0.2"
-miow = "0.4"
 winreg = "0.10"
-schemars = "0.8"

 [dependencies.windows]
-version = "0.35"
+version = "0.39"
 features = [
    "Win32_Foundation",
    "Win32_Graphics_Dwm",
    "Win32_Graphics_Gdi",
-    "Win32_System_Threading",
+    "Win32_System_LibraryLoader",
    "Win32_System_RemoteDesktop",
-    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_System_Threading",
    "Win32_UI_Accessibility",
+    "Win32_UI_HiDpi",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_Shell",
+    "Win32_UI_Shell_Common",
    "Win32_UI_WindowsAndMessaging"
 ]

--- a/komorebi/src/border.rs
+++ b/komorebi/src/border.rs
@@ -0,0 +1,119 @@
+use std::sync::atomic::Ordering;
+use std::time::Duration;
+
+use color_eyre::Result;
+use komorebi_core::Rect;
+use windows::core::PCSTR;
+use windows::Win32::Foundation::HWND;
+use windows::Win32::UI::WindowsAndMessaging::DispatchMessageA;
+use windows::Win32::UI::WindowsAndMessaging::FindWindowA;
+use windows::Win32::UI::WindowsAndMessaging::GetMessageA;
+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::WNDCLASSA;
+
+use crate::window::Window;
+use crate::windows_callbacks;
+use crate::WindowsApi;
+use crate::BORDER_HWND;
+use crate::BORDER_OVERFLOW_IDENTIFIERS;
+use crate::WINDOWS_11;
+
+#[derive(Debug, Clone, Copy)]
+pub struct Border {
+    pub(crate) hwnd: isize,
+}
+
+impl From<isize> for Border {
+    fn from(hwnd: isize) -> Self {
+        Self { hwnd }
+    }
+}
+
+impl Border {
+    pub const fn hwnd(self) -> HWND {
+        HWND(self.hwnd)
+    }
+
+    pub fn create(name: &str) -> Result<()> {
+        let name = format!("{name}\0");
+        let instance = WindowsApi::module_handle_w()?;
+        let class_name = PCSTR(name.as_ptr());
+        let brush = WindowsApi::create_solid_brush(255, 140, 0);
+        let window_class = WNDCLASSA {
+            hInstance: instance,
+            lpszClassName: class_name,
+            style: CS_HREDRAW | CS_VREDRAW,
+            lpfnWndProc: Some(windows_callbacks::border_window),
+            hbrBackground: brush,
+            ..Default::default()
+        };
+
+        let _atom = WindowsApi::register_class_a(&window_class)?;
+
+        let name_cl = name.clone();
+        std::thread::spawn(move || -> Result<()> {
+            let hwnd = WindowsApi::create_border_window(PCSTR(name_cl.as_ptr()), instance)?;
+            let border = Self::from(hwnd);
+
+            let mut message = MSG::default();
+
+            unsafe {
+                while GetMessageA(&mut message, border.hwnd(), 0, 0).into() {
+                    DispatchMessageA(&message);
+                    std::thread::sleep(Duration::from_millis(10));
+                }
+            }
+
+            Ok(())
+        });
+
+        let mut hwnd = HWND(0);
+        while hwnd == HWND(0) {
+            hwnd = unsafe { FindWindowA(PCSTR(name.as_ptr()), PCSTR::null()) };
+        }
+
+        BORDER_HWND.store(hwnd.0, Ordering::SeqCst);
+
+        if *WINDOWS_11 {
+            WindowsApi::round_corners(hwnd.0)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn hide(self) -> Result<()> {
+        WindowsApi::hide_border_window(self.hwnd())
+    }
+
+    pub fn set_position(
+        self,
+        window: Window,
+        invisible_borders: &Rect,
+        activate: bool,
+    ) -> Result<()> {
+        let mut should_expand_border = false;
+
+        let mut rect = WindowsApi::window_rect(window.hwnd())?;
+        rect.top -= invisible_borders.bottom;
+        rect.bottom += invisible_borders.bottom;
+
+        let border_overflows = BORDER_OVERFLOW_IDENTIFIERS.lock();
+        if border_overflows.contains(&window.title()?)
+            || border_overflows.contains(&window.exe()?)
+            || border_overflows.contains(&window.class()?)
+        {
+            should_expand_border = true;
+        }
+
+        if should_expand_border {
+            rect.left -= invisible_borders.left;
+            rect.top -= invisible_borders.top;
+            rect.right += invisible_borders.right;
+            rect.bottom += invisible_borders.bottom;
+        }
+
+        WindowsApi::position_border_window(self.hwnd(), &rect, activate)
+    }
+}
--- a/komorebi/src/main.rs
+++ b/komorebi/src/main.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::all, clippy::nursery, clippy::pedantic)]
-#![allow(clippy::missing_errors_doc)]
+#![allow(clippy::missing_errors_doc, clippy::redundant_pub_crate)]

 use std::collections::HashMap;
 use std::fs::File;
@@ -7,12 +7,11 @@ use std::io::Write;
 use std::path::PathBuf;
 use std::process::Command;
 use std::sync::atomic::AtomicBool;
+use std::sync::atomic::AtomicIsize;
 use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 #[cfg(feature = "deadlock_detection")]
-use std::thread;
-#[cfg(feature = "deadlock_detection")]
 use std::time::Duration;

 use clap::Parser;
@@ -20,7 +19,9 @@ use color_eyre::eyre::anyhow;
 use color_eyre::Result;
 use crossbeam_channel::Receiver;
 use crossbeam_channel::Sender;
+use crossbeam_utils::Backoff;
 use lazy_static::lazy_static;
+use os_info::Version;
 #[cfg(feature = "deadlock_detection")]
 use parking_lot::deadlock;
 use parking_lot::Mutex;
@@ -39,6 +40,7 @@ use winreg::RegKey;
 use komorebi_core::HidingBehaviour;
 use komorebi_core::SocketMessage;

+use crate::border::Border;
 use crate::process_command::listen_for_commands;
 use crate::process_event::listen_for_events;
 use crate::process_movement::listen_for_movements;
@@ -50,6 +52,7 @@ use crate::windows_api::WindowsApi;
 #[macro_use]
 mod ring;

+mod border;
 mod container;
 mod monitor;
 mod process_command;
@@ -118,10 +121,44 @@ lazy_static! {
            dirs::home_dir().expect("there is no home directory")
        }
    };
+    static ref DATA_DIR: PathBuf = dirs::data_local_dir().expect("there is no local data directory").join("komorebi");
+    static ref AHK_V1_EXE: String = {
+        let mut ahk_v1: String = String::from("autohotkey.exe");
+
+        if let Ok(komorebi_ahk_v1_exe) = std::env::var("KOMOREBI_AHK_V1_EXE") {
+            if which(&komorebi_ahk_v1_exe).is_ok() {
+                ahk_v1 = komorebi_ahk_v1_exe;
+            }
+        }
+
+        ahk_v1
+    };
+    static ref AHK_V2_EXE: String = {
+        let mut ahk_v2: String = String::from("AutoHotkey64.exe");
+
+        if let Ok(komorebi_ahk_v2_exe) = std::env::var("KOMOREBI_AHK_V2_EXE") {
+            if which(&komorebi_ahk_v2_exe).is_ok() {
+                ahk_v2 = komorebi_ahk_v2_exe;
+            }
+        }
+
+        ahk_v2
+    };
+
+    static ref WINDOWS_11: bool = {
+        matches!(
+            os_info::get().version(),
+            Version::Semantic(_, _, x) if x >= &22000
+        )
+    };
 }

+pub static INITIAL_CONFIGURATION_LOADED: AtomicBool = AtomicBool::new(false);
 pub static CUSTOM_FFM: AtomicBool = AtomicBool::new(false);
 pub static SESSION_ID: AtomicU32 = AtomicU32::new(0);
+pub static BORDER_ENABLED: AtomicBool = AtomicBool::new(false);
+pub static BORDER_HWND: AtomicIsize = AtomicIsize::new(0);
+pub static BORDER_HIDDEN: AtomicBool = AtomicBool::new(false);

 fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
    if std::env::var("RUST_LIB_BACKTRACE").is_err() {
@@ -134,8 +171,7 @@ fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
        std::env::set_var("RUST_LOG", "info");
    }

-    let home = HOME_DIR.clone();
-    let appender = tracing_appender::rolling::never(home, "komorebi.log");
+    let appender = tracing_appender::rolling::never(DATA_DIR.clone(), "komorebi.log");
    let color_appender = tracing_appender::rolling::never(std::env::temp_dir(), "komorebi.log");
    let (non_blocking, guard) = tracing_appender::non_blocking(appender);
    let (color_non_blocking, color_guard) = tracing_appender::non_blocking(color_appender);
@@ -196,7 +232,7 @@ pub fn load_configuration() -> Result<()> {
    let mut config_v2 = home;
    config_v2.push("komorebi.ahk2");

-    if config_v1.exists() && which("autohotkey.exe").is_ok() {
+    if config_v1.exists() && which(&*AHK_V1_EXE).is_ok() {
        tracing::info!(
            "loading configuration file: {}",
            config_v1
@@ -208,7 +244,7 @@ pub fn load_configuration() -> Result<()> {
        Command::new("autohotkey.exe")
            .arg(config_v1.as_os_str())
            .output()?;
-    } else if config_v2.exists() && which("AutoHotkey64.exe").is_ok() {
+    } else if config_v2.exists() && which(&*AHK_V2_EXE).is_ok() {
        tracing::info!(
            "loading configuration file: {}",
            config_v2
@@ -220,7 +256,7 @@ pub fn load_configuration() -> Result<()> {
        Command::new("AutoHotkey64.exe")
            .arg(config_v2.as_os_str())
            .output()?;
-    };
+    }

    Ok(())
 }
@@ -319,9 +355,9 @@ pub fn notify_subscribers(notification: &str) -> Result<()> {
 #[tracing::instrument]
 fn detect_deadlocks() {
    // Create a background thread which checks for deadlocks every 10s
-    thread::spawn(move || loop {
+    std::thread::spawn(move || loop {
        tracing::info!("running deadlock detector");
-        thread::sleep(Duration::from_secs(5));
+        std::thread::sleep(Duration::from_secs(5));
        let deadlocks = deadlock::check_deadlock();
        if deadlocks.is_empty() {
            continue;
@@ -342,8 +378,11 @@ fn detect_deadlocks() {
 #[clap(author, about, version)]
 struct Opts {
    /// Allow the use of komorebi's custom focus-follows-mouse implementation
-    #[clap(long = "ffm")]
+    #[clap(action, short, long = "ffm")]
    focus_follows_mouse: bool,
+    /// Wait for 'komorebic complete-configuration' to be sent before processing events
+    #[clap(action, short, long)]
+    await_configuration: bool,
 }

 #[tracing::instrument]
@@ -352,7 +391,9 @@ fn main() -> Result<()> {
    CUSTOM_FFM.store(opts.focus_follows_mouse, Ordering::SeqCst);

    let arg_count = std::env::args().count();
-    let has_valid_args = arg_count == 1 || (arg_count == 2 && CUSTOM_FFM.load(Ordering::SeqCst));
+    let has_valid_args = arg_count == 1
+        || (arg_count == 2 && (opts.await_configuration || opts.focus_follows_mouse))
+        || (arg_count == 3 && opts.await_configuration && opts.focus_follows_mouse);

    if has_valid_args {
        let session_id = WindowsApi::process_id_to_session_id()?;
@@ -364,14 +405,14 @@ fn main() -> Result<()> {
        let matched_procs: Vec<&Process> = system.processes_by_name("komorebi.exe").collect();

        if matched_procs.len() > 1 {
-            let mut shim_is_active = false;
+            let mut len = matched_procs.len();
            for proc in matched_procs {
                if proc.root().ends_with("shims") {
-                    shim_is_active = true;
+                    len -= 1;
                }
            }

-            if !shim_is_active {
+            if len > 1 {
                tracing::error!("komorebi.exe is already running, please exit the existing process before starting a new one");
                std::process::exit(1);
            }
@@ -385,6 +426,8 @@ fn main() -> Result<()> {

        let process_id = WindowsApi::current_process_id();
        WindowsApi::allow_set_foreground_window(process_id)?;
+        WindowsApi::set_process_dpi_awareness_context()?;
+        Border::create("komorebi-border-window")?;

        let (outgoing, incoming): (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) =
            crossbeam_channel::unbounded();
@@ -398,14 +441,28 @@ fn main() -> Result<()> {

        wm.lock().init()?;
        listen_for_commands(wm.clone());
+
+        if !opts.await_configuration && !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
+            INITIAL_CONFIGURATION_LOADED.store(true, Ordering::SeqCst);
+        };
+
+        std::thread::spawn(|| {
+            load_configuration().expect("could not load configuration");
+        });
+
+        if opts.await_configuration {
+            let backoff = Backoff::new();
+            while !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
+                backoff.snooze();
+            }
+        }
+
        listen_for_events(wm.clone());

        if CUSTOM_FFM.load(Ordering::SeqCst) {
            listen_for_movements(wm.clone());
        }

-        load_configuration()?;
-
        let (ctrlc_sender, ctrlc_receiver) = crossbeam_channel::bounded(1);
        ctrlc::set_handler(move || {
            ctrlc_sender
--- a/komorebi/src/process_command.rs
+++ b/komorebi/src/process_command.rs
@@ -7,7 +7,6 @@ use std::num::NonZeroUsize;
 use std::str::FromStr;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::thread;

 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -20,6 +19,7 @@ use komorebi_core::ApplicationIdentifier;
 use komorebi_core::Axis;
 use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::Layout;
+use komorebi_core::MoveBehaviour;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
 use komorebi_core::Sizing;
@@ -27,18 +27,23 @@ use komorebi_core::SocketMessage;
 use komorebi_core::StateQuery;
 use komorebi_core::WindowContainerBehaviour;

+use crate::border::Border;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
+use crate::window::Window;
 use crate::window_manager;
 use crate::window_manager::WindowManager;
 use crate::windows_api::WindowsApi;
 use crate::Notification;
 use crate::NotificationEvent;
+use crate::BORDER_ENABLED;
+use crate::BORDER_HWND;
 use crate::BORDER_OVERFLOW_IDENTIFIERS;
 use crate::CUSTOM_FFM;
 use crate::FLOAT_IDENTIFIERS;
 use crate::HIDING_BEHAVIOUR;
 use crate::HOME_DIR;
+use crate::INITIAL_CONFIGURATION_LOADED;
 use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
 use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
@@ -54,7 +59,7 @@ pub fn listen_for_commands(wm: Arc<Mutex<WindowManager>>) {
        .try_clone()
        .expect("could not clone unix listener");

-    thread::spawn(move || {
+    std::thread::spawn(move || {
        tracing::info!("listening");
        for client in listener.incoming() {
            match client {
@@ -86,6 +91,20 @@ impl WindowManager {
            }
        }

+        match message {
+            SocketMessage::CycleFocusMonitor(_)
+            | SocketMessage::CycleFocusWorkspace(_)
+            | SocketMessage::FocusMonitorNumber(_)
+            | SocketMessage::FocusMonitorWorkspaceNumber(_, _)
+            | SocketMessage::FocusWorkspaceNumber(_) => {
+                if self.focused_workspace()?.visible_windows().is_empty() {
+                    let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+                    border.hide()?;
+                }
+            }
+            _ => {}
+        };
+
        match message {
            SocketMessage::Promote => self.promote_container_to_front()?,
            SocketMessage::FocusWindow(direction) => {
@@ -114,24 +133,24 @@ impl WindowManager {
            SocketMessage::WorkspacePadding(monitor_idx, workspace_idx, size) => {
                self.set_workspace_padding(monitor_idx, workspace_idx, size)?;
            }
-            SocketMessage::WorkspaceRule(_, id, monitor_idx, workspace_idx) => {
+            SocketMessage::WorkspaceRule(_, ref id, monitor_idx, workspace_idx) => {
                {
                    let mut workspace_rules = WORKSPACE_RULES.lock();
-                    workspace_rules.insert(id, (monitor_idx, workspace_idx));
+                    workspace_rules.insert(id.to_string(), (monitor_idx, workspace_idx));
                }

                self.enforce_workspace_rules()?;
            }
-            SocketMessage::ManageRule(_, id) => {
+            SocketMessage::ManageRule(_, ref id) => {
                let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
-                if !manage_identifiers.contains(&id) {
-                    manage_identifiers.push(id);
+                if !manage_identifiers.contains(id) {
+                    manage_identifiers.push(id.to_string());
                }
            }
-            SocketMessage::FloatRule(identifier, id) => {
+            SocketMessage::FloatRule(identifier, ref id) => {
                let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
-                if !float_identifiers.contains(&id) {
-                    float_identifiers.push(id.clone());
+                if !float_identifiers.contains(id) {
+                    float_identifiers.push(id.to_string());
                }

                let invisible_borders = self.invisible_borders;
@@ -148,17 +167,17 @@ impl WindowManager {
                        for window in container.windows().iter() {
                            match identifier {
                                ApplicationIdentifier::Exe => {
-                                    if window.exe()? == id {
+                                    if window.exe()? == *id {
                                        hwnds_to_purge.push((i, window.hwnd));
                                    }
                                }
                                ApplicationIdentifier::Class => {
-                                    if window.class()? == id {
+                                    if window.class()? == *id {
                                        hwnds_to_purge.push((i, window.hwnd));
                                    }
                                }
                                ApplicationIdentifier::Title => {
-                                    if window.title()? == id {
+                                    if window.title()? == *id {
                                        hwnds_to_purge.push((i, window.hwnd));
                                    }
                                }
@@ -235,9 +254,11 @@ impl WindowManager {
            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::ChangeLayoutCustom(path) => self.change_workspace_custom_layout(path)?,
-            SocketMessage::WorkspaceLayoutCustom(monitor_idx, workspace_idx, path) => {
-                self.set_workspace_layout_custom(monitor_idx, workspace_idx, path)?;
+            SocketMessage::ChangeLayoutCustom(ref path) => {
+                self.change_workspace_custom_layout(path.clone())?;
+            }
+            SocketMessage::WorkspaceLayoutCustom(monitor_idx, workspace_idx, ref path) => {
+                self.set_workspace_layout_custom(monitor_idx, workspace_idx, path.clone())?;
            }
            SocketMessage::WorkspaceTiling(monitor_idx, workspace_idx, tile) => {
                self.set_workspace_tiling(monitor_idx, workspace_idx, tile)?;
@@ -262,13 +283,13 @@ impl WindowManager {
                monitor_idx,
                workspace_idx,
                at_container_count,
-                path,
+                ref path,
            ) => {
                self.add_workspace_layout_custom_rule(
                    monitor_idx,
                    workspace_idx,
                    at_container_count,
-                    path,
+                    path.clone(),
                )?;
            }
            SocketMessage::ClearWorkspaceLayoutRules(monitor_idx, workspace_idx) => {
@@ -332,8 +353,8 @@ impl WindowManager {
            SocketMessage::NewWorkspace => {
                self.new_workspace()?;
            }
-            SocketMessage::WorkspaceName(monitor_idx, workspace_idx, name) => {
-                self.set_workspace_name(monitor_idx, workspace_idx, name)?;
+            SocketMessage::WorkspaceName(monitor_idx, workspace_idx, ref name) => {
+                self.set_workspace_name(monitor_idx, workspace_idx, name.to_string())?;
            }
            SocketMessage::State => {
                let state = match serde_json::to_string_pretty(&window_manager::State::from(&*self))
@@ -378,15 +399,40 @@ impl WindowManager {
            SocketMessage::ResizeWindowAxis(axis, sizing) => {
                // If the user has a custom layout, allow for the resizing of the primary column
                // with this signal
-                if let Layout::Custom(ref mut custom) = self.focused_workspace_mut()?.layout_mut() {
+                let workspace = self.focused_workspace_mut()?;
+                let container_len = workspace.containers().len();
+                let no_layout_rules = workspace.layout_rules().is_empty();
+
+                if let Layout::Custom(ref mut custom) = workspace.layout_mut() {
                    if matches!(axis, Axis::Horizontal) {
                        let percentage = custom
                            .primary_width_percentage()
                            .unwrap_or(100 / custom.len());

-                        match sizing {
-                            Sizing::Increase => custom.set_primary_width_percentage(percentage + 5),
-                            Sizing::Decrease => custom.set_primary_width_percentage(percentage - 5),
+                        if no_layout_rules {
+                            match sizing {
+                                Sizing::Increase => {
+                                    custom.set_primary_width_percentage(percentage + 5);
+                                }
+                                Sizing::Decrease => {
+                                    custom.set_primary_width_percentage(percentage - 5);
+                                }
+                            }
+                        } else {
+                            for rule in workspace.layout_rules_mut() {
+                                if container_len >= rule.0 {
+                                    if let Layout::Custom(ref mut custom) = rule.1 {
+                                        match sizing {
+                                            Sizing::Increase => {
+                                                custom.set_primary_width_percentage(percentage + 5);
+                                            }
+                                            Sizing::Decrease => {
+                                                custom.set_primary_width_percentage(percentage - 5);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
                        }
                    }
                // Otherwise proceed with the resizing logic for individual window containers in the
@@ -548,31 +594,37 @@ impl WindowManager {
            SocketMessage::ReloadConfiguration => {
                Self::reload_configuration();
            }
+            SocketMessage::CompleteConfiguration => {
+                if !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
+                    INITIAL_CONFIGURATION_LOADED.store(true, Ordering::SeqCst);
+                    self.update_focused_workspace(false)?;
+                }
+            }
            SocketMessage::WatchConfiguration(enable) => {
                self.watch_configuration(enable)?;
            }
-            SocketMessage::IdentifyBorderOverflowApplication(_, id) => {
+            SocketMessage::IdentifyBorderOverflowApplication(_, ref id) => {
                let mut identifiers = BORDER_OVERFLOW_IDENTIFIERS.lock();
-                if !identifiers.contains(&id) {
-                    identifiers.push(id);
+                if !identifiers.contains(id) {
+                    identifiers.push(id.to_string());
                }
            }
-            SocketMessage::IdentifyObjectNameChangeApplication(_, id) => {
+            SocketMessage::IdentifyObjectNameChangeApplication(_, ref id) => {
                let mut identifiers = OBJECT_NAME_CHANGE_ON_LAUNCH.lock();
-                if !identifiers.contains(&id) {
-                    identifiers.push(id);
+                if !identifiers.contains(id) {
+                    identifiers.push(id.to_string());
                }
            }
-            SocketMessage::IdentifyTrayApplication(_, id) => {
+            SocketMessage::IdentifyTrayApplication(_, ref id) => {
                let mut identifiers = TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
-                if !identifiers.contains(&id) {
-                    identifiers.push(id);
+                if !identifiers.contains(id) {
+                    identifiers.push(id.to_string());
                }
            }
-            SocketMessage::IdentifyLayeredApplication(_, id) => {
+            SocketMessage::IdentifyLayeredApplication(_, ref id) => {
                let mut identifiers = LAYERED_WHITELIST.lock();
-                if !identifiers.contains(&id) {
-                    identifiers.push(id);
+                if !identifiers.contains(id) {
+                    identifiers.push(id.to_string());
                }
            }
            SocketMessage::ManageFocusedWindow => {
@@ -622,7 +674,7 @@ impl WindowManager {
                workspace.set_resize_dimensions(resize);
                self.update_focused_workspace(false)?;
            }
-            SocketMessage::Save(path) => {
+            SocketMessage::Save(ref path) => {
                let workspace = self.focused_workspace_mut()?;
                let resize = workspace.resize_dimensions();

@@ -630,14 +682,14 @@ impl WindowManager {
                    .write(true)
                    .truncate(true)
                    .create(true)
-                    .open(path)?;
+                    .open(path.clone())?;

                serde_json::to_writer_pretty(&file, &resize)?;
            }
-            SocketMessage::Load(path) => {
+            SocketMessage::Load(ref path) => {
                let workspace = self.focused_workspace_mut()?;

-                let file = File::open(&path)
+                let file = File::open(path)
                    .map_err(|_| anyhow!("no file found at {}", path.display().to_string()))?;

                let resize: Vec<Option<Rect>> = serde_json::from_reader(file)?;
@@ -645,18 +697,18 @@ impl WindowManager {
                workspace.set_resize_dimensions(resize);
                self.update_focused_workspace(false)?;
            }
-            SocketMessage::AddSubscriber(subscriber) => {
+            SocketMessage::AddSubscriber(ref subscriber) => {
                let mut pipes = SUBSCRIPTION_PIPES.lock();
                let pipe_path = format!(r"\\.\pipe\{}", subscriber);
                let pipe = connect(&pipe_path).map_err(|_| {
                    anyhow!("the named pipe '{}' has not yet been created; please create it before running this command", pipe_path)
                })?;

-                pipes.insert(subscriber, pipe);
+                pipes.insert(subscriber.clone(), pipe);
            }
-            SocketMessage::RemoveSubscriber(subscriber) => {
+            SocketMessage::RemoveSubscriber(ref subscriber) => {
                let mut pipes = SUBSCRIPTION_PIPES.lock();
-                pipes.remove(&subscriber);
+                pipes.remove(subscriber);
            }
            SocketMessage::MouseFollowsFocus(enable) => {
                self.mouse_follows_focus = enable;
@@ -681,9 +733,35 @@ impl WindowManager {
                let mut hiding_behaviour = HIDING_BEHAVIOUR.lock();
                *hiding_behaviour = behaviour;
            }
+            SocketMessage::ToggleCrossMonitorMoveBehaviour => {
+                match self.cross_monitor_move_behaviour {
+                    MoveBehaviour::Swap => {
+                        self.cross_monitor_move_behaviour = MoveBehaviour::Insert;
+                    }
+                    MoveBehaviour::Insert => {
+                        self.cross_monitor_move_behaviour = MoveBehaviour::Swap;
+                    }
+                }
+            }
+            SocketMessage::CrossMonitorMoveBehaviour(behaviour) => {
+                self.cross_monitor_move_behaviour = behaviour;
+            }
            SocketMessage::UnmanagedWindowOperationBehaviour(behaviour) => {
                self.unmanaged_window_operation_behaviour = behaviour;
            }
+            SocketMessage::ActiveWindowBorder(enable) => {
+                if enable {
+                    BORDER_ENABLED.store(true, Ordering::SeqCst);
+                    self.show_border()?;
+                } else {
+                    BORDER_ENABLED.store(false, Ordering::SeqCst);
+                    self.hide_border()?;
+                }
+            }
+            SocketMessage::ActiveWindowBorderColour(r, g, b) => {
+                let hwnd = BORDER_HWND.load(Ordering::SeqCst);
+                WindowsApi::change_border_colour(hwnd, r, g, b)?;
+            }
            SocketMessage::NotificationSchema => {
                let notification = schema_for!(Notification);
                let schema = serde_json::to_string_pretty(&notification)?;
@@ -696,6 +774,58 @@ impl WindowManager {
            }
        };

+        match message {
+            SocketMessage::ChangeLayout(_)
+            | SocketMessage::ChangeLayoutCustom(_)
+            | SocketMessage::FlipLayout(_)
+            | SocketMessage::ManageFocusedWindow
+            | SocketMessage::MoveWorkspaceToMonitorNumber(_)
+            | SocketMessage::MoveContainerToMonitorNumber(_)
+            | SocketMessage::MoveContainerToWorkspaceNumber(_)
+            | SocketMessage::ResizeWindowEdge(_, _)
+            | SocketMessage::ResizeWindowAxis(_, _)
+            | SocketMessage::ToggleFloat
+            | SocketMessage::ToggleMonocle
+            | SocketMessage::ToggleMaximize
+            | SocketMessage::Promote
+            | SocketMessage::Retile
+            | SocketMessage::MoveWindow(_) => {
+                let foreground = WindowsApi::foreground_window()?;
+                let foreground_window = Window { hwnd: foreground };
+                let mut rect = WindowsApi::window_rect(foreground_window.hwnd())?;
+                rect.top -= self.invisible_borders.bottom;
+                rect.bottom += self.invisible_borders.bottom;
+
+                let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+                border.set_position(foreground_window, &self.invisible_borders, false)?;
+            }
+            SocketMessage::TogglePause => {
+                let is_paused = self.is_paused;
+                let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+
+                if is_paused {
+                    border.hide()?;
+                } else {
+                    let focused = self.focused_window()?;
+                    border.set_position(*focused, &self.invisible_borders, true)?;
+                    focused.focus(false)?;
+                }
+            }
+            SocketMessage::ToggleTiling | SocketMessage::WorkspaceTiling(..) => {
+                let tiling_enabled = *self.focused_workspace_mut()?.tile();
+                let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+
+                if tiling_enabled {
+                    let focused = self.focused_window()?;
+                    border.set_position(*focused, &self.invisible_borders, true)?;
+                    focused.focus(false)?;
+                } else {
+                    border.hide()?;
+                }
+            }
+            _ => {}
+        };
+
        tracing::info!("processed");
        Ok(())
    }
--- a/komorebi/src/process_event.rs
+++ b/komorebi/src/process_event.rs
@@ -1,6 +1,6 @@
 use std::fs::OpenOptions;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::thread;

 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -12,6 +12,7 @@ use komorebi_core::Rect;
 use komorebi_core::Sizing;
 use komorebi_core::WindowContainerBehaviour;

+use crate::border::Border;
 use crate::current_virtual_desktop;
 use crate::notify_subscribers;
 use crate::window_manager::WindowManager;
@@ -19,15 +20,18 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::Notification;
 use crate::NotificationEvent;
+use crate::BORDER_ENABLED;
+use crate::BORDER_HIDDEN;
+use crate::BORDER_HWND;
+use crate::DATA_DIR;
 use crate::HIDDEN_HWNDS;
-use crate::HOME_DIR;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;

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

-    thread::spawn(move || {
+    std::thread::spawn(move || {
        tracing::info!("listening");
        loop {
            select! {
@@ -288,6 +292,7 @@ impl WindowManager {
                    .ok_or_else(|| anyhow!("cannot get monitor idx from current position"))?;

                let new_window_behaviour = self.window_container_behaviour;
+                let invisible_borders = self.invisible_borders;

                let workspace = self.focused_workspace_mut()?;
                if workspace
@@ -340,7 +345,10 @@ impl WindowManager {

                // If we have moved across the monitors, use that override, otherwise determine
                // if a move has taken place by ruling out a resize
-                let is_move = moved_across_monitors || resize.right == 0 && resize.bottom == 0;
+                let is_move = moved_across_monitors
+                    || resize.right == 0 && resize.bottom == 0
+                    || resize.right.abs() == invisible_borders.right
+                        && resize.bottom.abs() == invisible_borders.bottom;

                if is_move {
                    tracing::info!("moving with mouse");
@@ -466,11 +474,46 @@ impl WindowManager {
            WindowManagerEvent::MonitorPoll(..) | WindowManagerEvent::MouseCapture(..) => {}
        };

+        if *self.focused_workspace()?.tile() && BORDER_ENABLED.load(Ordering::SeqCst) {
+            match event {
+                WindowManagerEvent::MoveResizeStart(_, _) => {
+                    let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+                    border.hide()?;
+                    BORDER_HIDDEN.store(true, Ordering::SeqCst);
+                }
+                WindowManagerEvent::MoveResizeEnd(_, _)
+                | WindowManagerEvent::Show(_, _)
+                | WindowManagerEvent::FocusChange(_, _) => {
+                    let window = self.focused_window()?;
+                    let mut rect = WindowsApi::window_rect(window.hwnd())?;
+                    rect.top -= self.invisible_borders.bottom;
+                    rect.bottom += self.invisible_borders.bottom;
+
+                    let activate = BORDER_HIDDEN.load(Ordering::SeqCst);
+
+                    let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+                    border.set_position(*window, &self.invisible_borders, activate)?;
+
+                    if activate {
+                        BORDER_HIDDEN.store(false, Ordering::SeqCst);
+                    }
+                }
+                _ => {}
+            }
+        }
+
        // If we unmanaged a window, it shouldn't be immediately hidden behind managed windows
        if let WindowManagerEvent::Unmanage(window) = event {
            window.center(&self.focused_monitor_work_area()?, &invisible_borders)?;
        }

+        // If there are no more windows on the workspace, we shouldn't show the border window
+        if self.focused_workspace()?.containers().is_empty() {
+            let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+            border.hide()?;
+            BORDER_HIDDEN.store(true, Ordering::SeqCst);
+        }
+
        tracing::trace!("updating list of known hwnds");
        let mut known_hwnds = vec![];
        for monitor in self.monitors() {
@@ -483,8 +526,7 @@ impl WindowManager {
            }
        }

-        let mut hwnd_json = HOME_DIR.clone();
-        hwnd_json.push("komorebi.hwnd.json");
+        let hwnd_json = DATA_DIR.join("komorebi.hwnd.json");
        let file = OpenOptions::new()
            .write(true)
            .truncate(true)
--- a/komorebi/src/process_movement.rs
+++ b/komorebi/src/process_movement.rs
@@ -17,7 +17,7 @@ pub fn listen_for_movements(wm: Arc<Mutex<WindowManager>>) {
        let receiver = message_loop::start().expect("could not start winput message loop");

        loop {
-            let focus_follows_mouse = wm.lock().focus_follows_mouse.clone();
+            let focus_follows_mouse = wm.lock().focus_follows_mouse;
            if let Some(FocusFollowsMouseImplementation::Komorebi) = focus_follows_mouse {
                match receiver.next_event() {
                    // Don't want to send any raise events while we are dragging or resizing
--- a/komorebi/src/window.rs
+++ b/komorebi/src/window.rs
@@ -1,6 +1,7 @@
 use std::convert::TryFrom;
 use std::fmt::Display;
 use std::fmt::Formatter;
+use std::fmt::Write as _;

 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -11,6 +12,7 @@ use serde::Serialize;
 use serde::Serializer;
 use windows::Win32::Foundation::HWND;

+use komorebi_core::ApplicationIdentifier;
 use komorebi_core::HidingBehaviour;
 use komorebi_core::Rect;

@@ -36,18 +38,18 @@ impl Display for Window {
        let mut display = format!("(hwnd: {}", self.hwnd);

        if let Ok(title) = self.title() {
-            display.push_str(&format!(", title: {}", title));
+            write!(display, ", title: {}", title)?;
        }

        if let Ok(exe) = self.exe() {
-            display.push_str(&format!(", exe: {}", exe));
+            write!(display, ", exe: {}", exe)?;
        }

        if let Ok(class) = self.class() {
-            display.push_str(&format!(", class: {}", class));
+            write!(display, ", class: {}", class)?;
        }

-        display.push(')');
+        write!(display, ")")?;

        write!(f, "{}", display)
    }
@@ -173,6 +175,18 @@ impl Window {
        WindowsApi::maximize_window(self.hwnd());
    }

+    pub fn unmaximize(self) {
+        let mut programmatically_hidden_hwnds = HIDDEN_HWNDS.lock();
+        if let Some(idx) = programmatically_hidden_hwnds
+            .iter()
+            .position(|&hwnd| hwnd == self.hwnd)
+        {
+            programmatically_hidden_hwnds.remove(idx);
+        }
+
+        WindowsApi::unmaximize_window(self.hwnd());
+    }
+
    pub fn raise(self) -> Result<()> {
        // Attach komorebi thread to Window thread
        let (_, window_thread_id) = WindowsApi::window_thread_process_id(self.hwnd());
@@ -198,7 +212,19 @@ impl Window {
        // Attach komorebi thread to Window thread
        let (_, window_thread_id) = WindowsApi::window_thread_process_id(self.hwnd());
        let current_thread_id = WindowsApi::current_thread_id();
-        WindowsApi::attach_thread_input(current_thread_id, window_thread_id, true)?;
+
+        // This can be allowed to fail if a window doesn't have a message queue or if a journal record
+        // hook has been installed
+        // https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-attachthreadinput#remarks
+        match WindowsApi::attach_thread_input(current_thread_id, window_thread_id, true) {
+            Ok(()) => {}
+            Err(error) => {
+                tracing::error!(
+                    "could not attach to window thread input processing mechanism, but continuing execution of focus(): {}",
+                    error
+                );
+            }
+        };

        // Raise Window to foreground
        match WindowsApi::set_foreground_window(self.hwnd()) {
@@ -217,7 +243,17 @@ impl Window {
        }

        // This isn't really needed when the above command works as expected via AHK
-        WindowsApi::set_focus(self.hwnd())
+        match WindowsApi::set_focus(self.hwnd()) {
+            Ok(_) => {}
+            Err(error) => {
+                tracing::error!(
+                    "could not set focus, but continuing execution of focus(): {}",
+                    error
+                );
+            }
+        };
+
+        Ok(())
    }

    #[allow(dead_code)]
@@ -280,46 +316,7 @@ impl Window {
            // If not allowing cloaked windows, we need to ensure the window is not cloaked
            (false, false) => {
                if let (Ok(title), Ok(exe_name), Ok(class)) = (self.title(), self.exe(), self.class()) {
-                    {
-                        let float_identifiers = FLOAT_IDENTIFIERS.lock();
-                        if float_identifiers.contains(&title)
-                            || float_identifiers.contains(&exe_name)
-                            || float_identifiers.contains(&class) {
-                            return Ok(false);
-                        }
-                    }
-
-                    let managed_override = {
-                        let manage_identifiers = MANAGE_IDENTIFIERS.lock();
-                        manage_identifiers.contains(&exe_name) || manage_identifiers.contains(&class)
-                    };
-
-                    let allow_layered = {
-                        let layered_whitelist = LAYERED_WHITELIST.lock();
-                        layered_whitelist.contains(&exe_name) || layered_whitelist.contains(&class)
-                    };
-
-                    let allow_wsl2_gui = {
-                        let wsl2_ui_processes = WSL2_UI_PROCESSES.lock();
-                        wsl2_ui_processes.contains(&exe_name)
-                    };
-
-                    let style = self.style()?;
-                    let ex_style = self.ex_style()?;
-
-                    if (allow_wsl2_gui || style.contains(WindowStyle::CAPTION) && ex_style.contains(ExtendedWindowStyle::WINDOWEDGE))
-                        && !ex_style.contains(ExtendedWindowStyle::DLGMODALFRAME)
-                        // Get a lot of dupe events coming through that make the redrawing go crazy
-                        // on FocusChange events if I don't filter out this one. But, if we are
-                        // allowing a specific layered window on the whitelist (like Steam), it should
-                        // pass this check
-                        && (allow_layered || !ex_style.contains(ExtendedWindowStyle::LAYERED))
-                        || managed_override
-                    {
-                        return Ok(true);
-                    } else if event.is_some() {
-                        tracing::debug!("ignoring (exe: {}, title: {})", exe_name, title);
-                    }
+                    return Ok(window_is_eligible(&title, &exe_name, &class, self.style()?, self.ex_style()?, event));
                }
            }
            _ => {}
@@ -328,3 +325,83 @@ impl Window {
        Ok(false)
    }
 }
+
+fn window_is_eligible(
+    title: &String,
+    exe_name: &String,
+    class: &String,
+    style: WindowStyle,
+    ex_style: ExtendedWindowStyle,
+    event: Option<WindowManagerEvent>,
+) -> bool {
+    let mut should_float = false;
+    let mut matched_identifier = None;
+
+    {
+        let float_identifiers = FLOAT_IDENTIFIERS.lock();
+        for identifier in float_identifiers.iter() {
+            if title.starts_with(identifier) || title.ends_with(identifier) {
+                should_float = true;
+                matched_identifier = Option::from(ApplicationIdentifier::Title);
+            }
+
+            if class.starts_with(identifier) || class.ends_with(identifier) {
+                should_float = true;
+                matched_identifier = Option::from(ApplicationIdentifier::Class);
+            }
+
+            if identifier == exe_name {
+                should_float = true;
+                matched_identifier = Option::from(ApplicationIdentifier::Exe);
+            }
+        }
+    };
+
+    let managed_override = {
+        let manage_identifiers = MANAGE_IDENTIFIERS.lock();
+        matched_identifier.map_or_else(
+            || {
+                manage_identifiers.contains(exe_name)
+                    || manage_identifiers.contains(class)
+                    || manage_identifiers.contains(title)
+            },
+            |matched_identifier| match matched_identifier {
+                ApplicationIdentifier::Exe => manage_identifiers.contains(exe_name),
+                ApplicationIdentifier::Class => manage_identifiers.contains(class),
+                ApplicationIdentifier::Title => manage_identifiers.contains(title),
+            },
+        )
+    };
+
+    if should_float && !managed_override {
+        return false;
+    }
+
+    let allow_layered = {
+        let layered_whitelist = LAYERED_WHITELIST.lock();
+        layered_whitelist.contains(exe_name)
+            || layered_whitelist.contains(class)
+            || layered_whitelist.contains(title)
+    };
+
+    let allow_wsl2_gui = {
+        let wsl2_ui_processes = WSL2_UI_PROCESSES.lock();
+        wsl2_ui_processes.contains(exe_name)
+    };
+
+    if (allow_wsl2_gui || style.contains(WindowStyle::CAPTION) && ex_style.contains(ExtendedWindowStyle::WINDOWEDGE))
+                        && !ex_style.contains(ExtendedWindowStyle::DLGMODALFRAME)
+                        // Get a lot of dupe events coming through that make the redrawing go crazy
+                        // on FocusChange events if I don't filter out this one. But, if we are
+                        // allowing a specific layered window on the whitelist (like Steam), it should
+                        // pass this check
+                        && (allow_layered || !ex_style.contains(ExtendedWindowStyle::LAYERED))
+        || managed_override
+    {
+        return true;
+    } else if event.is_some() {
+        tracing::debug!("ignoring (exe: {}, title: {})", exe_name, title);
+    }
+
+    false
+}
--- a/komorebi/src/window_manager.rs
+++ b/komorebi/src/window_manager.rs
@@ -2,8 +2,8 @@ use std::collections::VecDeque;
 use std::io::ErrorKind;
 use std::num::NonZeroUsize;
 use std::path::PathBuf;
+use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::thread;

 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -15,6 +15,7 @@ use schemars::JsonSchema;
 use serde::Serialize;
 use uds_windows::UnixListener;

+use crate::border::Border;
 use komorebi_core::custom_layout::CustomLayout;
 use komorebi_core::Arrangement;
 use komorebi_core::Axis;
@@ -22,6 +23,7 @@ use komorebi_core::CycleDirection;
 use komorebi_core::DefaultLayout;
 use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::Layout;
+use komorebi_core::MoveBehaviour;
 use komorebi_core::OperationBehaviour;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
@@ -38,7 +40,9 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent_listener::WINEVENT_CALLBACK_CHANNEL;
 use crate::workspace::Workspace;
+use crate::BORDER_HWND;
 use crate::BORDER_OVERFLOW_IDENTIFIERS;
+use crate::DATA_DIR;
 use crate::FLOAT_IDENTIFIERS;
 use crate::HOME_DIR;
 use crate::LAYERED_WHITELIST;
@@ -57,6 +61,7 @@ pub struct WindowManager {
    pub work_area_offset: Option<Rect>,
    pub resize_delta: i32,
    pub window_container_behaviour: WindowContainerBehaviour,
+    pub cross_monitor_move_behaviour: MoveBehaviour,
    pub unmanaged_window_operation_behaviour: OperationBehaviour,
    pub focus_follows_mouse: Option<FocusFollowsMouseImplementation>,
    pub mouse_follows_focus: bool,
@@ -73,6 +78,7 @@ pub struct State {
    pub invisible_borders: Rect,
    pub resize_delta: i32,
    pub new_window_behaviour: WindowContainerBehaviour,
+    pub cross_monitor_move_behaviour: MoveBehaviour,
    pub work_area_offset: Option<Rect>,
    pub focus_follows_mouse: Option<FocusFollowsMouseImplementation>,
    pub mouse_follows_focus: bool,
@@ -100,7 +106,8 @@ impl From<&WindowManager> for State {
            work_area_offset: wm.work_area_offset,
            resize_delta: wm.resize_delta,
            new_window_behaviour: wm.window_container_behaviour,
-            focus_follows_mouse: wm.focus_follows_mouse.clone(),
+            cross_monitor_move_behaviour: wm.cross_monitor_move_behaviour,
+            focus_follows_mouse: wm.focus_follows_mouse,
            mouse_follows_focus: wm.mouse_follows_focus,
            has_pending_raise_op: wm.has_pending_raise_op,
            float_identifiers: FLOAT_IDENTIFIERS.lock().clone(),
@@ -142,10 +149,7 @@ impl EnforceWorkspaceRuleOp {
 impl WindowManager {
    #[tracing::instrument]
    pub fn new(incoming: Arc<Mutex<Receiver<WindowManagerEvent>>>) -> Result<Self> {
-        let home = HOME_DIR.clone();
-        let mut socket = home;
-        socket.push("komorebi.sock");
-        let socket = socket.as_path();
+        let socket = DATA_DIR.join("komorebi.sock");

        match std::fs::remove_file(&socket) {
            Ok(_) => {}
@@ -174,6 +178,7 @@ impl WindowManager {
            virtual_desktop_id: current_virtual_desktop(),
            work_area_offset: None,
            window_container_behaviour: WindowContainerBehaviour::Create,
+            cross_monitor_move_behaviour: MoveBehaviour::Swap,
            unmanaged_window_operation_behaviour: OperationBehaviour::Op,
            resize_delta: 50,
            focus_follows_mouse: None,
@@ -188,14 +193,33 @@ impl WindowManager {
    pub fn init(&mut self) -> Result<()> {
        tracing::info!("initialising");
        WindowsApi::load_monitor_information(&mut self.monitors)?;
-        WindowsApi::load_workspace_information(&mut self.monitors)?;
-        self.update_focused_workspace(false)
+        WindowsApi::load_workspace_information(&mut self.monitors)
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn show_border(&self) -> Result<()> {
+        let foreground = WindowsApi::foreground_window()?;
+        let foreground_window = Window { hwnd: foreground };
+        let mut rect = WindowsApi::window_rect(foreground_window.hwnd())?;
+        rect.top -= self.invisible_borders.bottom;
+        rect.bottom += self.invisible_borders.bottom;
+
+        let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+        border.set_position(foreground_window, &self.invisible_borders, true)
+    }
+
+    #[tracing::instrument(skip(self))]
+    pub fn hide_border(&self) -> Result<()> {
+        let focused = self.focused_window()?;
+        let border = Border::from(BORDER_HWND.load(Ordering::SeqCst));
+        border.hide()?;
+        focused.focus(false)
    }

    #[tracing::instrument]
    pub fn reload_configuration() {
        tracing::info!("reloading configuration");
-        thread::spawn(|| load_configuration().expect("could not load configuration"));
+        std::thread::spawn(|| load_configuration().expect("could not load configuration"));
    }

    #[tracing::instrument(skip(self))]
@@ -244,7 +268,7 @@ impl WindowManager {
                    // Editing in Notepad sends a NoticeWrite while editing in (Neo)Vim sends
                    // a NoticeRemove, presumably because of the use of swap files?
                    DebouncedEvent::NoticeWrite(_) | DebouncedEvent::NoticeRemove(_) => {
-                        thread::spawn(|| {
+                        std::thread::spawn(|| {
                            load_configuration().expect("could not load configuration");
                        });
                    }
@@ -266,6 +290,39 @@ impl WindowManager {
        Ok(())
    }

+    pub fn monitor_idx_in_direction(&self, direction: OperationDirection) -> Option<usize> {
+        let current_monitor_size = self.focused_monitor_size().ok()?;
+
+        for (idx, monitor) in self.monitors.elements().iter().enumerate() {
+            match direction {
+                OperationDirection::Left => {
+                    if monitor.size().left + monitor.size().right == current_monitor_size.left {
+                        return Option::from(idx);
+                    }
+                }
+                OperationDirection::Right => {
+                    if current_monitor_size.right + current_monitor_size.left == monitor.size().left
+                    {
+                        return Option::from(idx);
+                    }
+                }
+                OperationDirection::Up => {
+                    if monitor.size().top + monitor.size().bottom == current_monitor_size.top {
+                        return Option::from(idx);
+                    }
+                }
+                OperationDirection::Down => {
+                    if current_monitor_size.top + current_monitor_size.bottom == monitor.size().top
+                    {
+                        return Option::from(idx);
+                    }
+                }
+            }
+        }
+
+        None
+    }
+
    #[tracing::instrument(skip(self))]
    pub fn reconcile_monitors(&mut self) -> Result<()> {
        let valid_hmonitors = WindowsApi::valid_hmonitors()?;
@@ -903,15 +960,33 @@ impl WindowManager {
    pub fn focus_container_in_direction(&mut self, direction: OperationDirection) -> Result<()> {
        self.handle_unmanaged_window_behaviour()?;

+        let workspace = self.focused_workspace()?;
+
+        if workspace.is_focused_window_monocle_or_maximized()? {
+            return Err(anyhow!(
+                "ignoring command while active window is in monocle mode or maximized"
+            ));
+        }
+
        tracing::info!("focusing container");

-        let workspace = self.focused_workspace_mut()?;
+        let new_idx = workspace.new_idx_for_direction(direction);

-        let new_idx = workspace
-            .new_idx_for_direction(direction)
-            .ok_or_else(|| anyhow!("this is not a valid direction from the current position"))?;
+        // if there is no container in that direction for this workspace
+        match new_idx {
+            None => {
+                let monitor_idx = self
+                    .monitor_idx_in_direction(direction)
+                    .ok_or_else(|| anyhow!("there is no container or monitor in this direction"))?;
+
+                self.focus_monitor(monitor_idx)?;
+            }
+            Some(idx) => {
+                let workspace = self.focused_workspace_mut()?;
+                workspace.focus_container(idx);
+            }
+        }

-        workspace.focus_container(new_idx);
        self.focused_window_mut()?.focus(self.mouse_follows_focus)?;

        Ok(())
@@ -921,17 +996,124 @@ impl WindowManager {
    pub fn move_container_in_direction(&mut self, direction: OperationDirection) -> Result<()> {
        self.handle_unmanaged_window_behaviour()?;

+        let workspace = self.focused_workspace()?;
+        if workspace.is_focused_window_monocle_or_maximized()? {
+            return Err(anyhow!(
+                "ignoring command while active window is in monocle mode or maximized"
+            ));
+        }
+
        tracing::info!("moving container");

-        let workspace = self.focused_workspace_mut()?;
+        let origin_container_idx = workspace.focused_container_idx();
+        let origin_monitor_idx = self.focused_monitor_idx();
+        let target_container_idx = workspace.new_idx_for_direction(direction);

-        let current_idx = workspace.focused_container_idx();
-        let new_idx = workspace
-            .new_idx_for_direction(direction)
-            .ok_or_else(|| anyhow!("this is not a valid direction from the current position"))?;
+        match target_container_idx {
+            // 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 => {
+                let target_monitor_idx = self
+                    .monitor_idx_in_direction(direction)
+                    .ok_or_else(|| anyhow!("there is no container or monitor in this direction"))?;
+
+                {
+                    // remove the container from the origin monitor workspace
+                    let origin_container = self
+                        .focused_workspace_mut()?
+                        .remove_container_by_idx(origin_container_idx)
+                        .ok_or_else(|| {
+                            anyhow!("could not remove container at given origin index")
+                        })?;
+
+                    // focus the target monitor
+                    self.focus_monitor(target_monitor_idx)?;
+
+                    // 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
+                    // at the position where the currently focused container on that workspace is
+                    target_workspace.insert_container_at_idx(
+                        target_workspace.focused_container_idx(),
+                        origin_container,
+                    );
+
+                    // if there is only one container on the target workspace after the insertion
+                    // it means that there won't be one swapped back, so we have to decrement the
+                    // focused position
+                    if target_workspace.containers().len() == 1 {
+                        let origin_workspace =
+                            self.focused_workspace_for_monitor_idx_mut(origin_monitor_idx)?;
+
+                        origin_workspace
+                            .focus_container(origin_workspace.focused_container_idx() - 1);
+                    }
+                }
+
+                // if our MoveBehaviour is Swap, let's try to send back the window container
+                // whose position which just took over
+                if matches!(self.cross_monitor_move_behaviour, MoveBehaviour::Swap) {
+                    {
+                        let target_workspace = self.focused_workspace_mut()?;
+
+                        // if the target workspace doesn't have more than one container, this means it
+                        // was previously empty, by only doing the second part of the swap when there is
+                        // more than one container, we can fall back to a "move" if there is nothing to
+                        // swap with on the target monitor
+                        if target_workspace.containers().len() > 1 {
+                            // remove the container from the target monitor workspace
+                            let target_container = target_workspace
+                                // this is now focused_container_idx + 1 because we have inserted our origin container
+                                .remove_container_by_idx(
+                                    target_workspace.focused_container_idx() + 1,
+                                )
+                                .ok_or_else(|| {
+                                    anyhow!("could not remove container at given target index")
+                                })?;
+
+                            let origin_workspace =
+                                self.focused_workspace_for_monitor_idx_mut(origin_monitor_idx)?;
+
+                            // insert the container from the target monitor workspace into the origin monitor workspace
+                            // at the same position from which our origin container was removed
+                            origin_workspace
+                                .insert_container_at_idx(origin_container_idx, target_container);
+                        }
+                    }
+                }
+
+                // make sure to update the origin monitor workspace layout because it is no
+                // longer focused so it won't get updated at the end of this fn
+                let offset = self.work_area_offset;
+                let invisible_borders = self.invisible_borders;
+
+                self.monitors_mut()
+                    .get_mut(origin_monitor_idx)
+                    .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+                    .update_focused_workspace(offset, &invisible_borders)?;
+
+                let a = self
+                    .focused_monitor()
+                    .ok_or_else(|| anyhow!("there is no monitor focused monitor"))?
+                    .id();
+                let b = self
+                    .monitors_mut()
+                    .get_mut(origin_monitor_idx)
+                    .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+                    .id();
+
+                if !WindowsApi::monitors_have_same_scale_factor(a, b)? {
+                    self.update_focused_workspace(self.mouse_follows_focus)?;
+                }
+            }
+            Some(new_idx) => {
+                let workspace = self.focused_workspace_mut()?;
+                workspace.swap_containers(origin_container_idx, new_idx);
+                workspace.focus_container(new_idx);
+            }
+        }

-        workspace.swap_containers(current_idx, new_idx);
-        workspace.focus_container(new_idx);
        self.update_focused_workspace(self.mouse_follows_focus)
    }

@@ -976,9 +1158,14 @@ impl WindowManager {
    pub fn move_container_in_cycle_direction(&mut self, direction: CycleDirection) -> Result<()> {
        self.handle_unmanaged_window_behaviour()?;

-        tracing::info!("moving container");
-
        let workspace = self.focused_workspace_mut()?;
+        if workspace.is_focused_window_monocle_or_maximized()? {
+            return Err(anyhow!(
+                "ignoring command while active window is in monocle mode or maximized"
+            ));
+        }
+
+        tracing::info!("moving container");

        let current_idx = workspace.focused_container_idx();
        let new_idx = workspace
@@ -1288,6 +1475,7 @@ impl WindowManager {
        }

        workspace.set_layout(Layout::Custom(layout));
+        workspace.set_layout_flip(None);
        self.update_focused_workspace(self.mouse_follows_focus)
    }

@@ -1528,6 +1716,7 @@ impl WindowManager {
            .ok_or_else(|| anyhow!("there is no monitor"))?;

        workspace.set_layout(Layout::Custom(layout));
+        workspace.set_layout_flip(None);

        // 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 {
@@ -1629,6 +1818,13 @@ impl WindowManager {
        self.update_focused_workspace(false)
    }

+    pub fn focused_monitor_size(&self) -> Result<Rect> {
+        Ok(*self
+            .focused_monitor()
+            .ok_or_else(|| anyhow!("there is no monitor"))?
+            .size())
+    }
+
    pub fn focused_monitor_work_area(&self) -> Result<Rect> {
        Ok(*self
            .focused_monitor()
@@ -1661,7 +1857,7 @@ impl WindowManager {
        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() {
@@ -1687,6 +1883,22 @@ impl WindowManager {
            .ok_or_else(|| anyhow!("there is no workspace"))
    }

+    pub fn focused_workspace_for_monitor_idx(&self, idx: usize) -> Result<&Workspace> {
+        self.monitors()
+            .get(idx)
+            .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+            .focused_workspace()
+            .ok_or_else(|| anyhow!("there is no workspace"))
+    }
+
+    pub fn focused_workspace_for_monitor_idx_mut(&mut self, idx: usize) -> Result<&mut Workspace> {
+        self.monitors_mut()
+            .get_mut(idx)
+            .ok_or_else(|| anyhow!("there is no monitor at this index"))?
+            .focused_workspace_mut()
+            .ok_or_else(|| anyhow!("there is no workspace"))
+    }
+
    #[tracing::instrument(skip(self))]
    pub fn focus_workspace(&mut self, idx: usize) -> Result<()> {
        tracing::info!("focusing workspace");
@@ -1699,7 +1911,7 @@ impl WindowManager {
        monitor.focus_workspace(idx)?;
        monitor.load_focused_workspace(mouse_follows_focus)?;

-        self.update_focused_workspace(mouse_follows_focus)
+        self.update_focused_workspace(false)
    }

    #[tracing::instrument(skip(self))]
--- a/komorebi/src/window_manager_event.rs
+++ b/komorebi/src/window_manager_event.rs
@@ -28,56 +28,56 @@ pub enum WindowManagerEvent {
 impl Display for WindowManagerEvent {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
-            WindowManagerEvent::Manage(window) => {
+            Self::Manage(window) => {
                write!(f, "Manage (Window: {})", window)
            }
-            WindowManagerEvent::Unmanage(window) => {
+            Self::Unmanage(window) => {
                write!(f, "Unmanage (Window: {})", window)
            }
-            WindowManagerEvent::Destroy(winevent, window) => {
+            Self::Destroy(winevent, window) => {
                write!(f, "Destroy (WinEvent: {}, Window: {})", winevent, window)
            }
-            WindowManagerEvent::FocusChange(winevent, window) => {
+            Self::FocusChange(winevent, window) => {
                write!(
                    f,
                    "FocusChange (WinEvent: {}, Window: {})",
                    winevent, window
                )
            }
-            WindowManagerEvent::Hide(winevent, window) => {
+            Self::Hide(winevent, window) => {
                write!(f, "Hide (WinEvent: {}, Window: {})", winevent, window)
            }
-            WindowManagerEvent::Minimize(winevent, window) => {
+            Self::Minimize(winevent, window) => {
                write!(f, "Minimize (WinEvent: {}, Window: {})", winevent, window)
            }
-            WindowManagerEvent::Show(winevent, window) => {
+            Self::Show(winevent, window) => {
                write!(f, "Show (WinEvent: {}, Window: {})", winevent, window)
            }
-            WindowManagerEvent::MoveResizeStart(winevent, window) => {
+            Self::MoveResizeStart(winevent, window) => {
                write!(
                    f,
                    "MoveResizeStart (WinEvent: {}, Window: {})",
                    winevent, window
                )
            }
-            WindowManagerEvent::MoveResizeEnd(winevent, window) => {
+            Self::MoveResizeEnd(winevent, window) => {
                write!(
                    f,
                    "MoveResizeEnd (WinEvent: {}, Window: {})",
                    winevent, window
                )
            }
-            WindowManagerEvent::MouseCapture(winevent, window) => {
+            Self::MouseCapture(winevent, window) => {
                write!(
                    f,
                    "MouseCapture (WinEvent: {}, Window: {})",
                    winevent, window
                )
            }
-            WindowManagerEvent::Raise(window) => {
+            Self::Raise(window) => {
                write!(f, "Raise (Window: {})", window)
            }
-            WindowManagerEvent::MonitorPoll(winevent, window) => {
+            Self::MonitorPoll(winevent, window) => {
                write!(
                    f,
                    "MonitorPoll (WinEvent: {}, Window: {})",
@@ -91,18 +91,18 @@ impl Display for WindowManagerEvent {
 impl WindowManagerEvent {
    pub const fn window(self) -> Window {
        match self {
-            WindowManagerEvent::Destroy(_, window)
-            | WindowManagerEvent::FocusChange(_, window)
-            | WindowManagerEvent::Hide(_, window)
-            | WindowManagerEvent::Minimize(_, window)
-            | WindowManagerEvent::Show(_, window)
-            | WindowManagerEvent::MoveResizeStart(_, window)
-            | WindowManagerEvent::MoveResizeEnd(_, window)
-            | WindowManagerEvent::MouseCapture(_, window)
-            | WindowManagerEvent::MonitorPoll(_, window)
-            | WindowManagerEvent::Raise(window)
-            | WindowManagerEvent::Manage(window)
-            | WindowManagerEvent::Unmanage(window) => window,
+            Self::Destroy(_, window)
+            | Self::FocusChange(_, window)
+            | Self::Hide(_, window)
+            | Self::Minimize(_, window)
+            | Self::Show(_, window)
+            | Self::MoveResizeStart(_, window)
+            | Self::MoveResizeEnd(_, window)
+            | Self::MouseCapture(_, window)
+            | Self::MonitorPoll(_, window)
+            | Self::Raise(window)
+            | Self::Manage(window)
+            | Self::Unmanage(window) => window,
        }
    }

--- a/komorebi/src/windows_api.rs
+++ b/komorebi/src/windows_api.rs
@@ -6,29 +6,37 @@ use color_eyre::eyre::anyhow;
 use color_eyre::eyre::Error;
 use color_eyre::Result;
 use windows::core::Result as WindowsCrateResult;
+use windows::core::PCSTR;
 use windows::core::PWSTR;
 use windows::Win32::Foundation::BOOL;
 use windows::Win32::Foundation::HANDLE;
+use windows::Win32::Foundation::HINSTANCE;
 use windows::Win32::Foundation::HWND;
 use windows::Win32::Foundation::LPARAM;
 use windows::Win32::Foundation::POINT;
 use windows::Win32::Foundation::RECT;
 use windows::Win32::Graphics::Dwm::DwmGetWindowAttribute;
+use windows::Win32::Graphics::Dwm::DwmSetWindowAttribute;
 use windows::Win32::Graphics::Dwm::DWMWA_CLOAKED;
 use windows::Win32::Graphics::Dwm::DWMWA_EXTENDED_FRAME_BOUNDS;
+use windows::Win32::Graphics::Dwm::DWMWA_WINDOW_CORNER_PREFERENCE;
+use windows::Win32::Graphics::Dwm::DWMWCP_ROUND;
 use windows::Win32::Graphics::Dwm::DWMWINDOWATTRIBUTE;
 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::EnumDisplayMonitors;
 use windows::Win32::Graphics::Gdi::GetMonitorInfoW;
 use windows::Win32::Graphics::Gdi::MonitorFromPoint;
 use windows::Win32::Graphics::Gdi::MonitorFromWindow;
+use windows::Win32::Graphics::Gdi::HBRUSH;
 use windows::Win32::Graphics::Gdi::HDC;
 use windows::Win32::Graphics::Gdi::HMONITOR;
 use windows::Win32::Graphics::Gdi::MONITORENUMPROC;
 use windows::Win32::Graphics::Gdi::MONITORINFO;
 use windows::Win32::Graphics::Gdi::MONITOR_DEFAULTTONEAREST;
+use windows::Win32::System::LibraryLoader::GetModuleHandleW;
 use windows::Win32::System::RemoteDesktop::ProcessIdToSessionId;
 use windows::Win32::System::Threading::AttachThreadInput;
 use windows::Win32::System::Threading::GetCurrentProcessId;
@@ -38,8 +46,13 @@ use windows::Win32::System::Threading::QueryFullProcessImageNameW;
 use windows::Win32::System::Threading::PROCESS_ACCESS_RIGHTS;
 use windows::Win32::System::Threading::PROCESS_NAME_WIN32;
 use windows::Win32::System::Threading::PROCESS_QUERY_INFORMATION;
+use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
+use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
 use windows::Win32::UI::Input::KeyboardAndMouse::SetFocus;
+use windows::Win32::UI::Shell::Common::DEVICE_SCALE_FACTOR;
+use windows::Win32::UI::Shell::GetScaleFactorForMonitor;
 use windows::Win32::UI::WindowsAndMessaging::AllowSetForegroundWindow;
+use windows::Win32::UI::WindowsAndMessaging::CreateWindowExA;
 use windows::Win32::UI::WindowsAndMessaging::EnumWindows;
 use windows::Win32::UI::WindowsAndMessaging::GetCursorPos;
 use windows::Win32::UI::WindowsAndMessaging::GetDesktopWindow;
@@ -54,6 +67,8 @@ use windows::Win32::UI::WindowsAndMessaging::IsIconic;
 use windows::Win32::UI::WindowsAndMessaging::IsWindow;
 use windows::Win32::UI::WindowsAndMessaging::IsWindowVisible;
 use windows::Win32::UI::WindowsAndMessaging::RealGetWindowClassW;
+use windows::Win32::UI::WindowsAndMessaging::RegisterClassA;
+use windows::Win32::UI::WindowsAndMessaging::SetClassLongPtrW;
 use windows::Win32::UI::WindowsAndMessaging::SetCursorPos;
 use windows::Win32::UI::WindowsAndMessaging::SetForegroundWindow;
 use windows::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW;
@@ -61,9 +76,12 @@ use windows::Win32::UI::WindowsAndMessaging::SetWindowPos;
 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::GCLP_HBRBACKGROUND;
 use windows::Win32::UI::WindowsAndMessaging::GWL_EXSTYLE;
 use windows::Win32::UI::WindowsAndMessaging::GWL_STYLE;
 use windows::Win32::UI::WindowsAndMessaging::GW_HWNDNEXT;
+use windows::Win32::UI::WindowsAndMessaging::HWND_BOTTOM;
 use windows::Win32::UI::WindowsAndMessaging::HWND_NOTOPMOST;
 use windows::Win32::UI::WindowsAndMessaging::HWND_TOPMOST;
 use windows::Win32::UI::WindowsAndMessaging::SET_WINDOW_POS_FLAGS;
@@ -74,11 +92,18 @@ use windows::Win32::UI::WindowsAndMessaging::SPI_SETACTIVEWINDOWTRACKING;
 use windows::Win32::UI::WindowsAndMessaging::SW_HIDE;
 use windows::Win32::UI::WindowsAndMessaging::SW_MAXIMIZE;
 use windows::Win32::UI::WindowsAndMessaging::SW_MINIMIZE;
-use windows::Win32::UI::WindowsAndMessaging::SW_RESTORE;
+use windows::Win32::UI::WindowsAndMessaging::SW_NORMAL;
+use windows::Win32::UI::WindowsAndMessaging::SW_SHOWNOACTIVATE;
 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::WNDCLASSA;
 use windows::Win32::UI::WindowsAndMessaging::WNDENUMPROC;
+use windows::Win32::UI::WindowsAndMessaging::WS_EX_TOOLWINDOW;
+use windows::Win32::UI::WindowsAndMessaging::WS_MAXIMIZEBOX;
+use windows::Win32::UI::WindowsAndMessaging::WS_MINIMIZEBOX;
+use windows::Win32::UI::WindowsAndMessaging::WS_POPUP;
+use windows::Win32::UI::WindowsAndMessaging::WS_SYSMENU;

 use komorebi_core::Rect;

@@ -109,7 +134,7 @@ macro_rules! impl_from_integer_for_windows_result {
    };
 }

-impl_from_integer_for_windows_result!(isize, u32, i32);
+impl_from_integer_for_windows_result!(usize, isize, u16, u32, i32);

 impl<T, E> From<WindowsResult<T, E>> for Result<T, E> {
    fn from(result: WindowsResult<T, E>) -> Self {
@@ -130,7 +155,7 @@ macro_rules! impl_process_windows_crate_integer_wrapper_result {
            $(
                impl ProcessWindowsCrateResult<$deref> for $input {
                    fn process(self) -> Result<$deref> {
-                        if self.0 == 0 {
+                        if self == $input(0) {
                            Err(std::io::Error::last_os_error().into())
                        } else {
                            Ok(self.0)
@@ -258,6 +283,24 @@ impl WindowsApi {
        Self::set_window_pos(hwnd, layout, position, flags.bits())
    }

+    pub fn position_border_window(hwnd: HWND, layout: &Rect, activate: bool) -> Result<()> {
+        let flags = if activate {
+            SetWindowPosition::SHOW_WINDOW | SetWindowPosition::NO_ACTIVATE
+        } else {
+            SetWindowPosition::NO_ACTIVATE
+        };
+
+        let position = HWND_BOTTOM;
+        Self::set_window_pos(hwnd, layout, position, flags.bits())
+    }
+
+    pub fn hide_border_window(hwnd: HWND) -> Result<()> {
+        let flags = SetWindowPosition::HIDE_WINDOW;
+
+        let position = HWND_BOTTOM;
+        Self::set_window_pos(hwnd, &Rect::default(), position, flags.bits())
+    }
+
    pub fn set_window_pos(hwnd: HWND, layout: &Rect, position: HWND, flags: u32) -> Result<()> {
        unsafe {
            SetWindowPos(
@@ -289,7 +332,11 @@ impl WindowsApi {
    }

    pub fn restore_window(hwnd: HWND) {
-        Self::show_window(hwnd, SW_RESTORE);
+        Self::show_window(hwnd, SW_SHOWNOACTIVATE);
+    }
+
+    pub fn unmaximize_window(hwnd: HWND) {
+        Self::show_window(hwnd, SW_NORMAL);
    }

    pub fn maximize_window(hwnd: HWND) {
@@ -436,6 +483,11 @@ impl WindowsApi {
        Self::set_window_long_ptr_w(hwnd, GWL_STYLE, new_value)
    }

+    #[allow(dead_code)]
+    pub fn update_ex_style(hwnd: HWND, new_value: isize) -> Result<()> {
+        Self::set_window_long_ptr_w(hwnd, GWL_EXSTYLE, new_value)
+    }
+
    pub fn window_text_w(hwnd: HWND) -> Result<String> {
        let mut text: [u16; 512] = [0; 512];
        match WindowsResult::from(unsafe { GetWindowTextW(hwnd, &mut text) }) {
@@ -565,6 +617,12 @@ impl WindowsApi {
        ))
    }

+    pub fn set_process_dpi_awareness_context() -> Result<()> {
+        unsafe { SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) }
+            .ok()
+            .process()
+    }
+
    #[allow(dead_code)]
    pub fn system_parameters_info_w(
        action: SYSTEM_PARAMETERS_INFO_ACTION,
@@ -610,4 +668,71 @@ impl WindowsApi {
            SPIF_SENDCHANGE,
        )
    }
+
+    pub fn module_handle_w() -> Result<HINSTANCE> {
+        unsafe { GetModuleHandleW(None) }.process()
+    }
+
+    pub fn create_solid_brush(r: u32, g: u32, b: u32) -> HBRUSH {
+        unsafe { CreateSolidBrush(r | (g << 8) | (b << 16)) }
+    }
+
+    pub fn register_class_a(window_class: &WNDCLASSA) -> Result<u16> {
+        Result::from(WindowsResult::from(unsafe { RegisterClassA(window_class) }))
+    }
+
+    pub fn scale_factor_for_monitor(hmonitor: isize) -> Result<DEVICE_SCALE_FACTOR> {
+        unsafe { GetScaleFactorForMonitor(HMONITOR(hmonitor)) }.process()
+    }
+
+    pub fn monitors_have_same_scale_factor(a: isize, b: isize) -> Result<bool> {
+        let a = Self::scale_factor_for_monitor(a)?;
+        let b = Self::scale_factor_for_monitor(b)?;
+
+        Ok(a == b)
+    }
+
+    pub fn change_border_colour(hwnd: isize, r: u32, g: u32, b: u32) -> Result<usize> {
+        Result::from(WindowsResult::from(unsafe {
+            SetClassLongPtrW(
+                HWND(hwnd),
+                GCLP_HBRBACKGROUND,
+                Self::create_solid_brush(r, g, b).0,
+            )
+        }))
+    }
+
+    pub fn round_corners(hwnd: isize) -> Result<()> {
+        let round = DWMWCP_ROUND;
+
+        unsafe {
+            DwmSetWindowAttribute(
+                HWND(hwnd),
+                DWMWA_WINDOW_CORNER_PREFERENCE,
+                std::ptr::addr_of!(round).cast(),
+                4,
+            )
+        }
+        .process()
+    }
+
+    pub fn create_border_window(name: PCSTR, instance: HINSTANCE) -> Result<isize> {
+        unsafe {
+            CreateWindowExA(
+                WS_EX_TOOLWINDOW,
+                name,
+                name,
+                WS_POPUP | WS_SYSMENU | WS_MAXIMIZEBOX | WS_MINIMIZEBOX,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
+                None,
+                None,
+                instance,
+                std::ptr::null(),
+            )
+        }
+        .process()
+    }
 }
--- a/komorebi/src/windows_callbacks.rs
+++ b/komorebi/src/windows_callbacks.rs
@@ -3,10 +3,17 @@ use std::collections::VecDeque;
 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::InvalidateRect;
 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::PostQuitMessage;
+use windows::Win32::UI::WindowsAndMessaging::WM_DESTROY;
+use windows::Win32::UI::WindowsAndMessaging::WM_PAINT;

 use crate::container::Container;
 use crate::monitor::Monitor;
@@ -103,3 +110,24 @@ pub extern "system" fn win_event_hook(
        }
    }
 }
+
+pub extern "system" fn border_window(
+    window: HWND,
+    message: u32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+) -> LRESULT {
+    unsafe {
+        match message as u32 {
+            WM_PAINT => {
+                InvalidateRect(window, std::ptr::null(), true);
+                LRESULT(0)
+            }
+            WM_DESTROY => {
+                PostQuitMessage(0);
+                LRESULT(0)
+            }
+            _ => DefWindowProcW(window, message, wparam, lparam),
+        }
+    }
+}
--- a/komorebi/src/winevent.rs
+++ b/komorebi/src/winevent.rs
@@ -88,7 +88,7 @@ use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_EVENTID_START;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_END;
 use windows::Win32::UI::WindowsAndMessaging::EVENT_UIA_PROPID_START;

-#[derive(Clone, Copy, PartialEq, Debug, Serialize, Display, JsonSchema)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Serialize, Display, JsonSchema)]
 #[repr(u32)]
 #[allow(dead_code)]
 pub enum WinEvent {
--- a/komorebi/src/winevent_listener.rs
+++ b/komorebi/src/winevent_listener.rs
@@ -1,7 +1,6 @@
 use std::sync::atomic::AtomicIsize;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::thread;
 use std::time::Duration;

 use crossbeam_channel::Receiver;
@@ -44,10 +43,10 @@ impl WinEventListener {
        let hook = self.hook.clone();
        let outgoing = self.outgoing_events.lock().clone();

-        thread::spawn(move || unsafe {
+        std::thread::spawn(move || unsafe {
            let hook_ref = SetWinEventHook(
-                EVENT_MIN as u32,
-                EVENT_MAX as u32,
+                EVENT_MIN,
+                EVENT_MAX,
                None,
                Some(windows_callbacks::win_event_hook),
                0,
@@ -96,7 +95,7 @@ impl MessageLoop {
                }
            }

-            thread::sleep(Duration::from_millis(sleep));
+            std::thread::sleep(Duration::from_millis(sleep));

            if !cb(value) {
                break;
--- a/komorebi/src/workspace.rs
+++ b/komorebi/src/workspace.rs
@@ -1,5 +1,6 @@
 use std::collections::VecDeque;
 use std::num::NonZeroUsize;
+use std::sync::atomic::Ordering;

 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -21,6 +22,7 @@ use crate::container::Container;
 use crate::ring::Ring;
 use crate::window::Window;
 use crate::windows_api::WindowsApi;
+use crate::INITIAL_CONFIGURATION_LOADED;

 #[derive(Debug, Clone, Serialize, Getters, CopyGetters, MutGetters, Setters, JsonSchema)]
 pub struct Workspace {
@@ -149,6 +151,10 @@ impl Workspace {
        offset: Option<Rect>,
        invisible_borders: &Rect,
    ) -> Result<()> {
+        if !INITIAL_CONFIGURATION_LOADED.load(Ordering::SeqCst) {
+            return Ok(());
+        }
+
        let container_padding = self.container_padding();
        let mut adjusted_work_area = offset.map_or_else(
            || *work_area,
@@ -177,6 +183,10 @@ impl Workspace {
            }

            if let Some(updated_layout) = updated_layout {
+                if !matches!(updated_layout, Layout::Default(DefaultLayout::BSP)) {
+                    self.set_layout_flip(None);
+                }
+
                self.set_layout(updated_layout);
            }
        }
@@ -356,6 +366,23 @@ impl Workspace {
        false
    }

+    pub fn is_focused_window_monocle_or_maximized(&self) -> Result<bool> {
+        let hwnd = WindowsApi::foreground_window()?;
+        if let Some(window) = self.maximized_window() {
+            if hwnd == window.hwnd {
+                return Ok(true);
+            }
+        }
+
+        if let Some(container) = self.monocle_container() {
+            if container.contains_window(hwnd) {
+                return Ok(true);
+            }
+        }
+
+        Ok(false)
+    }
+
    pub fn contains_window(&self, hwnd: isize) -> bool {
        for container in self.containers() {
            if container.contains_window(hwnd) {
@@ -412,7 +439,11 @@ impl Workspace {
        self.focus_last_container();
    }

-    fn remove_container_by_idx(&mut self, idx: usize) -> Option<Container> {
+    pub fn insert_container_at_idx(&mut self, idx: usize, container: Container) {
+        self.containers_mut().insert(idx, container);
+    }
+
+    pub fn remove_container_by_idx(&mut self, idx: usize) -> Option<Container> {
        if idx < self.resize_dimensions().len() {
            self.resize_dimensions_mut().remove(idx);
        }
@@ -462,6 +493,7 @@ impl Workspace {

        if let Some(window) = self.maximized_window() {
            if window.hwnd == hwnd {
+                window.unmaximize();
                self.set_maximized_window(None);
                self.set_maximized_window_restore_idx(None);
                return Ok(());
@@ -643,22 +675,44 @@ impl Workspace {
    }

    pub fn new_floating_window(&mut self) -> Result<()> {
-        let focused_idx = self.focused_container_idx();
+        let window = if let Some(maximized_window) = self.maximized_window() {
+            let window = *maximized_window;
+            self.set_maximized_window(None);
+            self.set_maximized_window_restore_idx(None);
+            window
+        } else if let Some(monocle_container) = self.monocle_container_mut() {
+            let window = monocle_container
+                .remove_focused_window()
+                .ok_or_else(|| anyhow!("there is no window"))?;

-        let container = self
-            .focused_container_mut()
-            .ok_or_else(|| anyhow!("there is no container"))?;
+            if monocle_container.windows().is_empty() {
+                self.set_monocle_container(None);
+                self.set_monocle_container_restore_idx(None);
+            } else {
+                monocle_container.load_focused_window();
+            }

-        let window = container
-            .remove_focused_window()
-            .ok_or_else(|| anyhow!("there is no window"))?;
-
-        if container.windows().is_empty() {
-            self.containers_mut().remove(focused_idx);
-            self.resize_dimensions_mut().remove(focused_idx);
+            window
        } else {
-            container.load_focused_window();
-        }
+            let focused_idx = self.focused_container_idx();
+
+            let container = self
+                .focused_container_mut()
+                .ok_or_else(|| anyhow!("there is no container"))?;
+
+            let window = container
+                .remove_focused_window()
+                .ok_or_else(|| anyhow!("there is no window"))?;
+
+            if container.windows().is_empty() {
+                self.containers_mut().remove(focused_idx);
+                self.resize_dimensions_mut().remove(focused_idx);
+            } else {
+                container.load_focused_window();
+            }
+
+            window
+        };

        self.floating_windows_mut().push(window);

@@ -744,6 +798,53 @@ impl Workspace {

    pub fn new_maximized_window(&mut self) -> Result<()> {
        let focused_idx = self.focused_container_idx();
+        let foreground_hwnd = WindowsApi::foreground_window()?;
+        let mut floating_window = None;
+
+        if !self.floating_windows().is_empty() {
+            let mut focused_floating_window_idx = None;
+            for (i, w) in self.floating_windows().iter().enumerate() {
+                if w.hwnd == foreground_hwnd {
+                    focused_floating_window_idx = Option::from(i);
+                }
+            }
+
+            if let Some(idx) = focused_floating_window_idx {
+                floating_window = Option::from(self.floating_windows_mut().remove(idx));
+            }
+        }
+
+        if let Some(floating_window) = floating_window {
+            self.set_maximized_window(Option::from(floating_window));
+            self.set_maximized_window_restore_idx(Option::from(focused_idx));
+            if let Some(window) = self.maximized_window() {
+                window.maximize();
+            }
+
+            return Ok(());
+        }
+
+        let monocle_restore_idx = self.monocle_container_restore_idx();
+        if let Some(monocle_container) = self.monocle_container_mut() {
+            let window = monocle_container
+                .remove_focused_window()
+                .ok_or_else(|| anyhow!("there is no window"))?;
+
+            if monocle_container.windows().is_empty() {
+                self.set_monocle_container(None);
+                self.set_monocle_container_restore_idx(None);
+            } else {
+                monocle_container.load_focused_window();
+            }
+
+            self.set_maximized_window(Option::from(window));
+            self.set_maximized_window_restore_idx(monocle_restore_idx);
+            if let Some(window) = self.maximized_window() {
+                window.maximize();
+            }
+
+            return Ok(());
+        }

        let container = self
            .focused_container_mut()
--- a/komorebic.lib.sample.ahk
+++ b/komorebic.lib.sample.ahk
@@ -1,7 +1,7 @@
 ; Generated by komorebic.exe

-Start(ffm) {
-    Run, komorebic.exe start  --ffm %ffm%, , Hide
+Start(ffm, await_configuration) {
+    Run, komorebic.exe start %ffm% --await_configuration %await_configuration%, , Hide
 }

 Stop() {
@@ -252,10 +252,22 @@ WatchConfiguration(boolean_state) {
    Run, komorebic.exe watch-configuration %boolean_state%, , Hide
 }

+CompleteConfiguration() {
+    Run, komorebic.exe complete-configuration, , Hide
+}
+
 WindowHidingBehaviour(hiding_behaviour) {
    Run, komorebic.exe window-hiding-behaviour %hiding_behaviour%, , Hide
 }

+CrossMonitorMoveBehaviour(move_behaviour) {
+    Run, komorebic.exe cross-monitor-move-behaviour %move_behaviour%, , Hide
+}
+
+ToggleCrossMonitorMoveBehaviour() {
+    Run, komorebic.exe toggle-cross-monitor-move-behaviour, , Hide
+}
+
 UnmanagedWindowOperationBehaviour(operation_behaviour) {
    Run, komorebic.exe unmanaged-window-operation-behaviour %operation_behaviour%, , Hide
 }
@@ -288,6 +300,14 @@ IdentifyBorderOverflowApplication(identifier, id) {
    Run, komorebic.exe identify-border-overflow-application %identifier% "%id%", , Hide
 }

+ActiveWindowBorder(boolean_state) {
+    Run, komorebic.exe active-window-border %boolean_state%, , Hide
+}
+
+ActiveWindowBorderColour(r, g, b) {
+    Run, komorebic.exe active-window-border-colour %r% %g% %b%, , Hide
+}
+
 FocusFollowsMouse(boolean_state, implementation) {
    Run, komorebic.exe focus-follows-mouse %boolean_state% --implementation %implementation%, , Hide
 }
--- a/komorebic/Cargo.toml
+++ b/komorebic/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.8"
+version = "0.1.12"
 authors = ["Jade Iqbal <jadeiqbal@fastmail.com>"]
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
 categories = ["cli", "tiling-window-manager", "windows"]
@@ -21,14 +21,14 @@ fs-tail = "0.1"
 heck = "0.4"
 lazy_static = "1"
 paste = "1"
-powershell_script = "0.3"
+powershell_script = "1.0"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-serde_yaml = "0.8"
+serde_yaml = "0.9"
 uds_windows = "1"

 [dependencies.windows]
-version = "0.35"
+version = "0.39"
 features = [
    "Win32_Foundation",
    "Win32_UI_WindowsAndMessaging"
--- a/komorebic/src/main.rs
+++ b/komorebic/src/main.rs
@@ -36,6 +36,7 @@ use komorebi_core::CycleDirection;
 use komorebi_core::DefaultLayout;
 use komorebi_core::FocusFollowsMouseImplementation;
 use komorebi_core::HidingBehaviour;
+use komorebi_core::MoveBehaviour;
 use komorebi_core::OperationBehaviour;
 use komorebi_core::OperationDirection;
 use komorebi_core::Rect;
@@ -60,6 +61,9 @@ lazy_static! {
            dirs::home_dir().expect("there is no home directory")
        }
    };
+    static ref DATA_DIR: PathBuf = dirs::data_local_dir()
+        .expect("there is no local data directory")
+        .join("komorebi");
 }

 trait AhkLibrary {
@@ -115,6 +119,7 @@ gen_enum_subcommand_args! {
    MouseFollowsFocus: BooleanState,
    Query: StateQuery,
    WindowHidingBehaviour: HidingBehaviour,
+    CrossMonitorMoveBehaviour: MoveBehaviour,
    UnmanagedWindowOperationBehaviour: OperationBehaviour,
 }

@@ -207,6 +212,7 @@ pub struct WorkspaceLayoutRule {
    /// The number of window containers on-screen required to trigger this layout rule
    at_container_count: usize,

+    #[clap(arg_enum)]
    layout: DefaultLayout,
 }

@@ -387,11 +393,30 @@ struct FocusFollowsMouse {
    boolean_state: BooleanState,
 }

+#[derive(Parser, AhkFunction)]
+struct ActiveWindowBorder {
+    #[clap(arg_enum)]
+    boolean_state: BooleanState,
+}
+
+#[derive(Parser, AhkFunction)]
+struct ActiveWindowBorderColour {
+    /// Red
+    r: u32,
+    /// Green
+    g: u32,
+    /// Blue
+    b: u32,
+}
+
 #[derive(Parser, AhkFunction)]
 struct Start {
    /// Allow the use of komorebi's custom focus-follows-mouse implementation
-    #[clap(long)]
+    #[clap(action, short, long = "ffm")]
    ffm: bool,
+    /// Wait for 'komorebic complete-configuration' to be sent before processing events
+    #[clap(action, short, long)]
+    await_configuration: bool,
 }

 #[derive(Parser, AhkFunction)]
@@ -621,9 +646,16 @@ enum SubCommand {
    /// Enable or disable watching of ~/komorebi.ahk (if it exists)
    #[clap(arg_required_else_help = true)]
    WatchConfiguration(WatchConfiguration),
+    /// Signal that the final configuration option has been sent
+    CompleteConfiguration,
    /// Set the window behaviour when switching workspaces / cycling stacks
    #[clap(arg_required_else_help = true)]
    WindowHidingBehaviour(WindowHidingBehaviour),
+    /// Set the behaviour when moving windows across monitor boundaries
+    #[clap(arg_required_else_help = true)]
+    CrossMonitorMoveBehaviour(CrossMonitorMoveBehaviour),
+    /// Toggle the behaviour when moving windows across monitor boundaries
+    ToggleCrossMonitorMoveBehaviour,
    /// Set the operation behaviour when the focused window is not managed
    #[clap(arg_required_else_help = true)]
    UnmanagedWindowOperationBehaviour(UnmanagedWindowOperationBehaviour),
@@ -649,6 +681,12 @@ enum SubCommand {
    #[clap(arg_required_else_help = true)]
    #[clap(alias = "identify-border-overflow")]
    IdentifyBorderOverflowApplication(IdentifyBorderOverflowApplication),
+    /// Enable or disable the active window border
+    #[clap(arg_required_else_help = true)]
+    ActiveWindowBorder(ActiveWindowBorder),
+    /// Set the colour for the active window border
+    #[clap(arg_required_else_help = true)]
+    ActiveWindowBorderColour(ActiveWindowBorderColour),
    /// Enable or disable focus follows mouse for the operating system
    #[clap(arg_required_else_help = true)]
    FocusFollowsMouse(FocusFollowsMouse),
@@ -675,12 +713,9 @@ enum SubCommand {
 }

 pub fn send_message(bytes: &[u8]) -> Result<()> {
-    let mut socket = HOME_DIR.clone();
-    socket.push("komorebi.sock");
-    let socket = socket.as_path();
-
+    let socket = DATA_DIR.join("komorebi.sock");
    let mut stream = UnixStream::connect(&socket)?;
-    Ok(stream.write_all(&*bytes)?)
+    Ok(stream.write_all(bytes)?)
 }

 #[allow(clippy::too_many_lines)]
@@ -720,46 +755,47 @@ fn main() -> Result<()> {
            color_log.push("komorebi.log");
            let file = TailedFile::new(File::open(color_log)?);
            let locked = file.lock();
-            for line in locked.lines() {
-                println!("{}", line?);
+            #[allow(clippy::significant_drop_in_scrutinee)]
+            for line in locked.lines().flatten() {
+                println!("{}", line);
            }
        }
        SubCommand::Focus(arg) => {
-            send_message(&*SocketMessage::FocusWindow(arg.operation_direction).as_bytes()?)?;
+            send_message(&SocketMessage::FocusWindow(arg.operation_direction).as_bytes()?)?;
        }
        SubCommand::Promote => {
-            send_message(&*SocketMessage::Promote.as_bytes()?)?;
+            send_message(&SocketMessage::Promote.as_bytes()?)?;
        }
        SubCommand::TogglePause => {
-            send_message(&*SocketMessage::TogglePause.as_bytes()?)?;
+            send_message(&SocketMessage::TogglePause.as_bytes()?)?;
        }
        SubCommand::Retile => {
-            send_message(&*SocketMessage::Retile.as_bytes()?)?;
+            send_message(&SocketMessage::Retile.as_bytes()?)?;
        }
        SubCommand::Move(arg) => {
-            send_message(&*SocketMessage::MoveWindow(arg.operation_direction).as_bytes()?)?;
+            send_message(&SocketMessage::MoveWindow(arg.operation_direction).as_bytes()?)?;
        }
        SubCommand::CycleFocus(arg) => {
-            send_message(&*SocketMessage::CycleFocusWindow(arg.cycle_direction).as_bytes()?)?;
+            send_message(&SocketMessage::CycleFocusWindow(arg.cycle_direction).as_bytes()?)?;
        }
        SubCommand::CycleMove(arg) => {
-            send_message(&*SocketMessage::CycleMoveWindow(arg.cycle_direction).as_bytes()?)?;
+            send_message(&SocketMessage::CycleMoveWindow(arg.cycle_direction).as_bytes()?)?;
        }
        SubCommand::MoveToMonitor(arg) => {
-            send_message(&*SocketMessage::MoveContainerToMonitorNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::MoveContainerToMonitorNumber(arg.target).as_bytes()?)?;
        }
        SubCommand::MoveToWorkspace(arg) => {
-            send_message(&*SocketMessage::MoveContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::MoveContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
        }
        SubCommand::SendToMonitor(arg) => {
-            send_message(&*SocketMessage::SendContainerToMonitorNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::SendContainerToMonitorNumber(arg.target).as_bytes()?)?;
        }
        SubCommand::SendToWorkspace(arg) => {
-            send_message(&*SocketMessage::SendContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::SendContainerToWorkspaceNumber(arg.target).as_bytes()?)?;
        }
        SubCommand::SendToMonitorWorkspace(arg) => {
            send_message(
-                &*SocketMessage::SendContainerToMonitorWorkspaceNumber(
+                &SocketMessage::SendContainerToMonitorWorkspaceNumber(
                    arg.target_monitor,
                    arg.target_workspace,
                )
@@ -767,11 +803,11 @@ fn main() -> Result<()> {
            )?;
        }
        SubCommand::MoveWorkspaceToMonitor(arg) => {
-            send_message(&*SocketMessage::MoveWorkspaceToMonitorNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::MoveWorkspaceToMonitorNumber(arg.target).as_bytes()?)?;
        }
        SubCommand::InvisibleBorders(arg) => {
            send_message(
-                &*SocketMessage::InvisibleBorders(Rect {
+                &SocketMessage::InvisibleBorders(Rect {
                    left: arg.left,
                    top: arg.top,
                    right: arg.right,
@@ -782,7 +818,7 @@ fn main() -> Result<()> {
        }
        SubCommand::WorkAreaOffset(arg) => {
            send_message(
-                &*SocketMessage::WorkAreaOffset(Rect {
+                &SocketMessage::WorkAreaOffset(Rect {
                    left: arg.left,
                    top: arg.top,
                    right: arg.right,
@@ -793,50 +829,50 @@ fn main() -> Result<()> {
        }
        SubCommand::ContainerPadding(arg) => {
            send_message(
-                &*SocketMessage::ContainerPadding(arg.monitor, arg.workspace, arg.size)
+                &SocketMessage::ContainerPadding(arg.monitor, arg.workspace, arg.size)
                    .as_bytes()?,
            )?;
        }
        SubCommand::WorkspacePadding(arg) => {
            send_message(
-                &*SocketMessage::WorkspacePadding(arg.monitor, arg.workspace, arg.size)
+                &SocketMessage::WorkspacePadding(arg.monitor, arg.workspace, arg.size)
                    .as_bytes()?,
            )?;
        }
        SubCommand::AdjustWorkspacePadding(arg) => {
            send_message(
-                &*SocketMessage::AdjustWorkspacePadding(arg.sizing, arg.adjustment).as_bytes()?,
+                &SocketMessage::AdjustWorkspacePadding(arg.sizing, arg.adjustment).as_bytes()?,
            )?;
        }
        SubCommand::AdjustContainerPadding(arg) => {
            send_message(
-                &*SocketMessage::AdjustContainerPadding(arg.sizing, arg.adjustment).as_bytes()?,
+                &SocketMessage::AdjustContainerPadding(arg.sizing, arg.adjustment).as_bytes()?,
            )?;
        }
        SubCommand::ToggleFocusFollowsMouse(arg) => {
-            send_message(&*SocketMessage::ToggleFocusFollowsMouse(arg.implementation).as_bytes()?)?;
+            send_message(&SocketMessage::ToggleFocusFollowsMouse(arg.implementation).as_bytes()?)?;
        }
        SubCommand::ToggleTiling => {
-            send_message(&*SocketMessage::ToggleTiling.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleTiling.as_bytes()?)?;
        }
        SubCommand::ToggleFloat => {
-            send_message(&*SocketMessage::ToggleFloat.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleFloat.as_bytes()?)?;
        }
        SubCommand::ToggleMonocle => {
-            send_message(&*SocketMessage::ToggleMonocle.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleMonocle.as_bytes()?)?;
        }
        SubCommand::ToggleMaximize => {
-            send_message(&*SocketMessage::ToggleMaximize.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleMaximize.as_bytes()?)?;
        }
        SubCommand::WorkspaceLayout(arg) => {
            send_message(
-                &*SocketMessage::WorkspaceLayout(arg.monitor, arg.workspace, arg.value)
+                &SocketMessage::WorkspaceLayout(arg.monitor, arg.workspace, arg.value)
                    .as_bytes()?,
            )?;
        }
        SubCommand::WorkspaceCustomLayout(arg) => {
            send_message(
-                &*SocketMessage::WorkspaceLayoutCustom(
+                &SocketMessage::WorkspaceLayoutCustom(
                    arg.monitor,
                    arg.workspace,
                    resolve_windows_path(&arg.path)?,
@@ -846,7 +882,7 @@ fn main() -> Result<()> {
        }
        SubCommand::WorkspaceLayoutRule(arg) => {
            send_message(
-                &*SocketMessage::WorkspaceLayoutRule(
+                &SocketMessage::WorkspaceLayoutRule(
                    arg.monitor,
                    arg.workspace,
                    arg.at_container_count,
@@ -857,7 +893,7 @@ fn main() -> Result<()> {
        }
        SubCommand::WorkspaceCustomLayoutRule(arg) => {
            send_message(
-                &*SocketMessage::WorkspaceLayoutCustomRule(
+                &SocketMessage::WorkspaceLayoutCustomRule(
                    arg.monitor,
                    arg.workspace,
                    arg.at_container_count,
@@ -868,13 +904,12 @@ fn main() -> Result<()> {
        }
        SubCommand::ClearWorkspaceLayoutRules(arg) => {
            send_message(
-                &*SocketMessage::ClearWorkspaceLayoutRules(arg.monitor, arg.workspace)
-                    .as_bytes()?,
+                &SocketMessage::ClearWorkspaceLayoutRules(arg.monitor, arg.workspace).as_bytes()?,
            )?;
        }
        SubCommand::WorkspaceTiling(arg) => {
            send_message(
-                &*SocketMessage::WorkspaceTiling(arg.monitor, arg.workspace, arg.value.into())
+                &SocketMessage::WorkspaceTiling(arg.monitor, arg.workspace, arg.value.into())
                    .as_bytes()?,
            )?;
        }
@@ -902,19 +937,33 @@ fn main() -> Result<()> {

            let script = exec.map_or_else(
                || {
-                    if arg.ffm {
-                        String::from(
-                            "Start-Process komorebi.exe -ArgumentList '--ffm' -WindowStyle hidden",
+                    if arg.ffm | arg.await_configuration {
+                        format!(
+                            "Start-Process komorebi.exe -ArgumentList {} -WindowStyle hidden",
+                            if arg.ffm && arg.await_configuration {
+                                "'--ffm','--await-configuration'"
+                            } else if arg.ffm {
+                                "'--ffm'"
+                            } else {
+                                "'--await-configuration'"
+                            }
                        )
                    } else {
                        String::from("Start-Process komorebi.exe -WindowStyle hidden")
                    }
                },
                |exec| {
-                    if arg.ffm {
+                    if arg.ffm | arg.await_configuration {
                        format!(
-                            "Start-Process '{}' -ArgumentList '--ffm' -WindowStyle hidden",
-                            exec
+                            "Start-Process '{}' -ArgumentList {} -WindowStyle hidden",
+                            exec,
+                            if arg.ffm && arg.await_configuration {
+                                "'--ffm','--await-configuration'"
+                            } else if arg.ffm {
+                                "'--ffm'"
+                            } else {
+                                "'--await-configuration'"
+                            }
                        )
                    } else {
                        format!("Start-Process '{}' -WindowStyle hidden", exec)
@@ -922,7 +971,7 @@ fn main() -> Result<()> {
                },
            );

-            match powershell_script::run(&script, true) {
+            match powershell_script::run(&script) {
                Ok(output) => {
                    println!("{}", output);
                }
@@ -932,49 +981,49 @@ fn main() -> Result<()> {
            }
        }
        SubCommand::Stop => {
-            send_message(&*SocketMessage::Stop.as_bytes()?)?;
+            send_message(&SocketMessage::Stop.as_bytes()?)?;
        }
        SubCommand::FloatRule(arg) => {
-            send_message(&*SocketMessage::FloatRule(arg.identifier, arg.id).as_bytes()?)?;
+            send_message(&SocketMessage::FloatRule(arg.identifier, arg.id).as_bytes()?)?;
        }
        SubCommand::ManageRule(arg) => {
-            send_message(&*SocketMessage::ManageRule(arg.identifier, arg.id).as_bytes()?)?;
+            send_message(&SocketMessage::ManageRule(arg.identifier, arg.id).as_bytes()?)?;
        }
        SubCommand::WorkspaceRule(arg) => {
            send_message(
-                &*SocketMessage::WorkspaceRule(arg.identifier, arg.id, arg.monitor, arg.workspace)
+                &SocketMessage::WorkspaceRule(arg.identifier, arg.id, arg.monitor, arg.workspace)
                    .as_bytes()?,
            )?;
        }
        SubCommand::Stack(arg) => {
-            send_message(&*SocketMessage::StackWindow(arg.operation_direction).as_bytes()?)?;
+            send_message(&SocketMessage::StackWindow(arg.operation_direction).as_bytes()?)?;
        }
        SubCommand::Unstack => {
-            send_message(&*SocketMessage::UnstackWindow.as_bytes()?)?;
+            send_message(&SocketMessage::UnstackWindow.as_bytes()?)?;
        }
        SubCommand::CycleStack(arg) => {
-            send_message(&*SocketMessage::CycleStack(arg.cycle_direction).as_bytes()?)?;
+            send_message(&SocketMessage::CycleStack(arg.cycle_direction).as_bytes()?)?;
        }
        SubCommand::ChangeLayout(arg) => {
-            send_message(&*SocketMessage::ChangeLayout(arg.default_layout).as_bytes()?)?;
+            send_message(&SocketMessage::ChangeLayout(arg.default_layout).as_bytes()?)?;
        }
        SubCommand::LoadCustomLayout(arg) => {
            send_message(
-                &*SocketMessage::ChangeLayoutCustom(resolve_windows_path(&arg.path)?).as_bytes()?,
+                &SocketMessage::ChangeLayoutCustom(resolve_windows_path(&arg.path)?).as_bytes()?,
            )?;
        }
        SubCommand::FlipLayout(arg) => {
-            send_message(&*SocketMessage::FlipLayout(arg.axis).as_bytes()?)?;
+            send_message(&SocketMessage::FlipLayout(arg.axis).as_bytes()?)?;
        }
        SubCommand::FocusMonitor(arg) => {
-            send_message(&*SocketMessage::FocusMonitorNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::FocusMonitorNumber(arg.target).as_bytes()?)?;
        }
        SubCommand::FocusWorkspace(arg) => {
-            send_message(&*SocketMessage::FocusWorkspaceNumber(arg.target).as_bytes()?)?;
+            send_message(&SocketMessage::FocusWorkspaceNumber(arg.target).as_bytes()?)?;
        }
        SubCommand::FocusMonitorWorkspace(arg) => {
            send_message(
-                &*SocketMessage::FocusMonitorWorkspaceNumber(
+                &SocketMessage::FocusMonitorWorkspaceNumber(
                    arg.target_monitor,
                    arg.target_workspace,
                )
@@ -982,23 +1031,23 @@ fn main() -> Result<()> {
            )?;
        }
        SubCommand::CycleMonitor(arg) => {
-            send_message(&*SocketMessage::CycleFocusMonitor(arg.cycle_direction).as_bytes()?)?;
+            send_message(&SocketMessage::CycleFocusMonitor(arg.cycle_direction).as_bytes()?)?;
        }
        SubCommand::CycleWorkspace(arg) => {
-            send_message(&*SocketMessage::CycleFocusWorkspace(arg.cycle_direction).as_bytes()?)?;
+            send_message(&SocketMessage::CycleFocusWorkspace(arg.cycle_direction).as_bytes()?)?;
        }
        SubCommand::NewWorkspace => {
-            send_message(&*SocketMessage::NewWorkspace.as_bytes()?)?;
+            send_message(&SocketMessage::NewWorkspace.as_bytes()?)?;
        }
        SubCommand::WorkspaceName(name) => {
            send_message(
-                &*SocketMessage::WorkspaceName(name.monitor, name.workspace, name.value)
+                &SocketMessage::WorkspaceName(name.monitor, name.workspace, name.value)
                    .as_bytes()?,
            )?;
        }
        SubCommand::EnsureWorkspaces(workspaces) => {
            send_message(
-                &*SocketMessage::EnsureWorkspaces(workspaces.monitor, workspaces.workspace_count)
+                &SocketMessage::EnsureWorkspaces(workspaces.monitor, workspaces.workspace_count)
                    .as_bytes()?,
            )?;
        }
@@ -1019,7 +1068,7 @@ fn main() -> Result<()> {
                },
            };

-            send_message(&*SocketMessage::State.as_bytes()?)?;
+            send_message(&SocketMessage::State.as_bytes()?)?;

            let listener = UnixListener::bind(&socket)?;
            match listener.accept() {
@@ -1053,7 +1102,7 @@ fn main() -> Result<()> {
                },
            };

-            send_message(&*SocketMessage::Query(arg.state_query).as_bytes()?)?;
+            send_message(&SocketMessage::Query(arg.state_query).as_bytes()?)?;

            let listener = UnixListener::bind(&socket)?;
            match listener.accept() {
@@ -1071,8 +1120,7 @@ fn main() -> Result<()> {
            }
        }
        SubCommand::RestoreWindows => {
-            let mut hwnd_json = HOME_DIR.clone();
-            hwnd_json.push("komorebi.hwnd.json");
+            let hwnd_json = DATA_DIR.join("komorebi.hwnd.json");

            let file = File::open(hwnd_json)?;
            let reader = BufReader::new(file);
@@ -1083,93 +1131,107 @@ fn main() -> Result<()> {
            }
        }
        SubCommand::ResizeEdge(resize) => {
-            send_message(
-                &*SocketMessage::ResizeWindowEdge(resize.edge, resize.sizing).as_bytes()?,
-            )?;
+            send_message(&SocketMessage::ResizeWindowEdge(resize.edge, resize.sizing).as_bytes()?)?;
        }
        SubCommand::ResizeAxis(arg) => {
-            send_message(&*SocketMessage::ResizeWindowAxis(arg.axis, arg.sizing).as_bytes()?)?;
+            send_message(&SocketMessage::ResizeWindowAxis(arg.axis, arg.sizing).as_bytes()?)?;
        }
        SubCommand::FocusFollowsMouse(arg) => {
            send_message(
-                &*SocketMessage::FocusFollowsMouse(arg.implementation, arg.boolean_state.into())
+                &SocketMessage::FocusFollowsMouse(arg.implementation, arg.boolean_state.into())
                    .as_bytes()?,
            )?;
        }
        SubCommand::ReloadConfiguration => {
-            send_message(&*SocketMessage::ReloadConfiguration.as_bytes()?)?;
+            send_message(&SocketMessage::ReloadConfiguration.as_bytes()?)?;
        }
        SubCommand::WatchConfiguration(arg) => {
-            send_message(
-                &*SocketMessage::WatchConfiguration(arg.boolean_state.into()).as_bytes()?,
-            )?;
+            send_message(&SocketMessage::WatchConfiguration(arg.boolean_state.into()).as_bytes()?)?;
+        }
+        SubCommand::CompleteConfiguration => {
+            send_message(&SocketMessage::CompleteConfiguration.as_bytes()?)?;
        }
        SubCommand::IdentifyObjectNameChangeApplication(target) => {
            send_message(
-                &*SocketMessage::IdentifyObjectNameChangeApplication(target.identifier, target.id)
+                &SocketMessage::IdentifyObjectNameChangeApplication(target.identifier, target.id)
                    .as_bytes()?,
            )?;
        }
        SubCommand::IdentifyTrayApplication(target) => {
            send_message(
-                &*SocketMessage::IdentifyTrayApplication(target.identifier, target.id)
-                    .as_bytes()?,
+                &SocketMessage::IdentifyTrayApplication(target.identifier, target.id).as_bytes()?,
            )?;
        }
        SubCommand::IdentifyLayeredApplication(target) => {
            send_message(
-                &*SocketMessage::IdentifyLayeredApplication(target.identifier, target.id)
+                &SocketMessage::IdentifyLayeredApplication(target.identifier, target.id)
                    .as_bytes()?,
            )?;
        }
        SubCommand::IdentifyBorderOverflowApplication(target) => {
            send_message(
-                &*SocketMessage::IdentifyBorderOverflowApplication(target.identifier, target.id)
+                &SocketMessage::IdentifyBorderOverflowApplication(target.identifier, target.id)
                    .as_bytes()?,
            )?;
        }
        SubCommand::Manage => {
-            send_message(&*SocketMessage::ManageFocusedWindow.as_bytes()?)?;
+            send_message(&SocketMessage::ManageFocusedWindow.as_bytes()?)?;
        }
        SubCommand::Unmanage => {
-            send_message(&*SocketMessage::UnmanageFocusedWindow.as_bytes()?)?;
+            send_message(&SocketMessage::UnmanageFocusedWindow.as_bytes()?)?;
        }
        SubCommand::QuickSaveResize => {
-            send_message(&*SocketMessage::QuickSave.as_bytes()?)?;
+            send_message(&SocketMessage::QuickSave.as_bytes()?)?;
        }
        SubCommand::QuickLoadResize => {
-            send_message(&*SocketMessage::QuickLoad.as_bytes()?)?;
+            send_message(&SocketMessage::QuickLoad.as_bytes()?)?;
        }
        SubCommand::SaveResize(arg) => {
-            send_message(&*SocketMessage::Save(resolve_windows_path(&arg.path)?).as_bytes()?)?;
+            send_message(&SocketMessage::Save(resolve_windows_path(&arg.path)?).as_bytes()?)?;
        }
        SubCommand::LoadResize(arg) => {
-            send_message(&*SocketMessage::Load(resolve_windows_path(&arg.path)?).as_bytes()?)?;
+            send_message(&SocketMessage::Load(resolve_windows_path(&arg.path)?).as_bytes()?)?;
        }
        SubCommand::Subscribe(arg) => {
-            send_message(&*SocketMessage::AddSubscriber(arg.named_pipe).as_bytes()?)?;
+            send_message(&SocketMessage::AddSubscriber(arg.named_pipe).as_bytes()?)?;
        }
        SubCommand::Unsubscribe(arg) => {
-            send_message(&*SocketMessage::RemoveSubscriber(arg.named_pipe).as_bytes()?)?;
+            send_message(&SocketMessage::RemoveSubscriber(arg.named_pipe).as_bytes()?)?;
        }
        SubCommand::ToggleMouseFollowsFocus => {
-            send_message(&*SocketMessage::ToggleMouseFollowsFocus.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleMouseFollowsFocus.as_bytes()?)?;
        }
        SubCommand::MouseFollowsFocus(arg) => {
-            send_message(&*SocketMessage::MouseFollowsFocus(arg.boolean_state.into()).as_bytes()?)?;
+            send_message(&SocketMessage::MouseFollowsFocus(arg.boolean_state.into()).as_bytes()?)?;
+        }
+        SubCommand::ActiveWindowBorder(arg) => {
+            send_message(&SocketMessage::ActiveWindowBorder(arg.boolean_state.into()).as_bytes()?)?;
+        }
+        SubCommand::ActiveWindowBorderColour(arg) => {
+            send_message(
+                &SocketMessage::ActiveWindowBorderColour(arg.r, arg.g, arg.b).as_bytes()?,
+            )?;
        }
        SubCommand::ResizeDelta(arg) => {
-            send_message(&*SocketMessage::ResizeDelta(arg.pixels).as_bytes()?)?;
+            send_message(&SocketMessage::ResizeDelta(arg.pixels).as_bytes()?)?;
        }
        SubCommand::ToggleWindowContainerBehaviour => {
-            send_message(&*SocketMessage::ToggleWindowContainerBehaviour.as_bytes()?)?;
+            send_message(&SocketMessage::ToggleWindowContainerBehaviour.as_bytes()?)?;
        }
        SubCommand::WindowHidingBehaviour(arg) => {
-            send_message(&*SocketMessage::WindowHidingBehaviour(arg.hiding_behaviour).as_bytes()?)?;
+            send_message(&SocketMessage::WindowHidingBehaviour(arg.hiding_behaviour).as_bytes()?)?;
+        }
+        SubCommand::CrossMonitorMoveBehaviour(arg) => {
+            send_message(
+                &SocketMessage::CrossMonitorMoveBehaviour(arg.move_behaviour).as_bytes()?,
+            )?;
+        }
+        SubCommand::ToggleCrossMonitorMoveBehaviour => {
+            send_message(&SocketMessage::ToggleCrossMonitorMoveBehaviour.as_bytes()?)?;
        }
        SubCommand::UnmanagedWindowOperationBehaviour(arg) => {
            send_message(
-                &*SocketMessage::UnmanagedWindowOperationBehaviour(arg.operation_behaviour)
+                &SocketMessage::UnmanagedWindowOperationBehaviour(arg.operation_behaviour)
                    .as_bytes()?,
            )?;
        }
@@ -1241,7 +1303,7 @@ fn main() -> Result<()> {
                },
            };

-            send_message(&*SocketMessage::NotificationSchema.as_bytes()?)?;
+            send_message(&SocketMessage::NotificationSchema.as_bytes()?)?;

            let listener = UnixListener::bind(&socket)?;
            match listener.accept() {
@@ -1283,15 +1345,18 @@ fn resolve_windows_path(raw_path: &str) -> Result<PathBuf> {
        .parent()
        .ok_or_else(|| anyhow!("cannot parse directory"))?;

-    let file = full_path
-        .components()
-        .last()
-        .ok_or_else(|| anyhow!("cannot parse filename"))?;
+    Ok(if parent.is_dir() {
+        let file = full_path
+            .components()
+            .last()
+            .ok_or_else(|| anyhow!("cannot parse filename"))?;

-    let mut canonicalized = std::fs::canonicalize(parent)?;
-    canonicalized.push(file);
-
-    Ok(canonicalized)
+        let mut canonicalized = std::fs::canonicalize(parent)?;
+        canonicalized.push(file);
+        canonicalized
+    } else {
+        full_path
+    })
 }

 fn show_window(hwnd: HWND, command: SHOW_WINDOW_CMD) {
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -0,0 +1,2 @@
+[toolchain]
+channel = "stable"