wip use cached monitor idx when handling newly spawned windows

remove(wm): remove workspace_reconciliator
refactor(wm): refactor alt-tab reconciliation
2026-01-14 06:13:36 +01:00 · 2025-03-31 15:40:59 -07:00 · 2025-03-31 15:23:33 -07:00 · 2025-03-31 15:23:14 -07:00 · 2025-03-31 15:23:10 -07:00 · 2025-03-30 14:35:59 -07:00
47 changed files with 2069 additions and 467 deletions
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,40 @@
+# The Komorebi Code of Conduct
+
+This document is based on the [Rust Code of
+Conduct](https://www.rust-lang.org/policies/code-of-conduct)
+
+## Conduct
+
+- We are committed to providing a friendly, safe and welcoming environment for
+all, regardless of level of experience, gender identity and expression, sexual
+orientation, disability, personal appearance, body size, race, ethnicity, age,
+religion, nationality, or other similar characteristic.
+
+- Please avoid using overtly sexual aliases or other nicknames that might
+detract from a friendly, safe and welcoming environment for all.
+
+- Please be kind and courteous. There’s no need to be mean or rude.
+
+- Respect that people have differences of opinion and that every design or
+implementation choice carries a trade-off and numerous costs. There is seldom a
+right answer.
+
+- Please keep unstructured critique to a minimum. If you have solid ideas you
+want to experiment with, make a fork and see how it works.
+
+- We will exclude you from interaction if you insult, demean or harass anyone.
+That is not welcome behavior. We interpret the term “harassment” as including
+the definition in the [Citizen Code of
+Conduct](https://github.com/stumpsyn/policies/blob/master/citizen_code_of_conduct.md);
+if you have any lack of clarity about what might be included in that concept,
+please read their definition. In particular, we don’t tolerate behavior that
+excludes people in socially marginalized groups.
+
+- Private harassment is also unacceptable. No matter who you are, if you feel
+you have been or are being harassed or made uncomfortable by a community member,
+please contact me immediately. Whether you’re a regular contributor or a
+newcomer, we care about making this community a safe place for you and we’ve got
+your back.
+
+- Likewise any spamming, trolling, flaming, baiting or other attention-stealing
+behavior is not welcome.
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -468,9 +468,9 @@ checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"

 [[package]]
 name = "async-trait"
-version = "0.1.87"
+version = "0.1.88"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d556ec1359574147ec0c4fc5eb525f3f23263a592b1a9c07e0a75b427de55c97"
+checksum = "e539d3fca749fcee5236ab05e93a52867dd549cc157c8cb7f99595f3cedffdb5"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -728,9 +728,9 @@ dependencies = [

 [[package]]
 name = "bytemuck_derive"
-version = "1.8.1"
+version = "1.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fa76293b4f7bb636ab88fd78228235b5248b4d05cc589aed610f954af5d7c7a"
+checksum = "2ff22c2722516255d1823ce3cc4bc0b154dbc9364be5c905d6baa6eccbbc8774"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -791,9 +791,9 @@ dependencies = [

 [[package]]
 name = "cc"
-version = "1.2.16"
+version = "1.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
+checksum = "1fcb57c740ae1daf453ae85f16e37396f672b039e00d9d866e07ddb24e328e3a"
 dependencies = [
 "jobserver",
 "libc",
@@ -1187,9 +1187,9 @@ checksum = "96a6ac251f4a2aca6b3f91340350eab87ae57c3f127ffeb585e92bd336717991"

 [[package]]
 name = "deranged"
-version = "0.3.11"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
 dependencies = [
 "powerfmt",
 ]
@@ -1678,9 +1678,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

 [[package]]
 name = "foldhash"
-version = "0.1.4"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a0d2fde1f7b3d48b8395d5f2de76c18a528bd6a9cdde438df747bfcba3e05d6f"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"

 [[package]]
 name = "font-loader"
@@ -1910,14 +1910,14 @@ dependencies = [

 [[package]]
 name = "getrandom"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a49c392881ce6d5c3b8cb70f98717b7c07aabbdff06687b9030dbfbe2725f8"
+checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
 dependencies = [
 "cfg-if 1.0.0",
 "libc",
- "wasi 0.13.3+wasi-0.2.2",
- "windows-targets 0.52.6",
+ "r-efi",
+ "wasi 0.14.2+wasi-0.2.4",
 ]

 [[package]]
@@ -1950,9 +1950,9 @@ checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"

 [[package]]
 name = "git2"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fda788993cc341f69012feba8bf45c0ba4f3291fcc08e214b4d5a7332d88aff"
+checksum = "5220b8ba44c68a9a7f7a7659e864dd73692e417ef0211bea133c7b74e031eeb9"
 dependencies = [
 "bitflags 2.9.0",
 "libc",
@@ -2110,9 +2110,9 @@ dependencies = [

 [[package]]
 name = "half"
-version = "2.4.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+checksum = "7db2ff139bba50379da6aa0766b52fdcb62cb5b263009b09ed58ba604e14bbd1"
 dependencies = [
 "cfg-if 1.0.0",
 "crunchy",
@@ -2184,9 +2184,9 @@ dependencies = [

 [[package]]
 name = "http"
-version = "1.2.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f16ca2af56261c99fba8bac40a10251ce8188205a4c448fbb745a2e4daa76fea"
+checksum = "f4a85d31aea989eead29a3aaf9e1115a180df8282431156e533de47660892565"
 dependencies = [
 "bytes",
 "fnv",
@@ -2205,12 +2205,12 @@ dependencies = [

 [[package]]
 name = "http-body-util"
-version = "0.1.2"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
 dependencies = [
 "bytes",
- "futures-util",
+ "futures-core",
 "http",
 "http-body",
 "pin-project-lite",
@@ -2665,7 +2665,7 @@ checksum = "e2db585e1d738fc771bf08a151420d3ed193d9d895a36df7f6f8a9456b911ddc"

 [[package]]
 name = "komorebi"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
 "bitflags 2.9.0",
 "clap",
@@ -2702,7 +2702,7 @@ dependencies = [
 "uuid",
 "which",
 "win32-display-data",
- "windows 0.61.0",
+ "windows 0.61.1",
 "windows-core 0.61.0",
 "windows-implement 0.60.0",
 "windows-interface 0.59.1",
@@ -2713,7 +2713,7 @@ dependencies = [

 [[package]]
 name = "komorebi-bar"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
 "chrono",
 "chrono-tz",
@@ -2743,14 +2743,15 @@ dependencies = [
 "sysinfo",
 "tracing",
 "tracing-subscriber",
- "windows 0.61.0",
+ "windows 0.61.1",
 "windows-core 0.61.0",
- "windows-icons",
+ "windows-icons 0.1.0 (git+https://github.com/LGUG2Z/windows-icons?rev=0c9d7ee1b807347c507d3a9862dd007b4d3f4354)",
+ "windows-icons 0.1.0 (git+https://github.com/LGUG2Z/windows-icons?rev=d67cc9920aa9b4883393e411fb4fa2ddd4c498b5)",
 ]

 [[package]]
 name = "komorebi-client"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
 "komorebi",
 "serde_json_lenient",
@@ -2759,20 +2760,20 @@ dependencies = [

 [[package]]
 name = "komorebi-gui"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
 "eframe",
 "egui_extras",
 "komorebi-client",
 "random_word",
 "serde_json_lenient",
- "windows 0.61.0",
+ "windows 0.61.1",
 "windows-core 0.61.0",
 ]

 [[package]]
 name = "komorebi-themes"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
 "base16-egui-themes",
 "catppuccin-egui",
@@ -2785,7 +2786,7 @@ dependencies = [

 [[package]]
 name = "komorebic"
-version = "0.1.35"
+version = "0.1.36"
 dependencies = [
 "chrono",
 "clap",
@@ -2806,12 +2807,12 @@ dependencies = [
 "sysinfo",
 "thiserror 2.0.12",
 "which",
- "windows 0.61.0",
+ "windows 0.61.1",
 ]

 [[package]]
 name = "komorebic-no-console"
-version = "0.1.35"
+version = "0.1.36"

 [[package]]
 name = "kqueue"
@@ -2853,9 +2854,9 @@ checksum = "03087c2bad5e1034e8cace5926dec053fb3790248370865f5117a7d0213354c8"

 [[package]]
 name = "libc"
-version = "0.2.170"
+version = "0.2.171"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "875b3680cb2f8f71bdcf9a30f38d48282f5d3c95cbf9b3fa57269bb5d5c06828"
+checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"

 [[package]]
 name = "libfuzzer-sys"
@@ -2869,9 +2870,9 @@ dependencies = [

 [[package]]
 name = "libgit2-sys"
-version = "0.18.0+1.9.0"
+version = "0.18.1+1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1a117465e7e1597e8febea8bb0c410f1c7fb93b1e1cddf34363f8390367ffec"
+checksum = "e1dcb20f84ffcdd825c7a311ae347cce604a6f084a767dec4a4929829645290e"
 dependencies = [
 "cc",
 "libc",
@@ -2902,9 +2903,9 @@ dependencies = [

 [[package]]
 name = "libz-sys"
-version = "1.1.21"
+version = "1.1.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df9b68e50e6e0b26f672573834882eb57759f6db9b3be2ea3c35c91188bb4eaa"
+checksum = "8b70e7a7df205e92a1a4cd9aaae7898dac0aa555503cc0a649494d0d60e7651d"
 dependencies = [
 "cc",
 "libc",
@@ -2920,9 +2921,9 @@ checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"

 [[package]]
 name = "linux-raw-sys"
-version = "0.9.2"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db9c683daf087dc577b7506e9695b3d556a9f3849903fa28186283afd6809e9"
+checksum = "fe7db12097d22ec582439daf8618b8fdd1a7bef6270e9af3b1ebcd30893cf413"

 [[package]]
 name = "litemap"
@@ -3759,9 +3760,9 @@ dependencies = [

 [[package]]
 name = "once_cell"
-version = "1.21.0"
+version = "1.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cde51589ab56b20a6f686b2c68f7a0bd6add753d697abf720d63f8db3ab7b1ad"
+checksum = "d75b0bedcc4fe52caa0e03d9f1151a323e4aa5e2d78ba3580400cd3c9e2bc4bc"

 [[package]]
 name = "openssl"
@@ -4088,7 +4089,7 @@ version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
 dependencies = [
- "zerocopy 0.8.23",
+ "zerocopy 0.8.24",
 ]

 [[package]]
@@ -4195,13 +4196,19 @@ dependencies = [

 [[package]]
 name = "quote"
-version = "1.0.39"
+version = "1.0.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1f1914ce909e1658d9907913b4b91947430c7d9be598b15a1912935b8c04801"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
 dependencies = [
 "proc-macro2",
 ]

+[[package]]
+name = "r-efi"
+version = "5.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+
 [[package]]
 name = "rand"
 version = "0.8.5"
@@ -4403,9 +4410,9 @@ checksum = "19b30a45b0cd0bcca8037f3d0dc3421eaf95327a17cad11964fb8179b4fc4832"

 [[package]]
 name = "reqwest"
-version = "0.12.14"
+version = "0.12.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "989e327e510263980e231de548a33e63d34962d29ae61b467389a1a09627a254"
+checksum = "d19c46a6fdd48bc4dab94b6103fccc55d34c67cc0ad04653aad4ea2a07cd7bbb"
 dependencies = [
 "base64",
 "bytes",
@@ -4454,9 +4461,9 @@ checksum = "57397d16646700483b67d2dd6511d79318f9d057fdbd21a4066aeac8b41d310a"

 [[package]]
 name = "ring"
-version = "0.17.13"
+version = "0.17.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ac5d832aa16abd7d1def883a8545280c20a60f523a370aa3a9617c2b8550ee"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
 dependencies = [
 "cc",
 "cfg-if 1.0.0",
@@ -4466,6 +4473,12 @@ dependencies = [
 "windows-sys 0.52.0",
 ]

+[[package]]
+name = "roxmltree"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
+
 [[package]]
 name = "rustc-demangle"
 version = "0.1.24"
@@ -4493,22 +4506,22 @@ dependencies = [

 [[package]]
 name = "rustix"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7178faa4b75a30e269c71e61c353ce2748cf3d76f0c44c393f4e60abf49b825"
+checksum = "e56a18552996ac8d29ecc3b190b4fdbb2d91ca4ec396de7bbffaf43f3d637e96"
 dependencies = [
 "bitflags 2.9.0",
 "errno",
 "libc",
- "linux-raw-sys 0.9.2",
+ "linux-raw-sys 0.9.3",
 "windows-sys 0.59.0",
 ]

 [[package]]
 name = "rustls"
-version = "0.23.23"
+version = "0.23.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47796c98c480fce5406ef69d1c76378375492c3b0a0de587be0c1d9feb12f395"
+checksum = "822ee9188ac4ec04a2f0531e55d035fb2de73f18b41a63c70c2712503b6fb13c"
 dependencies = [
 "once_cell",
 "rustls-pki-types",
@@ -4534,9 +4547,9 @@ checksum = "917ce264624a4b4db1c364dcc35bfca9ded014d0a958cd47ad3e960e988ea51c"

 [[package]]
 name = "rustls-webpki"
-version = "0.102.8"
+version = "0.103.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
+checksum = "0aa4eeac2588ffff23e9d7a7e9b3f971c5fb5b7ebc9452745e0c232c64f83b2f"
 dependencies = [
 "ring",
 "rustls-pki-types",
@@ -4788,9 +4801,9 @@ dependencies = [

 [[package]]
 name = "shadow-rs"
-version = "1.0.1"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3672eb035a31ac62bf171765d04e3f1f01659920847384d08ac979ca6bb56763"
+checksum = "6d5625ed609cf66d7e505e7d487aca815626dc4ebb6c0dd07637ca61a44651a6"
 dependencies = [
 "const_format",
 "git2",
@@ -5132,15 +5145,14 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"

 [[package]]
 name = "tempfile"
-version = "3.18.0"
+version = "3.19.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c317e0a526ee6120d8dabad239c8dadca62b24b6f168914bbbc8e2fb1f0e567"
+checksum = "7437ac7763b9b123ccf33c338a5cc1bac6f69b45a136c19bdd8a65e3916435bf"
 dependencies = [
- "cfg-if 1.0.0",
 "fastrand",
- "getrandom 0.3.1",
+ "getrandom 0.3.2",
 "once_cell",
- "rustix 1.0.2",
+ "rustix 1.0.3",
 "windows-sys 0.59.0",
 ]

@@ -5159,7 +5171,7 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "45c6481c4829e4cc63825e62c49186a34538b7b2750b73b266581ffb612fb5ed"
 dependencies = [
- "rustix 1.0.2",
+ "rustix 1.0.3",
 "windows-sys 0.59.0",
 ]

@@ -5246,9 +5258,9 @@ dependencies = [

 [[package]]
 name = "time"
-version = "0.3.39"
+version = "0.3.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dad298b01a40a23aac4580b67e3dbedb7cc8402f3592d7f49469de2ea4aecdd8"
+checksum = "9d9c75b47bdff86fa3334a3db91356b8d7d86a9b839dab7d0bdc5c3d3a077618"
 dependencies = [
 "deranged",
 "itoa",
@@ -5263,15 +5275,15 @@ dependencies = [

 [[package]]
 name = "time-core"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "765c97a5b985b7c11d7bc27fa927dc4fe6af3a6dfb021d28deb60d3bf51e76ef"
+checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c"

 [[package]]
 name = "time-macros"
-version = "0.2.20"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8093bc3e81c3bc5f7879de09619d06c9a5a5e45ca44dfeeb7225bae38005c5c"
+checksum = "29aa485584182073ed57fd5004aa09c371f021325014694e432313345865fd04"
 dependencies = [
 "num-conv",
 "time-core",
@@ -5314,9 +5326,9 @@ dependencies = [

 [[package]]
 name = "tokio"
-version = "1.44.0"
+version = "1.44.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9975ea0f48b5aa3972bf2d888c238182458437cc2a19374b81b25cdf1023fb3a"
+checksum = "f382da615b842244d4b8738c82ed1275e6c5dd90c459a30941cd07080b06c91a"
 dependencies = [
 "backtrace",
 "bytes",
@@ -5349,9 +5361,9 @@ dependencies = [

 [[package]]
 name = "tokio-util"
-version = "0.7.13"
+version = "0.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7fcaa8d55a2bdd6b83ace262b016eca0d79ee02818c5c1bcdf0305114081078"
+checksum = "6b9590b93e6fcc1739458317cccd391ad3955e2bde8913edf6f95f9e65a8f034"
 dependencies = [
 "bytes",
 "futures-core",
@@ -5667,7 +5679,7 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
 dependencies = [
- "getrandom 0.3.1",
+ "getrandom 0.3.2",
 ]

 [[package]]
@@ -5732,9 +5744,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

 [[package]]
 name = "wasi"
-version = "0.13.3+wasi-0.2.2"
+version = "0.14.2+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
 dependencies = [
 "wit-bindgen-rt",
 ]
@@ -5964,9 +5976,9 @@ checksum = "53a85b86a771b1c87058196170769dd264f66c0782acf1ae6cc51bfd64b39082"

 [[package]]
 name = "wgpu"
-version = "24.0.1"
+version = "24.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47f55718f85c2fa756edffa0e7f0e0a60aba463d1362b57e23123c58f035e4b6"
+checksum = "35904fb00ba2d2e0a4d002fcbbb6e1b89b574d272a50e5fc95f6e81cf281c245"
 dependencies = [
 "arrayvec",
 "bitflags 2.9.0",
@@ -6080,12 +6092,12 @@ dependencies = [
 [[package]]
 name = "win32-display-data"
 version = "0.1.0"
-source = "git+https://github.com/LGUG2Z/win32-display-data?rev=93949750b1f123fb79827ba4d66ffcab68055654#93949750b1f123fb79827ba4d66ffcab68055654"
+source = "git+https://github.com/LGUG2Z/win32-display-data?rev=a28c6559a9de2f92c142a714947a9b081776caca#a28c6559a9de2f92c142a714947a9b081776caca"
 dependencies = [
 "itertools 0.14.0",
 "serde",
 "thiserror 2.0.12",
- "windows 0.61.0",
+ "windows 0.61.1",
 "windows-core 0.60.1",
 "wmi",
 ]
@@ -6147,31 +6159,40 @@ version = "0.60.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ddf874e74c7a99773e62b1c671427abf01a425e77c3d3fb9fb1e4883ea934529"
 dependencies = [
- "windows-collections",
+ "windows-collections 0.1.1",
 "windows-core 0.60.1",
- "windows-future",
+ "windows-future 0.1.1",
 "windows-link",
 "windows-numerics 0.1.1",
 ]

 [[package]]
 name = "windows"
-version = "0.61.0"
+version = "0.61.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b76779b1008b2bafb6cdf5e299dfe7f5780d604349fe68d9476c08feb448e98f"
+checksum = "c5ee8f3d025738cb02bad7868bbb5f8a6327501e870bf51f1b455b0a2454a419"
 dependencies = [
- "windows-collections",
+ "windows-collections 0.2.0",
 "windows-core 0.61.0",
- "windows-future",
+ "windows-future 0.2.0",
 "windows-link",
 "windows-numerics 0.2.0",
 ]

 [[package]]
 name = "windows-collections"
-version = "0.1.2"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b095389c0f7a1e16ba4927c17478dca870938c7bbeb31e7f77eab4e86dc8fd1a"
+checksum = "5467f79cc1ba3f52ebb2ed41dbb459b8e7db636cc3429458d9a852e15bc24dec"
+dependencies = [
+ "windows-core 0.60.1",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
 dependencies = [
 "windows-core 0.61.0",
 ]
@@ -6238,14 +6259,38 @@ dependencies = [

 [[package]]
 name = "windows-future"
-version = "0.1.2"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbb86813135724d122c524095d1e55a72f2844b0ce6b77ef05e782dff1e6abfc"
+checksum = "a787db4595e7eb80239b74ce8babfb1363d8e343ab072f2ffe901400c03349f0"
+dependencies = [
+ "windows-core 0.60.1",
+ "windows-link",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a1d6bbefcb7b60acd19828e1bc965da6fcf18a7e39490c5f8be71e54a19ba32"
 dependencies = [
 "windows-core 0.61.0",
 "windows-link",
 ]

+[[package]]
+name = "windows-icons"
+version = "0.1.0"
+source = "git+https://github.com/LGUG2Z/windows-icons?rev=0c9d7ee1b807347c507d3a9862dd007b4d3f4354#0c9d7ee1b807347c507d3a9862dd007b4d3f4354"
+dependencies = [
+ "base64",
+ "image",
+ "regex",
+ "roxmltree",
+ "sysinfo",
+ "winapi",
+ "windows 0.58.0",
+]
+
 [[package]]
 name = "windows-icons"
 version = "0.1.0"
@@ -6758,9 +6803,9 @@ dependencies = [

 [[package]]
 name = "winnow"
-version = "0.7.3"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e7f4ea97f6f78012141bcdb6a216b2609f0979ada50b20ca5b52dde2eac2bb1"
+checksum = "0e97b544156e9bebe1a0ffbc03484fc1ffe3100cbce3ffb17eac35f7cdd7ab36"
 dependencies = [
 "memchr",
 ]
@@ -6792,9 +6837,9 @@ checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904"

 [[package]]
 name = "wit-bindgen-rt"
-version = "0.33.0"
+version = "0.39.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
 dependencies = [
 "bitflags 2.9.0",
 ]
@@ -7033,11 +7078,11 @@ dependencies = [

 [[package]]
 name = "zerocopy"
-version = "0.8.23"
+version = "0.8.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd97444d05a4328b90e75e503a34bad781f14e28a823ad3557f0750df1ebcbc6"
+checksum = "2586fea28e186957ef732a5f8b3be2da217d65c5969d4b1e17f973ebbe876879"
 dependencies = [
- "zerocopy-derive 0.8.23",
+ "zerocopy-derive 0.8.24",
 ]

 [[package]]
@@ -7053,9 +7098,9 @@ dependencies = [

 [[package]]
 name = "zerocopy-derive"
-version = "0.8.23"
+version = "0.8.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6352c01d0edd5db859a63e2605f4ea3183ddbd15e2c4a9e7d32184df75e4f154"
+checksum = "a996a8f63c5c4448cd959ac1bab0aaa3306ccfd060472f85943ee0750f0169be"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 paste = "1"
 sysinfo = "0.33"
 uds_windows = "1"
-win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "93949750b1f123fb79827ba4d66ffcab68055654" }
+win32-display-data = { git = "https://github.com/LGUG2Z/win32-display-data", rev = "a28c6559a9de2f92c142a714947a9b081776caca" }
 windows-numerics = { version = "0.2" }
 windows-implement = { version = "0.60" }
 windows-interface = { version = "0.59" }
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,6 +1,6 @@
 # Komorebi License

-Version 1.0.0
+Version 2.0.0

 ## Acceptance

@@ -13,9 +13,20 @@ your licenses.
 The licensor grants you a copyright license for the software
 to do everything you might do with the software that would
 otherwise infringe the licensor's copyright in it for any
-permitted purpose. However, you may only make changes according
+permitted purpose. However, you may only distribute the source
+code of the software according to the [Distribution License](
+#distribution-license), you may only make changes according
 to the [Changes License](#changes-license), and you may not
-distribute the software or new works based on the software.
+otherwise distribute the software or new works based on the
+software.
+
+## Distribution License
+
+The licensor grants you an additional copyright license to
+distribute copies of the source code of the software. Your
+license to distribute covers distributing the source code of
+the software with changes permitted by the [Changes License](
+#changes-license).

 ## Changes License

@@ -45,7 +56,7 @@ law. These terms do not limit them.

 These terms do not allow you to sublicense or transfer any of
 your licenses to anyone else, or prevent the licensor from
-granting licenses to anyone else.  These terms do not imply
+granting licenses to anyone else. These terms do not imply
 any other licenses.

 ## Patent Defense
@@ -63,7 +74,7 @@ violated any of these terms, or done anything with the software
 not covered by your licenses, your licenses can nonetheless
 continue if you come into full compliance with these terms,
 and take practical steps to correct past violations, within
-32 days of receiving notice.  Otherwise, all your licenses
+32 days of receiving notice. Otherwise, all your licenses
 end immediately.

 ## No Liability
@@ -88,11 +99,10 @@ organizations that have control over, are under the control of,
 or are under common control with that organization.  **Control**
 means ownership of substantially all the assets of an entity,
 or the power to direct its management and policies by vote,
-contract, or otherwise.  Control can be direct or indirect.
+contract, or otherwise. Control can be direct or indirect.

 **Your licenses** are all the licenses granted to you for the
 software under these terms.

 **Use** means anything you do with the software requiring one
 of your licenses.
-
--- a/README.md
+++ b/README.md
@@ -74,7 +74,7 @@ showcases the many awesome projects that exist in the _komorebi_ ecosystem.
 `komorebi` is [educational source
 software](https://lgug2z.com/articles/educational-source-software/).

-`komorebi` is licensed under the [Komorebi 1.0.0
+`komorebi` is licensed under the [Komorebi 2.0.0
 license](https://github.com/LGUG2Z/komorebi-license), which is a fork of the
 [PolyForm Strict 1.0.0
 license](https://polyformproject.org/licenses/strict/1.0.0). On a high level
@@ -85,7 +85,7 @@ hard-forks) based on the software.
 Anyone is free to make their own fork of `komorebi` with changes intended either
 for personal use or for integration back upstream via pull requests.

-The [Komorebi 1.0.0 License](https://github.com/LGUG2Z/komorebi-license) does
+The [Komorebi 2.0.0 License](https://github.com/LGUG2Z/komorebi-license) does
 not permit any kind of commercial use (i.e. using `komorebi` at work).

 ## Sponsorship for Personal Use
@@ -146,7 +146,8 @@ video will answer the majority of your questions.

 [@amnweb](https://github.com/amnweb) showing _komorebi_ `v0.1.28` running on Windows 11 with window borders,
 unfocused window transparency and animations enabled, using a custom status bar integrated using
-_komorebi_'s [Window Manager Event Subscriptions](https://github.com/LGUG2Z/komorebi?tab=readme-ov-file#window-manager-event-subscriptions).
+_komorebi_'
+s [Window Manager Event Subscriptions](https://github.com/LGUG2Z/komorebi?tab=readme-ov-file#window-manager-event-subscriptions).

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

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

  -a, --animation-type <ANIMATION_TYPE>
          Animation type to apply the style to. If not specified, sets global style
--- a/docs/cli/border-colour.md
+++ b/docs/cli/border-colour.md
@@ -18,7 +18,7 @@ Arguments:
 Options:
  -w, --window-kind <WINDOW_KIND>
          [default: single]
-          [possible values: single, stack, monocle, unfocused, floating]
+          [possible values: single, stack, monocle, unfocused, unfocused-locked, floating]

  -h, --help
          Print help
--- a/docs/cli/move-to-last-workspace.md
+++ b/docs/cli/move-to-last-workspace.md
@@ -0,0 +1,12 @@
+# move-to-last-workspace
+
+```
+Move the focused window to the last focused monitor workspace
+
+Usage: komorebic.exe move-to-last-workspace
+
+Options:
+  -h, --help
+          Print help
+
+```
--- a/docs/cli/send-to-last-workspace.md
+++ b/docs/cli/send-to-last-workspace.md
@@ -0,0 +1,12 @@
+# send-to-last-workspace
+
+```
+Send the focused window to the last focused monitor workspace
+
+Usage: komorebic.exe send-to-last-workspace
+
+Options:
+  -h, --help
+          Print help
+
+```
--- a/docs/cli/toggle-lock.md
+++ b/docs/cli/toggle-lock.md
@@ -0,0 +1,12 @@
+# toggle-lock
+
+```
+Toggle a lock for the focused container, ensuring it will not be displaced by any new windows
+
+Usage: komorebic.exe toggle-lock
+
+Options:
+  -h, --help
+          Print help
+
+```
--- a/docs/cli/toggle-workspace-float-override.md
+++ b/docs/cli/toggle-workspace-float-override.md
@@ -1,8 +1,8 @@
 # toggle-workspace-float-override

 ```
-Enable or disable float override, which makes it so every new window opens in floating mode, for the currently focused workspace. If there was no override value set for the workspace
-previously it takes the opposite of the global value
+Enable or disable float override, which makes it so every new window opens in floating mode, for the currently focused workspace. If there was no override value set for the workspace previously it takes
+the opposite of the global value

 Usage: komorebic.exe toggle-workspace-float-override

--- a/docs/cli/toggle-workspace-window-container-behaviour.md
+++ b/docs/cli/toggle-workspace-window-container-behaviour.md
@@ -1,8 +1,7 @@
 # toggle-workspace-window-container-behaviour

 ```
-Toggle the behaviour for new windows (stacking or dynamic tiling) for currently focused workspace. If there was no behaviour set for the workspace previously it takes the opposite of the
-global value
+Toggle the behaviour for new windows (stacking or dynamic tiling) for currently focused workspace. If there was no behaviour set for the workspace previously it takes the opposite of the global value

 Usage: komorebic.exe toggle-workspace-window-container-behaviour

--- a/docs/index.md
+++ b/docs/index.md
@@ -34,7 +34,7 @@ showcases the many awesome projects that exist in the `komorebi` ecosystem.

 ## Licensing for Personal Use

-`komorebi` is licensed under the [Komorebi 1.0.0 license](https://github.com/LGUG2Z/komorebi-license), which is a fork
+`komorebi` is licensed under the [Komorebi 2.0.0 license](https://github.com/LGUG2Z/komorebi-license), which is a fork
 of the [PolyForm Strict 1.0.0 license](https://polyformproject.org/licenses/strict/1.0.0). On a high level this means
 that you are free to do whatever you want with `komorebi` for personal use other than redistribution, or distribution of
 new works (i.e. hard-forks) based on the software.
@@ -42,7 +42,7 @@ new works (i.e. hard-forks) based on the software.
 Anyone is free to make their own fork of `komorebi` with changes intended either for personal use or for integration
 back upstream via pull requests.

-The [Komorebi 1.0.0 License](https://github.com/LGUG2Z/komorebi-license) does not permit any kind of commercial use (
+The [Komorebi 2.0.0 License](https://github.com/LGUG2Z/komorebi-license) does not permit any kind of commercial use (
 i.e. using `komorebi` at work).

 ## Sponsorship for Personal Use
--- a/docs/usage/focusing-workspaces.md
+++ b/docs/usage/focusing-workspaces.md
@@ -56,4 +56,4 @@ alt + 3                 : komorebic focus-workspaces 2
 ```

 The last focused workspace on the focused monitor can be re-focused using the [
-`komorebic focus-last-workspace`](../cli/focus-last-workspace) command.
+`komorebic focus-last-workspace`](../cli/focus-last-workspace.md) command.
--- a/docs/usage/moving-windows-across-workspaces.md
+++ b/docs/usage/moving-windows-across-workspaces.md
@@ -47,7 +47,7 @@ alt + shift + oem_6     : komorebic cycle-send-to-workspace next # oem_6 is ]
 ```

 Windows can be moved or sent to the focused workspace on a another monitor using the [
-`komorebic move-to-monitor`](../cli/move-to-monitor.md) and [`komorebic send-to-monitor`](../cli/send-to-monitor)
+`komorebic move-to-monitor`](../cli/move-to-monitor.md) and [`komorebic send-to-monitor`](../cli/send-to-monitor.md)
 commands.

 Windows can be moved or sent to the focused workspace on a monitor in a cycle direction (previous, next) using the [
@@ -56,4 +56,4 @@ Windows can be moved or sent to the focused workspace on a monitor in a cycle di

 Windows can be moved or sent to a named workspace on any monitor (given that all workspace names across all monitors are
 unique) using the [`komorebic move-to-named-workspace`](../cli/move-to-named-workspace.md) and [
-`komorebic send-to-named-workspace`](../cli/send-to-named-workspace.md) commands
+`komorebic send-to-named-workspace`](../cli/send-to-named-workspace.md) commands
--- a/komorebi-bar/Cargo.toml
+++ b/komorebi-bar/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-bar"
-version = "0.1.35"
+version = "0.1.36"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -37,7 +37,8 @@ tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 windows = { workspace = true }
 windows-core = { workspace = true }
-windows-icons = { git = "https://github.com/LGUG2Z/windows-icons", rev = "d67cc9920aa9b4883393e411fb4fa2ddd4c498b5" }
+windows-icons = { git = "https://github.com/LGUG2Z/windows-icons", rev = "0c9d7ee1b807347c507d3a9862dd007b4d3f4354" }
+windows-icons-fallback = { package = "windows-icons", git = "https://github.com/LGUG2Z/windows-icons", rev = "d67cc9920aa9b4883393e411fb4fa2ddd4c498b5" }

 [features]
 default = ["schemars"]
--- a/komorebi-bar/src/config.rs
+++ b/komorebi-bar/src/config.rs
@@ -13,7 +13,7 @@ use std::path::PathBuf;

 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-/// The `komorebi.bar.json` configuration file reference for `v0.1.35`
+/// The `komorebi.bar.json` configuration file reference for `v0.1.36`
 pub struct KomobarConfig {
    /// Bar height (default: 50)
    pub height: Option<f32>,
--- a/komorebi-bar/src/main.rs
+++ b/komorebi-bar/src/main.rs
@@ -47,7 +47,7 @@ pub static MONITOR_INDEX: AtomicUsize = AtomicUsize::new(0);
 pub static BAR_HEIGHT: f32 = 50.0;
 pub static DEFAULT_PADDING: f32 = 10.0;

-pub static ICON_CACHE: LazyLock<Mutex<HashMap<String, RgbaImage>>> =
+pub static ICON_CACHE: LazyLock<Mutex<HashMap<isize, RgbaImage>>> =
    LazyLock::new(|| Mutex::new(HashMap::new()));

 #[derive(Parser)]
--- a/komorebi-bar/src/widgets/komorebi.rs
+++ b/komorebi-bar/src/widgets/komorebi.rs
@@ -837,11 +837,16 @@ impl From<&Container> for KomorebiNotificationStateContainerInformation {
        for window in windows {
            let mut icon_cache = ICON_CACHE.lock().unwrap();
            let mut update_cache = false;
-            let exe = window.exe().unwrap_or_default();
+            let hwnd = window.hwnd;

-            match icon_cache.get(&exe) {
+            match icon_cache.get(&hwnd) {
                None => {
-                    icons.push(windows_icons::get_icon_by_process_id(window.process_id()));
+                    let icon = match windows_icons::get_icon_by_hwnd(window.hwnd) {
+                        None => windows_icons_fallback::get_icon_by_process_id(window.process_id()),
+                        Some(icon) => Some(icon),
+                    };
+
+                    icons.push(icon);
                    update_cache = true;
                }
                Some(icon) => {
@@ -851,7 +856,7 @@ impl From<&Container> for KomorebiNotificationStateContainerInformation {

            if update_cache {
                if let Some(Some(icon)) = icons.last() {
-                    icon_cache.insert(exe, icon.clone());
+                    icon_cache.insert(hwnd, icon.clone());
                }
            }
        }
@@ -873,11 +878,16 @@ impl From<&Window> for KomorebiNotificationStateContainerInformation {
        let mut icon_cache = ICON_CACHE.lock().unwrap();
        let mut update_cache = false;
        let mut icons = vec![];
-        let exe = value.exe().unwrap_or_default();
+        let hwnd = value.hwnd;

-        match icon_cache.get(&exe) {
+        match icon_cache.get(&hwnd) {
            None => {
-                icons.push(windows_icons::get_icon_by_process_id(value.process_id()));
+                let icon = match windows_icons::get_icon_by_hwnd(hwnd) {
+                    None => windows_icons_fallback::get_icon_by_process_id(value.process_id()),
+                    Some(icon) => Some(icon),
+                };
+
+                icons.push(icon);
                update_cache = true;
            }
            Some(icon) => {
@@ -887,7 +897,7 @@ impl From<&Window> for KomorebiNotificationStateContainerInformation {

        if update_cache {
            if let Some(Some(icon)) = icons.last() {
-                icon_cache.insert(exe, icon.clone());
+                icon_cache.insert(hwnd, icon.clone());
            }
        }

--- a/komorebi-client/Cargo.toml
+++ b/komorebi-client/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-client"
-version = "0.1.35"
+version = "0.1.36"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
--- a/komorebi-client/src/lib.rs
+++ b/komorebi-client/src/lib.rs
@@ -29,6 +29,7 @@ pub use komorebi::core::CustomLayout;
 pub use komorebi::core::CycleDirection;
 pub use komorebi::core::DefaultLayout;
 pub use komorebi::core::Direction;
+pub use komorebi::core::FloatingLayerBehaviour;
 pub use komorebi::core::FocusFollowsMouseImplementation;
 pub use komorebi::core::HidingBehaviour;
 pub use komorebi::core::Layout;
@@ -46,6 +47,7 @@ pub use komorebi::core::WindowKind;
 pub use komorebi::monitor::Monitor;
 pub use komorebi::monitor_reconciliator::MonitorNotification;
 pub use komorebi::ring::Ring;
+pub use komorebi::win32_display_data;
 pub use komorebi::window::Window;
 pub use komorebi::window_manager_event::WindowManagerEvent;
 pub use komorebi::workspace::Workspace;
--- a/komorebi-gui/Cargo.toml
+++ b/komorebi-gui/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebi-gui"
-version = "0.1.35"
+version = "0.1.36"
 edition = "2021"

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

 [dependencies]
--- a/komorebi/Cargo.toml
+++ b/komorebi/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebi"
-version = "0.1.35"
+version = "0.1.36"
 description = "A tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"
--- a/komorebi/src/border_manager/border.rs
+++ b/komorebi/src/border_manager/border.rs
@@ -272,6 +272,7 @@ impl Border {
                    WindowKind::Monocle,
                    WindowKind::Unfocused,
                    WindowKind::Floating,
+                    WindowKind::UnfocusedLocked,
                ] {
                    let color = window_kind_colour(window_kind);
                    let color = D2D1_COLOR_F {
--- a/komorebi/src/border_manager/mod.rs
+++ b/komorebi/src/border_manager/mod.rs
@@ -7,7 +7,6 @@ use crate::core::WindowKind;
 use crate::ring::Ring;
 use crate::windows_api;
 use crate::workspace::WorkspaceLayer;
-use crate::workspace_reconciliator::ALT_TAB_HWND;
 use crate::Colour;
 use crate::Rgb;
 use crate::WindowManager;
@@ -48,6 +47,8 @@ lazy_static! {
        AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(66, 165, 245))));
    pub static ref UNFOCUSED: AtomicU32 =
        AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(128, 128, 128))));
+    pub static ref UNFOCUSED_LOCKED: AtomicU32 =
+        AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(158, 8, 8))));
    pub static ref MONOCLE: AtomicU32 =
        AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(255, 51, 153))));
    pub static ref STACK: AtomicU32 = AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(0, 165, 66))));
@@ -149,6 +150,7 @@ pub fn destroy_all_borders() -> color_eyre::Result<()> {
 fn window_kind_colour(focus_kind: WindowKind) -> u32 {
    match focus_kind {
        WindowKind::Unfocused => UNFOCUSED.load(Ordering::Relaxed),
+        WindowKind::UnfocusedLocked => UNFOCUSED_LOCKED.load(Ordering::Relaxed),
        WindowKind::Single => FOCUSED.load(Ordering::Relaxed),
        WindowKind::Stack => STACK.load(Ordering::Relaxed),
        WindowKind::Monocle => MONOCLE.load(Ordering::Relaxed),
@@ -229,7 +231,11 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                            let window_kind = if idx != ws.focused_container_idx()
                                || monitor_idx != focused_monitor_idx
                            {
-                                WindowKind::Unfocused
+                                if ws.locked_containers().contains(&idx) {
+                                    WindowKind::UnfocusedLocked
+                                } else {
+                                    WindowKind::Unfocused
+                                }
                            } else if c.windows().len() > 1 {
                                WindowKind::Stack
                            } else {
@@ -326,8 +332,6 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                if !BORDER_ENABLED.load_consume()
                    // Or if the wm is paused
                    || is_paused
-                    // Or if we are handling an alt-tab across workspaces
-                    || ALT_TAB_HWND.load().is_some()
                {
                    // Destroy the borders we know about
                    for (_, border) in borders.drain() {
@@ -493,7 +497,11 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                                || monitor_idx != focused_monitor_idx
                                || focused_window_hwnd != foreground_window
                            {
-                                WindowKind::Unfocused
+                                if ws.locked_containers().contains(&idx) {
+                                    WindowKind::UnfocusedLocked
+                                } else {
+                                    WindowKind::Unfocused
+                                }
                            } else if c.windows().len() > 1 {
                                WindowKind::Stack
                            } else {
--- a/komorebi/src/core/mod.rs
+++ b/komorebi/src/core/mod.rs
@@ -62,6 +62,8 @@ pub enum SocketMessage {
    UnstackAll,
    ResizeWindowEdge(OperationDirection, Sizing),
    ResizeWindowAxis(Axis, Sizing),
+    MoveContainerToLastWorkspace,
+    SendContainerToLastWorkspace,
    MoveContainerToMonitorNumber(usize),
    CycleMoveContainerToMonitor(CycleDirection),
    MoveContainerToWorkspaceNumber(usize),
@@ -84,6 +86,9 @@ pub enum SocketMessage {
    PromoteFocus,
    PromoteWindow(OperationDirection),
    EagerFocus(String),
+    LockMonitorWorkspaceContainer(usize, usize, usize),
+    UnlockMonitorWorkspaceContainer(usize, usize, usize),
+    ToggleLock,
    ToggleFloat,
    ToggleMonocle,
    ToggleMaximize,
@@ -312,6 +317,7 @@ pub enum WindowKind {
    Monocle,
    #[default]
    Unfocused,
+    UnfocusedLocked,
    Floating,
 }

@@ -372,6 +378,18 @@ pub enum WindowContainerBehaviour {
    Append,
 }

+#[derive(
+    Clone, Copy, Debug, Default, Serialize, Deserialize, Display, EnumString, ValueEnum, PartialEq,
+)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+pub enum FloatingLayerBehaviour {
+    /// Tile new windows (unless they match a float rule)
+    #[default]
+    Tile,
+    /// Float new windows
+    Float,
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize, Display, EnumString, ValueEnum)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 pub enum MoveBehaviour {
--- a/komorebi/src/lib.rs
+++ b/komorebi/src/lib.rs
@@ -9,6 +9,7 @@ pub mod colour;
 pub mod container;
 pub mod core;
 pub mod focus_manager;
+pub mod locked_deque;
 pub mod monitor;
 pub mod monitor_reconciliator;
 pub mod process_command;
@@ -29,7 +30,6 @@ pub mod windows_callbacks;
 pub mod winevent;
 pub mod winevent_listener;
 pub mod workspace;
-pub mod workspace_reconciliator;

 use lazy_static::lazy_static;
 use monitor_reconciliator::MonitorNotification;
@@ -52,6 +52,7 @@ pub use core::*;
 pub use process_command::*;
 pub use process_event::*;
 pub use static_config::*;
+pub use win32_display_data;
 pub use window::*;
 pub use window_manager::*;
 pub use window_manager_event::*;
--- a/komorebi/src/locked_deque.rs
+++ b/komorebi/src/locked_deque.rs
@@ -0,0 +1,316 @@
+use std::collections::BTreeSet;
+use std::collections::VecDeque;
+
+pub struct LockedDeque<'a, T> {
+    deque: &'a mut VecDeque<T>,
+    locked_indices: &'a mut BTreeSet<usize>,
+}
+
+impl<'a, T: PartialEq> LockedDeque<'a, T> {
+    pub fn new(deque: &'a mut VecDeque<T>, locked_indices: &'a mut BTreeSet<usize>) -> Self {
+        Self {
+            deque,
+            locked_indices,
+        }
+    }
+
+    pub fn insert(&mut self, index: usize, value: T) -> usize {
+        insert_respecting_locks(self.deque, self.locked_indices, index, value)
+    }
+
+    pub fn remove(&mut self, index: usize) -> Option<T> {
+        remove_respecting_locks(self.deque, self.locked_indices, index)
+    }
+}
+
+pub fn insert_respecting_locks<T>(
+    deque: &mut VecDeque<T>,
+    locked_idx: &mut BTreeSet<usize>,
+    idx: usize,
+    value: T,
+) -> usize {
+    if idx == deque.len() {
+        deque.push_back(value);
+        return idx;
+    }
+
+    let mut new_deque = VecDeque::with_capacity(deque.len() + 1);
+    let mut temp_locked_deque = VecDeque::new();
+    let mut j = 0;
+    let mut corrected_idx = idx;
+
+    for (i, el) in deque.drain(..).enumerate() {
+        if i == idx {
+            corrected_idx = j;
+        }
+        if locked_idx.contains(&i) {
+            temp_locked_deque.push_back(el);
+        } else {
+            new_deque.push_back(el);
+            j += 1;
+        }
+    }
+
+    new_deque.insert(corrected_idx, value);
+
+    for (locked_el, locked_idx) in temp_locked_deque.into_iter().zip(locked_idx.iter()) {
+        new_deque.insert(*locked_idx, locked_el);
+        if *locked_idx <= corrected_idx {
+            corrected_idx += 1;
+        }
+    }
+
+    *deque = new_deque;
+
+    corrected_idx
+}
+
+pub fn remove_respecting_locks<T>(
+    deque: &mut VecDeque<T>,
+    locked_idx: &mut BTreeSet<usize>,
+    idx: usize,
+) -> Option<T> {
+    if idx >= deque.len() {
+        return None;
+    }
+
+    let final_size = deque.len() - 1;
+
+    let mut new_deque = VecDeque::with_capacity(final_size);
+    let mut temp_locked_deque = VecDeque::new();
+    let mut removed = None;
+    let mut removed_locked_idx = None;
+
+    for (i, el) in deque.drain(..).enumerate() {
+        if i == idx {
+            removed = Some(el);
+            removed_locked_idx = locked_idx.contains(&i).then_some(i);
+        } else if locked_idx.contains(&i) {
+            temp_locked_deque.push_back(el);
+        } else {
+            new_deque.push_back(el);
+        }
+    }
+
+    if let Some(i) = removed_locked_idx {
+        let mut above = locked_idx.split_off(&i);
+        above.pop_first();
+        locked_idx.extend(above.into_iter().map(|i| i - 1));
+    }
+
+    while locked_idx.last().is_some_and(|i| *i >= final_size) {
+        locked_idx.pop_last();
+    }
+
+    let extra_invalid_idx = (new_deque.len()
+        ..(new_deque.len() + temp_locked_deque.len() - locked_idx.len()))
+        .collect::<Vec<_>>();
+
+    for (locked_el, locked_idx) in temp_locked_deque
+        .into_iter()
+        .zip(locked_idx.iter().chain(extra_invalid_idx.iter()))
+    {
+        new_deque.insert(*locked_idx, locked_el);
+    }
+
+    *deque = new_deque;
+
+    removed
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::BTreeSet;
+    use std::collections::VecDeque;
+
+    #[test]
+    fn test_insert_respecting_locks() {
+        // Test case 1: Basic insertion with locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            // Insert at index 0, should shift elements while keeping index 2 locked
+            insert_respecting_locks(&mut deque, &mut locked, 0, 99);
+            assert_eq!(deque, VecDeque::from(vec![99, 0, 2, 1, 3, 4]));
+            // Element '2' remains at index 2, element '1' that was at index 1 is now at index 3
+        }
+
+        // Test case 2: Insert at a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            // Try to insert at locked index 2, should insert at index 3 instead
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 2, 99);
+            assert_eq!(actual_index, 3);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 99, 3, 4]));
+        }
+
+        // Test case 3: Multiple locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(1); // Lock index 1
+            locked.insert(3); // Lock index 3
+
+            // Insert at index 0, should maintain locked indices
+            insert_respecting_locks(&mut deque, &mut locked, 0, 99);
+            assert_eq!(deque, VecDeque::from(vec![99, 1, 0, 3, 2, 4]));
+            // Elements '1' and '3' remain at indices 1 and 3
+        }
+
+        // Test case 4: Insert at end
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            // Insert at end of deque
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 5, 99);
+            assert_eq!(actual_index, 5);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3, 4, 99]));
+        }
+
+        // Test case 5: Empty deque
+        {
+            let mut deque = VecDeque::new();
+            let mut locked = BTreeSet::new();
+
+            // Insert into empty deque
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 0, 99);
+            assert_eq!(actual_index, 0);
+            assert_eq!(deque, VecDeque::from(vec![99]));
+        }
+
+        // Test case 6: All indices locked
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            for i in 0..5 {
+                locked.insert(i); // Lock all indices
+            }
+
+            // Try to insert at index 2, should insert at the end
+            let actual_index = insert_respecting_locks(&mut deque, &mut locked, 2, 99);
+            assert_eq!(actual_index, 5);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3, 4, 99]));
+        }
+
+        // Test case 7: Consecutive locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+            locked.insert(3); // Lock index 3
+
+            // Insert at index 1, should maintain consecutive locked indices
+            insert_respecting_locks(&mut deque, &mut locked, 1, 99);
+            assert_eq!(deque, VecDeque::from(vec![0, 99, 2, 3, 1, 4]));
+            // Elements '2' and '3' remain at indices 2 and 3
+        }
+    }
+
+    #[test]
+    fn test_remove_respecting_locks() {
+        // Test case 1: Remove a non-locked index before a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 0);
+            assert_eq!(removed, Some(0));
+            assert_eq!(deque, VecDeque::from(vec![1, 3, 2, 4]));
+            assert!(locked.contains(&2)); // Index 2 should still be locked
+        }
+
+        // Test case 2: Remove a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 2);
+            assert_eq!(removed, Some(2));
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 3, 4]));
+            assert!(!locked.contains(&2)); // Index 2 should be unlocked
+        }
+
+        // Test case 3: Remove an index after a locked index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(1); // Lock index 1
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 3);
+            assert_eq!(removed, Some(3));
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 4]));
+            assert!(locked.contains(&1)); // Index 1 should still be locked
+        }
+
+        // Test case 4: Multiple locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(1); // Lock index 1
+            locked.insert(3); // Lock index 3
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 0);
+            assert_eq!(removed, Some(0));
+            assert_eq!(deque, VecDeque::from(vec![2, 1, 4, 3]));
+            assert!(locked.contains(&1) && locked.contains(&3)); // Both indices should still be locked
+        }
+
+        // Test case 5: Remove the last element
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 4);
+            assert_eq!(removed, Some(4));
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3]));
+            assert!(locked.contains(&2)); // Index 2 should still be locked
+        }
+
+        // Test case 6: Invalid index
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 10);
+            assert_eq!(removed, None);
+            assert_eq!(deque, VecDeque::from(vec![0, 1, 2, 3, 4])); // Deque unchanged
+            assert!(locked.contains(&2)); // Lock unchanged
+        }
+
+        // Test case 7: Remove enough elements to make a locked index invalid
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+
+            remove_respecting_locks(&mut deque, &mut locked, 0);
+            assert_eq!(deque, VecDeque::from(vec![1, 2]));
+            assert!(!locked.contains(&2)); // Index 2 should now be invalid
+        }
+
+        // Test case 8: Removing an element before multiple locked indices
+        {
+            let mut deque = VecDeque::from(vec![0, 1, 2, 3, 4, 5]);
+            let mut locked = BTreeSet::new();
+            locked.insert(2); // Lock index 2
+            locked.insert(4); // Lock index 4
+
+            let removed = remove_respecting_locks(&mut deque, &mut locked, 1);
+            assert_eq!(removed, Some(1));
+            assert_eq!(deque, VecDeque::from(vec![0, 3, 2, 5, 4]));
+            assert!(locked.contains(&2) && locked.contains(&4)); // Both indices should still be locked
+        }
+    }
+}
--- a/komorebi/src/main.rs
+++ b/komorebi/src/main.rs
@@ -16,6 +16,7 @@ use std::sync::Arc;
 use std::time::Duration;

 use clap::Parser;
+use clap::ValueEnum;
 use color_eyre::Result;
 use crossbeam_utils::Backoff;
 use komorebi::animation::AnimationEngine;
@@ -24,6 +25,7 @@ use komorebi::animation::ANIMATION_ENABLED_PER_ANIMATION;
 #[cfg(feature = "deadlock_detection")]
 use parking_lot::deadlock;
 use parking_lot::Mutex;
+use serde::Deserialize;
 use sysinfo::Process;
 use sysinfo::ProcessesToUpdate;
 use tracing_appender::non_blocking::WorkerGuard;
@@ -48,7 +50,6 @@ use komorebi::window_manager::State;
 use komorebi::window_manager::WindowManager;
 use komorebi::windows_api::WindowsApi;
 use komorebi::winevent_listener;
-use komorebi::workspace_reconciliator;
 use komorebi::CUSTOM_FFM;
 use komorebi::DATA_DIR;
 use komorebi::HOME_DIR;
@@ -57,7 +58,7 @@ use komorebi::SESSION_ID;

 shadow_rs::shadow!(build);

-fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
+fn setup(log_level: LogLevel) -> Result<(WorkerGuard, WorkerGuard)> {
    if std::env::var("RUST_LIB_BACKTRACE").is_err() {
        std::env::set_var("RUST_LIB_BACKTRACE", "1");
    }
@@ -65,7 +66,16 @@ fn setup() -> Result<(WorkerGuard, WorkerGuard)> {
    color_eyre::install()?;

    if std::env::var("RUST_LOG").is_err() {
-        std::env::set_var("RUST_LOG", "info");
+        std::env::set_var(
+            "RUST_LOG",
+            match log_level {
+                LogLevel::Error => "error",
+                LogLevel::Warn => "warn",
+                LogLevel::Info => "info",
+                LogLevel::Debug => "debug",
+                LogLevel::Trace => "trace",
+            },
+        );
    }

    let appender = tracing_appender::rolling::daily(std::env::temp_dir(), "komorebi_plaintext.log");
@@ -143,6 +153,17 @@ fn detect_deadlocks() {
    });
 }

+#[derive(Default, Deserialize, ValueEnum, Clone)]
+#[serde(rename_all = "snake_case")]
+enum LogLevel {
+    Error,
+    Warn,
+    #[default]
+    Info,
+    Debug,
+    Trace,
+}
+
 #[derive(Parser)]
 #[clap(author, about, version = build::CLAP_LONG_VERSION)]
 struct Opts {
@@ -161,6 +182,9 @@ struct Opts {
    /// Do not attempt to auto-apply a dumped state temp file from a previously running instance of komorebi
    #[clap(long)]
    clean_state: bool,
+    /// Level of log output verbosity
+    #[clap(long, value_enum, default_value_t=LogLevel::Info)]
+    log_level: LogLevel,
 }

 #[tracing::instrument]
@@ -198,7 +222,7 @@ fn main() -> Result<()> {
    }

    // File logging worker guard has to have an assignment in the main fn to work
-    let (_guard, _color_guard) = setup()?;
+    let (_guard, _color_guard) = setup(opts.log_level)?;

    WindowsApi::foreground_lock_timeout()?;

@@ -278,7 +302,6 @@ fn main() -> Result<()> {
    border_manager::listen_for_notifications(wm.clone());
    stackbar_manager::listen_for_notifications(wm.clone());
    transparency_manager::listen_for_notifications(wm.clone());
-    workspace_reconciliator::listen_for_notifications(wm.clone());
    monitor_reconciliator::listen_for_notifications(wm.clone())?;
    reaper::listen_for_notifications(wm.clone(), wm.lock().known_hwnds.clone());
    focus_manager::listen_for_notifications(wm.clone());
--- a/komorebi/src/monitor.rs
+++ b/komorebi/src/monitor.rs
@@ -370,20 +370,20 @@ impl Monitor {
            .position(|w| w.hwnd == foreground_hwnd);

        if let Some(idx) = floating_window_index {
-            let window = workspace.floating_windows_mut().remove(idx);
+            if let Some(window) = workspace.floating_windows_mut().remove(idx) {
+                let workspaces = self.workspaces_mut();
+                #[allow(clippy::option_if_let_else)]
+                let target_workspace = match workspaces.get_mut(target_workspace_idx) {
+                    None => {
+                        workspaces.resize(target_workspace_idx + 1, Workspace::default());
+                        workspaces.get_mut(target_workspace_idx).unwrap()
+                    }
+                    Some(workspace) => workspace,
+                };

-            let workspaces = self.workspaces_mut();
-            #[allow(clippy::option_if_let_else)]
-            let target_workspace = match workspaces.get_mut(target_workspace_idx) {
-                None => {
-                    workspaces.resize(target_workspace_idx + 1, Workspace::default());
-                    workspaces.get_mut(target_workspace_idx).unwrap()
-                }
-                Some(workspace) => workspace,
-            };
-
-            target_workspace.floating_windows_mut().push(window);
-            target_workspace.set_layer(WorkspaceLayer::Floating);
+                target_workspace.floating_windows_mut().push_back(window);
+                target_workspace.set_layer(WorkspaceLayer::Floating);
+            }
        } else {
            let container = workspace
                .remove_focused_container()
--- a/komorebi/src/monitor_reconciliator/mod.rs
+++ b/komorebi/src/monitor_reconciliator/mod.rs
@@ -29,7 +29,7 @@ use std::sync::OnceLock;

 pub mod hidden;

-#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
+#[derive(Debug, Copy, Clone, Serialize, Deserialize, PartialEq)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
 #[serde(tag = "type", content = "content")]
 pub enum MonitorNotification {
@@ -84,10 +84,12 @@ pub fn insert_in_monitor_cache(serial_or_device_id: &str, monitor: Monitor) {
    monitor_cache.insert(preferred_id, monitor);
 }

-pub fn attached_display_devices() -> color_eyre::Result<Vec<Monitor>> {
-    let all_displays = win32_display_data::connected_displays_all()
-        .flatten()
-        .collect::<Vec<_>>();
+pub fn attached_display_devices<F, I>(display_provider: F) -> color_eyre::Result<Vec<Monitor>>
+where
+    F: Fn() -> I + Copy,
+    I: Iterator<Item = Result<win32_display_data::Device, win32_display_data::Error>>,
+{
+    let all_displays = display_provider().flatten().collect::<Vec<_>>();

    let mut serial_id_map = HashMap::new();

@@ -154,7 +156,7 @@ pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Re
    tracing::info!("created hidden window to listen for monitor-related events");

    std::thread::spawn(move || loop {
-        match handle_notifications(wm.clone()) {
+        match handle_notifications(wm.clone(), win32_display_data::connected_displays_all) {
            Ok(()) => {
                tracing::warn!("restarting finished thread");
            }
@@ -171,7 +173,14 @@ pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Re
    Ok(())
 }

-pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
+pub fn handle_notifications<F, I>(
+    wm: Arc<Mutex<WindowManager>>,
+    display_provider: F,
+) -> color_eyre::Result<()>
+where
+    F: Fn() -> I + Copy,
+    I: Iterator<Item = Result<win32_display_data::Device, win32_display_data::Error>>,
+{
    tracing::info!("listening");

    let receiver = event_rx();
@@ -296,7 +305,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                let initial_monitor_count = wm.monitors().len();

                // Get the currently attached display devices
-                let attached_devices = attached_display_devices()?;
+                let attached_devices = attached_display_devices(display_provider)?;

                // Make sure that in our state any attached displays have the latest Win32 data
                for monitor in wm.monitors_mut() {
@@ -718,3 +727,304 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result

    Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::window_manager_event::WindowManagerEvent;
+    use crossbeam_channel::bounded;
+    use crossbeam_channel::Sender;
+    use std::path::PathBuf;
+    use uuid::Uuid;
+    use windows::Win32::Devices::Display::DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY;
+    // NOTE: Using RECT instead of RECT since I get a mismatched type error. Can be updated if
+    // needed.
+    use windows::Win32::Foundation::RECT;
+
+    // Creating a Mock Display Provider
+    #[derive(Clone)]
+    struct MockDevice {
+        hmonitor: isize,
+        device_path: String,
+        device_name: String,
+        device_description: String,
+        serial_number_id: Option<String>,
+        size: RECT,
+        work_area_size: RECT,
+        device_key: String,
+        output_technology: Option<DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY>,
+    }
+
+    impl From<MockDevice> for win32_display_data::Device {
+        fn from(mock: MockDevice) -> Self {
+            win32_display_data::Device {
+                hmonitor: mock.hmonitor,
+                device_path: mock.device_path,
+                device_name: mock.device_name,
+                device_description: mock.device_description,
+                serial_number_id: mock.serial_number_id,
+                size: mock.size,
+                work_area_size: mock.work_area_size,
+                device_key: mock.device_key,
+                output_technology: mock.output_technology,
+            }
+        }
+    }
+
+    // Creating a Window Manager Instance
+    struct TestContext {
+        socket_path: Option<PathBuf>,
+    }
+
+    impl Drop for TestContext {
+        fn drop(&mut self) {
+            if let Some(socket_path) = &self.socket_path {
+                // Clean up the socket file
+                if let Err(e) = std::fs::remove_file(socket_path) {
+                    tracing::warn!("Failed to remove socket file: {}", e);
+                }
+            }
+        }
+    }
+
+    fn setup_window_manager() -> (WindowManager, TestContext) {
+        let (_sender, receiver): (Sender<WindowManagerEvent>, Receiver<WindowManagerEvent>) =
+            bounded(1);
+
+        // Temporary socket path for testing
+        let socket_name = format!("komorebi-test-{}.sock", Uuid::new_v4());
+        let socket_path = PathBuf::from(socket_name);
+
+        // Create a new WindowManager instance
+        let wm = match WindowManager::new(receiver, Some(socket_path.clone())) {
+            Ok(manager) => manager,
+            Err(e) => {
+                panic!("Failed to create WindowManager: {}", e);
+            }
+        };
+
+        (
+            wm,
+            TestContext {
+                socket_path: Some(socket_path),
+            },
+        )
+    }
+
+    #[test]
+    fn test_send_notification() {
+        // Create a monitor notification
+        let notification = MonitorNotification::ResolutionScalingChanged;
+
+        // Use the send_notification function to send the notification
+        send_notification(notification);
+
+        // Receive the notification from the channel
+        let received = event_rx().try_recv();
+
+        // Check if we received the notification and if it matches what we sent
+        match received {
+            Ok(notification) => {
+                assert_eq!(notification, MonitorNotification::ResolutionScalingChanged);
+            }
+            Err(e) => panic!("Failed to receive MonitorNotification: {}", e),
+        }
+    }
+
+    #[test]
+    fn test_channel_bounded_capacity() {
+        let (_, receiver) = channel();
+
+        // Fill the channel to its capacity (20 messages)
+        for _ in 0..20 {
+            send_notification(MonitorNotification::WorkAreaChanged);
+        }
+
+        // Attempt to send another message (should be dropped)
+        send_notification(MonitorNotification::ResolutionScalingChanged);
+
+        // Verify the channel contains only the first 20 messages
+        for _ in 0..20 {
+            let notification = match receiver.try_recv() {
+                Ok(notification) => notification,
+                Err(e) => panic!("Failed to receive MonitorNotification: {}", e),
+            };
+            assert_eq!(
+                notification,
+                MonitorNotification::WorkAreaChanged,
+                "Unexpected notification in the channel"
+            );
+        }
+
+        // Verify that no additional messages are in the channel
+        assert!(
+            receiver.try_recv().is_err(),
+            "Channel should be empty after consuming all messages"
+        );
+    }
+
+    #[test]
+    fn test_insert_in_monitor_cache() {
+        let m = monitor::new(
+            0,
+            Rect::default(),
+            Rect::default(),
+            "Test Monitor".to_string(),
+            "Test Device".to_string(),
+            "Test Device ID".to_string(),
+            Some("TestMonitorID".to_string()),
+        );
+
+        // Insert the monitor into the cache
+        insert_in_monitor_cache("TestMonitorID", m.clone());
+
+        // Retrieve the monitor from the cache
+        let cache = MONITOR_CACHE
+            .get_or_init(|| Mutex::new(HashMap::new()))
+            .lock();
+        let retrieved_monitor = cache.get("TestMonitorID");
+
+        // Check that the monitor was inserted correctly and matches the expected value
+        assert_eq!(retrieved_monitor, Some(&m));
+    }
+
+    #[test]
+    fn test_insert_two_monitors_cache() {
+        let m1 = monitor::new(
+            0,
+            Rect::default(),
+            Rect::default(),
+            "Test Monitor".to_string(),
+            "Test Device".to_string(),
+            "Test Device ID".to_string(),
+            Some("TestMonitorID".to_string()),
+        );
+
+        let m2 = monitor::new(
+            0,
+            Rect::default(),
+            Rect::default(),
+            "Test Monitor 2".to_string(),
+            "Test Device 2".to_string(),
+            "Test Device ID 2".to_string(),
+            Some("TestMonitorID2".to_string()),
+        );
+
+        // Insert the first monitor into the cache
+        insert_in_monitor_cache("TestMonitorID", m1.clone());
+
+        // Insert the second monitor into the cache
+        insert_in_monitor_cache("TestMonitorID2", m2.clone());
+
+        // Retrieve the cache to check if the first and second monitors are present
+        let cache = MONITOR_CACHE
+            .get_or_init(|| Mutex::new(HashMap::new()))
+            .lock();
+
+        // Check if Monitor 1 was found in the cache
+        assert_eq!(
+            cache.get("TestMonitorID"),
+            Some(&m1),
+            "Monitor cache should contain monitor 1"
+        );
+
+        // Check if Monitor 2 was found in the cache
+        assert_eq!(
+            cache.get("TestMonitorID2"),
+            Some(&m2),
+            "Monitor cache should contain monitor 2"
+        );
+    }
+
+    #[test]
+    fn test_listen_for_notifications() {
+        // Create a WindowManager instance for testing
+        let (wm, _test_context) = setup_window_manager();
+
+        // Start the notification listener
+        let result = listen_for_notifications(Arc::new(Mutex::new(wm)));
+
+        // Check if the listener started successfully
+        assert!(result.is_ok(), "Failed to start notification listener");
+
+        // Test sending a notification
+        send_notification(MonitorNotification::DisplayConnectionChange);
+
+        // Receive the notification from the channel
+        let received = event_rx().try_recv();
+
+        // Check if we received the notification and if it matches what we sent
+        match received {
+            Ok(notification) => {
+                assert_eq!(notification, MonitorNotification::DisplayConnectionChange);
+            }
+            Err(e) => panic!("Failed to receive MonitorNotification: {}", e),
+        }
+    }
+
+    #[test]
+    fn test_attached_display_devices() {
+        // Define mock display data
+        let mock_monitor = MockDevice {
+            hmonitor: 1,
+            device_path: String::from(
+                "\\\\?\\DISPLAY#ABC123#4&123456&0&UID0#{saucepackets-4321-5678-2468-abc123456789}",
+            ),
+            device_name: String::from("\\\\.\\DISPLAY1"),
+            device_description: String::from("Display description"),
+            serial_number_id: Some(String::from("SaucePackets123")),
+            device_key: String::from("Mock Key"),
+            size: RECT {
+                left: 0,
+                top: 0,
+                right: 1920,
+                bottom: 1080,
+            },
+            work_area_size: RECT {
+                left: 0,
+                top: 0,
+                right: 1920,
+                bottom: 1080,
+            },
+            output_technology: Some(DISPLAYCONFIG_VIDEO_OUTPUT_TECHNOLOGY(0)),
+        };
+
+        // Create a closure to simulate the display provider
+        let display_provider = || {
+            vec![Ok::<win32_display_data::Device, win32_display_data::Error>(
+                win32_display_data::Device::from(mock_monitor.clone()),
+            )]
+            .into_iter()
+        };
+
+        // Should contain the mock monitor
+        let result = attached_display_devices(display_provider).ok();
+        if let Some(monitors) = result {
+            // Check Number of monitors
+            assert_eq!(monitors.len(), 1, "Expected one monitor");
+
+            // hmonitor
+            assert_eq!(monitors[0].id(), 1);
+
+            // device name
+            assert_eq!(monitors[0].name(), &String::from("DISPLAY1"));
+
+            // Device
+            assert_eq!(monitors[0].device(), &String::from("ABC123"));
+
+            // Device ID
+            assert_eq!(
+                monitors[0].device_id(),
+                &String::from("ABC123-4&123456&0&UID0")
+            );
+
+            // Check monitor serial number id
+            assert_eq!(
+                monitors[0].serial_number_id,
+                Some(String::from("SaucePackets123")),
+            );
+        } else {
+            panic!("No monitors found");
+        }
+    }
+}
--- a/komorebi/src/process_command.rs
+++ b/komorebi/src/process_command.rs
@@ -1,4 +1,5 @@
 use color_eyre::eyre::anyhow;
+use color_eyre::eyre::OptionExt;
 use color_eyre::Result;
 use miow::pipe::connect;
 use net2::TcpStreamExt;
@@ -359,6 +360,41 @@ impl WindowManager {
            SocketMessage::Minimize => {
                Window::from(WindowsApi::foreground_window()?).minimize();
            }
+            SocketMessage::LockMonitorWorkspaceContainer(
+                monitor_idx,
+                workspace_idx,
+                container_idx,
+            ) => {
+                let monitor = self
+                    .monitors_mut()
+                    .get_mut(monitor_idx)
+                    .ok_or_eyre("no monitor at the given index")?;
+
+                let workspace = monitor
+                    .workspaces_mut()
+                    .get_mut(workspace_idx)
+                    .ok_or_eyre("no workspace at the given index")?;
+
+                workspace.locked_containers.insert(container_idx);
+            }
+            SocketMessage::UnlockMonitorWorkspaceContainer(
+                monitor_idx,
+                workspace_idx,
+                container_idx,
+            ) => {
+                let monitor = self
+                    .monitors_mut()
+                    .get_mut(monitor_idx)
+                    .ok_or_eyre("no monitor at the given index")?;
+
+                let workspace = monitor
+                    .workspaces_mut()
+                    .get_mut(workspace_idx)
+                    .ok_or_eyre("no workspace at the given index")?;
+
+                workspace.locked_containers.remove(&container_idx);
+            }
+            SocketMessage::ToggleLock => self.toggle_lock()?,
            SocketMessage::ToggleFloat => self.toggle_float()?,
            SocketMessage::ToggleMonocle => self.toggle_monocle()?,
            SocketMessage::ToggleMaximize => self.toggle_maximize()?,
@@ -604,6 +640,67 @@ impl WindowManager {
            SocketMessage::AdjustWorkspacePadding(sizing, adjustment) => {
                self.adjust_workspace_padding(sizing, adjustment)?;
            }
+            SocketMessage::MoveContainerToLastWorkspace => {
+                // This is to ensure that even on an empty workspace on a secondary monitor, the
+                // secondary monitor where the cursor is focused will be used as the target for
+                // the workspace switch op
+                if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
+                    if monitor_idx != self.focused_monitor_idx() {
+                        if let Some(monitor) = self.monitors().get(monitor_idx) {
+                            if let Some(workspace) = monitor.focused_workspace() {
+                                if workspace.is_empty() {
+                                    self.focus_monitor(monitor_idx)?;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                let idx = self
+                    .focused_monitor()
+                    .ok_or_else(|| anyhow!("there is no monitor"))?
+                    .focused_workspace_idx();
+
+                if let Some(monitor) = self.focused_monitor_mut() {
+                    if let Some(last_focused_workspace) = monitor.last_focused_workspace() {
+                        self.move_container_to_workspace(last_focused_workspace, true, None)?;
+                    }
+                }
+
+                self.focused_monitor_mut()
+                    .ok_or_else(|| anyhow!("there is no monitor"))?
+                    .set_last_focused_workspace(Option::from(idx));
+            }
+            SocketMessage::SendContainerToLastWorkspace => {
+                // This is to ensure that even on an empty workspace on a secondary monitor, the
+                // secondary monitor where the cursor is focused will be used as the target for
+                // the workspace switch op
+                if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
+                    if monitor_idx != self.focused_monitor_idx() {
+                        if let Some(monitor) = self.monitors().get(monitor_idx) {
+                            if let Some(workspace) = monitor.focused_workspace() {
+                                if workspace.is_empty() {
+                                    self.focus_monitor(monitor_idx)?;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                let idx = self
+                    .focused_monitor()
+                    .ok_or_else(|| anyhow!("there is no monitor"))?
+                    .focused_workspace_idx();
+
+                if let Some(monitor) = self.focused_monitor_mut() {
+                    if let Some(last_focused_workspace) = monitor.last_focused_workspace() {
+                        self.move_container_to_workspace(last_focused_workspace, false, None)?;
+                    }
+                }
+                self.focused_monitor_mut()
+                    .ok_or_else(|| anyhow!("there is no monitor"))?
+                    .set_last_focused_workspace(Option::from(idx));
+            }
            SocketMessage::MoveContainerToWorkspaceNumber(workspace_idx) => {
                self.move_container_to_workspace(workspace_idx, true, None)?;
            }
@@ -1100,11 +1197,33 @@ impl WindowManager {
                    WorkspaceLayer::Tiling => {
                        workspace.set_layer(WorkspaceLayer::Floating);

-                        for (i, window) in workspace.floating_windows().iter().enumerate() {
-                            if i == 0 {
+                        let focused_idx = workspace.focused_floating_window_idx();
+                        let mut window_idx_pairs = workspace
+                            .floating_windows_mut()
+                            .make_contiguous()
+                            .iter()
+                            .enumerate()
+                            .collect::<Vec<_>>();
+
+                        // Sort by window area
+                        window_idx_pairs.sort_by_key(|(_, w)| {
+                            let rect = WindowsApi::window_rect(w.hwnd).unwrap_or_default();
+                            rect.right * rect.bottom
+                        });
+                        window_idx_pairs.reverse();
+
+                        for (i, window) in window_idx_pairs {
+                            if i == focused_idx {
                                to_focus = Some(*window);
+                            } else {
+                                window.raise()?;
                            }
-                            window.raise()?;
+                        }
+
+                        if let Some(focused_window) = &to_focus {
+                            // The focused window should be the last one raised to make sure it is
+                            // on top
+                            focused_window.raise()?;
                        }

                        for container in workspace.containers() {
@@ -1126,7 +1245,19 @@ impl WindowManager {
                            }
                        }

-                        for window in workspace.floating_windows() {
+                        let mut window_idx_pairs = workspace
+                            .floating_windows_mut()
+                            .make_contiguous()
+                            .iter()
+                            .collect::<Vec<_>>();
+
+                        // Sort by window area
+                        window_idx_pairs.sort_by_key(|w| {
+                            let rect = WindowsApi::window_rect(w.hwnd).unwrap_or_default();
+                            rect.right * rect.bottom
+                        });
+
+                        for window in window_idx_pairs {
                            window.lower()?;
                        }
                    }
@@ -1783,6 +1914,10 @@ impl WindowManager {
                WindowKind::Unfocused => {
                    border_manager::UNFOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                }
+                WindowKind::UnfocusedLocked => {
+                    border_manager::UNFOCUSED_LOCKED
+                        .store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
+                }
                WindowKind::Floating => {
                    border_manager::FLOATING.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                }
--- a/komorebi/src/process_event.rs
+++ b/komorebi/src/process_event.rs
@@ -1,7 +1,5 @@
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
-use std::time::Duration;
-use std::time::Instant;

 use color_eyre::eyre::anyhow;
 use color_eyre::Result;
@@ -27,12 +25,10 @@ use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
 use crate::winevent::WinEvent;
 use crate::workspace::WorkspaceLayer;
-use crate::workspace_reconciliator;
-use crate::workspace_reconciliator::ALT_TAB_HWND;
-use crate::workspace_reconciliator::ALT_TAB_HWND_INSTANT;
 use crate::Notification;
 use crate::NotificationEvent;
 use crate::State;
+use crate::Window;
 use crate::FLOATING_APPLICATIONS;
 use crate::HIDDEN_HWNDS;
 use crate::REGEX_IDENTIFIERS;
@@ -300,38 +296,11 @@ impl WindowManager {
                    tracing::info!("ignoring uncloak after monocle move by mouse across monitors");
                    self.uncloack_to_ignore = self.uncloack_to_ignore.saturating_sub(1);
                } else {
-                    let focused_monitor_idx = self.focused_monitor_idx();
-                    let focused_workspace_idx =
+                    let mut focused_monitor_idx = self.focused_monitor_idx();
+                    let mut focused_workspace_idx =
                        self.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;

-                    let focused_pair = (focused_monitor_idx, focused_workspace_idx);
-
-                    let mut needs_reconciliation = false;
-
-                    if let Some((m_idx, w_idx)) = self.known_hwnds.get(&window.hwnd) {
-                        if focused_pair != (*m_idx, *w_idx) {
-                            // At this point we know we are going to send a notification to the workspace reconciliator
-                            // So we get the topmost window returned by EnumWindows, which is almost always the window
-                            // that has been selected by alt-tab
-                            if let Ok(alt_tab_windows) = WindowsApi::alt_tab_windows() {
-                                if let Some(first) =
-                                    alt_tab_windows.iter().find(|w| w.title().is_ok())
-                                {
-                                    // If our record of this HWND hasn't been updated in over a minute
-                                    let mut instant = ALT_TAB_HWND_INSTANT.lock();
-                                    if instant.elapsed().gt(&Duration::from_secs(1)) {
-                                        // Update our record with the HWND we just found
-                                        ALT_TAB_HWND.store(Some(first.hwnd));
-                                        // Update the timestamp of our record
-                                        *instant = Instant::now();
-                                    }
-                                }
-                            }
-
-                            workspace_reconciliator::send_notification(*m_idx, *w_idx);
-                            needs_reconciliation = true;
-                        }
-                    }
+                    let mut needs_reconciliation = None;

                    // There are some applications such as Firefox where, if they are focused when a
                    // workspace switch takes place, it will fire an additional Show event, which will
@@ -340,6 +309,23 @@ impl WindowManager {
                    // duplicates across multiple workspaces, as it results in ghost layout tiles.
                    let mut proceed = true;

+                    // Check for potential `alt-tab` event
+                    if matches!(
+                        event,
+                        WindowManagerEvent::Uncloak(_, _) | WindowManagerEvent::Show(_, _)
+                    ) {
+                        needs_reconciliation = self.needs_reconciliation(window)?;
+
+                        if let Some((m_idx, ws_idx)) = needs_reconciliation {
+                            self.perform_reconciliation(window, (m_idx, ws_idx))?;
+
+                            // Since there was a reconciliation after an `alt-tab`, that means this
+                            // window is already handled by komorebi so we shouldn't proceed with
+                            // adding it as a new window.
+                            proceed = false;
+                        }
+                    }
+
                    if let Some((m_idx, w_idx)) = self.known_hwnds.get(&window.hwnd) {
                        if let Some(focused_workspace_idx) = self
                            .monitors()
@@ -360,6 +346,18 @@ impl WindowManager {
                    }

                    if proceed {
+                        if matches!(event, WindowManagerEvent::Show(_, _)) {
+                            let initial_monitor_idx = initial_state.monitors.focused_idx();
+                            if focused_monitor_idx != initial_monitor_idx {
+                                tracing::info!("assuming focused monitor index should be {initial_monitor_idx} for WindowManagerEvent::Show");
+                                self.focus_monitor(initial_monitor_idx)?;
+                            }
+
+                            focused_monitor_idx = self.focused_monitor_idx();
+                            focused_workspace_idx =
+                                self.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;
+                        }
+
                        let mut behaviour = self.window_management_behaviour(
                            focused_monitor_idx,
                            focused_workspace_idx,
@@ -368,7 +366,7 @@ impl WindowManager {
                        let workspace_contains_window = workspace.contains_window(window.hwnd);
                        let monocle_container = workspace.monocle_container().clone();

-                        if !workspace_contains_window && !needs_reconciliation {
+                        if !workspace_contains_window && needs_reconciliation.is_none() {
                            let floating_applications = FLOATING_APPLICATIONS.lock();
                            let mut should_float = false;

@@ -402,7 +400,7 @@ impl WindowManager {
                                    matches!(workspace.layer, WorkspaceLayer::Floating)
                                        && !should_float
                                        && workspace.tile;
-                                workspace.floating_windows_mut().push(window);
+                                workspace.floating_windows_mut().push_back(window);
                                workspace.set_layer(WorkspaceLayer::Floating);
                                if center_spawned_floats {
                                    let mut floating_window = window;
@@ -630,7 +628,7 @@ impl WindowManager {
                                window.focus(self.mouse_follows_focus)?;
                            }
                        } else if window_management_behaviour.float_override {
-                            workspace.floating_windows_mut().push(window);
+                            workspace.floating_windows_mut().push_back(window);
                            self.update_focused_workspace(false, false)?;
                        } else {
                            match window_management_behaviour.current_behaviour {
@@ -753,4 +751,119 @@ impl WindowManager {

        Ok(())
    }
+
+    /// Checks if this window is from another unfocused workspace or is an unfocused window on a
+    /// stack container. If it is it will return the monitor/workspace index pair of this window so
+    /// that a reconciliation of that monitor/workspace can be done.
+    fn needs_reconciliation(&self, window: Window) -> color_eyre::Result<Option<(usize, usize)>> {
+        let focused_monitor_idx = self.focused_monitor_idx();
+        let focused_workspace_idx =
+            self.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;
+
+        let focused_pair = (focused_monitor_idx, focused_workspace_idx);
+
+        let mut needs_reconciliation = None;
+
+        if let Some((m_idx, ws_idx)) = self.known_hwnds.get(&window.hwnd) {
+            if (*m_idx, *ws_idx) == focused_pair {
+                if let Some(target_workspace) = self
+                    .monitors()
+                    .get(*m_idx)
+                    .and_then(|m| m.workspaces().get(*ws_idx))
+                {
+                    if let Some(monocle_with_window) = target_workspace
+                        .monocle_container()
+                        .as_ref()
+                        .and_then(|m| m.contains_window(window.hwnd).then_some(m))
+                    {
+                        if monocle_with_window.focused_window() != Some(&window) {
+                            tracing::debug!("Needs reconciliation within a monocled stack");
+                            needs_reconciliation = Some((*m_idx, *ws_idx));
+                        }
+                    } else {
+                        let c_idx = target_workspace.container_idx_for_window(window.hwnd);
+
+                        if let Some(target_container) =
+                            c_idx.and_then(|c_idx| target_workspace.containers().get(c_idx))
+                        {
+                            if target_container.focused_window() != Some(&window) {
+                                tracing::debug!(
+                                    "Needs reconciliation within a stack on the focused workspace"
+                                );
+                                needs_reconciliation = Some((*m_idx, *ws_idx));
+                            }
+                        }
+                    }
+                }
+            } else {
+                tracing::debug!("Needs reconciliation for a different monitor/workspace pair");
+                needs_reconciliation = Some((*m_idx, *ws_idx));
+            }
+        }
+
+        Ok(needs_reconciliation)
+    }
+
+    /// When there was an `alt-tab` to a hidden window we need to perform a reconciliation, meaning
+    /// we need to update the focused monitor, workspace, container and window indices to the ones
+    /// corresponding to the window the user just alt-tabbed into.
+    fn perform_reconciliation(
+        &mut self,
+        window: Window,
+        reconciliation_pair: (usize, usize),
+    ) -> color_eyre::Result<()> {
+        let (m_idx, ws_idx) = reconciliation_pair;
+
+        tracing::debug!("performing reconciliation");
+        self.focus_monitor(m_idx)?;
+        let mouse_follows_focus = self.mouse_follows_focus;
+        let offset = self.work_area_offset;
+
+        if let Some(monitor) = self.focused_monitor_mut() {
+            if ws_idx != monitor.focused_workspace_idx() {
+                let previous_idx = monitor.focused_workspace_idx();
+                monitor.set_last_focused_workspace(Option::from(previous_idx));
+                monitor.focus_workspace(ws_idx)?;
+            }
+            if let Some(workspace) = monitor.focused_workspace_mut() {
+                let mut layer = WorkspaceLayer::Tiling;
+                if let Some((monocle, idx)) = workspace
+                    .monocle_container_mut()
+                    .as_mut()
+                    .and_then(|m| m.idx_for_window(window.hwnd).map(|i| (m, i)))
+                {
+                    monocle.focus_window(idx);
+                } else if workspace
+                    .floating_windows()
+                    .iter()
+                    .any(|w| w.hwnd == window.hwnd)
+                {
+                    layer = WorkspaceLayer::Floating;
+                } else if !workspace
+                    .maximized_window()
+                    .is_some_and(|w| w.hwnd == window.hwnd)
+                {
+                    // If the window is the maximized window do nothing, else we
+                    // reintegrate the monocle if it exists and then focus the
+                    // container
+                    if workspace.monocle_container().is_some() {
+                        tracing::info!("disabling monocle");
+                        for container in workspace.containers_mut() {
+                            container.restore();
+                        }
+                        for window in workspace.floating_windows_mut() {
+                            window.restore();
+                        }
+                        workspace.reintegrate_monocle_container()?;
+                    }
+                    workspace.focus_container_by_window(window.hwnd)?;
+                }
+                workspace.set_layer(layer);
+            }
+            monitor.load_focused_workspace(mouse_follows_focus)?;
+            monitor.update_focused_workspace(offset)?;
+        }
+
+        Ok(())
+    }
 }
--- a/komorebi/src/ring.rs
+++ b/komorebi/src/ring.rs
@@ -76,4 +76,36 @@ macro_rules! impl_ring_elements {
            }
        }
    };
+    // This allows passing a different name to be used for the functions. For instance, the
+    // `floating_windows` ring calls this as:
+    // ```rust
+    // impl_ring_elements!(Workspace, Window, "floating_window");
+    // ```
+    // Which allows using the `Window` element but name the functions as `floating_window`
+    ($name:ty, $element:ident, $el_name:literal) => {
+        paste::paste! {
+            impl $name {
+                pub const fn [<$el_name:lower s>](&self) -> &VecDeque<$element> {
+                    self.[<$el_name:lower s>].elements()
+                }
+
+                pub fn [<$el_name:lower s_mut>](&mut self) -> &mut VecDeque<$element> {
+                    self.[<$el_name:lower s>].elements_mut()
+                }
+
+                #[allow(dead_code)]
+                pub fn [<focused_ $el_name:lower>](&self) -> Option<&$element> {
+                    self.[<$el_name:lower s>].focused()
+                }
+
+                pub const fn [<focused_ $el_name:lower _idx>](&self) -> usize {
+                    self.[<$el_name:lower s>].focused_idx()
+                }
+
+                pub fn [<focused_ $el_name:lower _mut>](&mut self) -> Option<&mut $element> {
+                    self.[<$el_name:lower s>].focused_mut()
+                }
+            }
+        }
+    };
 }
--- a/komorebi/src/static_config.rs
+++ b/komorebi/src/static_config.rs
@@ -60,6 +60,7 @@ use crate::workspace::Workspace;
 use crate::AspectRatio;
 use crate::Axis;
 use crate::CrossBoundaryBehaviour;
+use crate::FloatingLayerBehaviour;
 use crate::PredefinedAspectRatio;
 use crate::DATA_DIR;
 use crate::DEFAULT_CONTAINER_PADDING;
@@ -164,6 +165,9 @@ pub struct WorkspaceConfig {
    /// Specify an axis on which to flip the selected layout (default: None)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub layout_flip: Option<Axis>,
+    /// Determine what happens to a new window when the Floating workspace layer is active (default: Tile)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub floating_layer_behaviour: Option<FloatingLayerBehaviour>,
 }

 impl From<&Workspace> for WorkspaceConfig {
@@ -239,6 +243,7 @@ impl From<&Workspace> for WorkspaceConfig {
            window_container_behaviour_rules: Option::from(window_container_behaviour_rules),
            float_override: *value.float_override(),
            layout_flip: value.layout_flip(),
+            floating_layer_behaviour: Option::from(*value.floating_layer_behaviour()),
        }
    }
 }
@@ -314,7 +319,7 @@ pub enum AppSpecificConfigurationPath {

 #[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
 #[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
-/// The `komorebi.json` static configuration file reference for `v0.1.35`
+/// The `komorebi.json` static configuration file reference for `v0.1.36`
 pub struct StaticConfig {
    /// DEPRECATED from v0.1.22: no longer required
    #[serde(skip_serializing_if = "Option::is_none")]
@@ -500,6 +505,9 @@ pub enum KomorebiTheme {
        /// Border colour when the container is unfocused (default: Base)
        #[serde(skip_serializing_if = "Option::is_none")]
        unfocused_border: Option<komorebi_themes::CatppuccinValue>,
+        /// Border colour when the container is unfocused and locked (default: Red)
+        #[serde(skip_serializing_if = "Option::is_none")]
+        unfocused_locked_border: Option<komorebi_themes::CatppuccinValue>,
        /// Stackbar focused tab text colour (default: Green)
        #[serde(skip_serializing_if = "Option::is_none")]
        stackbar_focused_text: Option<komorebi_themes::CatppuccinValue>,
@@ -532,6 +540,9 @@ pub enum KomorebiTheme {
        /// Border colour when the container is unfocused (default: Base01)
        #[serde(skip_serializing_if = "Option::is_none")]
        unfocused_border: Option<komorebi_themes::Base16Value>,
+        /// Border colour when the container is unfocused and locked (default: Base08)
+        #[serde(skip_serializing_if = "Option::is_none")]
+        unfocused_locked_border: Option<komorebi_themes::Base16Value>,
        /// Stackbar focused tab text colour (default: Base0B)
        #[serde(skip_serializing_if = "Option::is_none")]
        stackbar_focused_text: Option<komorebi_themes::Base16Value>,
--- a/komorebi/src/theme_manager.rs
+++ b/komorebi/src/theme_manager.rs
@@ -76,6 +76,7 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
            monocle_border,
            floating_border,
            unfocused_border,
+            unfocused_locked_border,
            stackbar_focused_text,
            stackbar_unfocused_text,
            stackbar_background,
@@ -87,6 +88,7 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                monocle_border,
                floating_border,
                unfocused_border,
+                unfocused_locked_border,
                stackbar_focused_text,
                stackbar_unfocused_text,
                stackbar_background,
@@ -112,6 +114,10 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                    .unwrap_or(komorebi_themes::CatppuccinValue::Base)
                    .color32(name.as_theme());

+                let unfocused_locked_border = unfocused_locked_border
+                    .unwrap_or(komorebi_themes::CatppuccinValue::Red)
+                    .color32(name.as_theme());
+
                let stackbar_focused_text = stackbar_focused_text
                    .unwrap_or(komorebi_themes::CatppuccinValue::Green)
                    .color32(name.as_theme());
@@ -130,6 +136,7 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                    monocle_border,
                    floating_border,
                    unfocused_border,
+                    unfocused_locked_border,
                    stackbar_focused_text,
                    stackbar_unfocused_text,
                    stackbar_background,
@@ -142,6 +149,7 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                monocle_border,
                floating_border,
                unfocused_border,
+                unfocused_locked_border,
                stackbar_focused_text,
                stackbar_unfocused_text,
                stackbar_background,
@@ -163,6 +171,10 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                    .unwrap_or(komorebi_themes::Base16Value::Base01)
                    .color32(*name);

+                let unfocused_locked_border = unfocused_locked_border
+                    .unwrap_or(komorebi_themes::Base16Value::Base08)
+                    .color32(*name);
+
                let floating_border = floating_border
                    .unwrap_or(komorebi_themes::Base16Value::Base09)
                    .color32(*name);
@@ -185,6 +197,7 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
                    monocle_border,
                    floating_border,
                    unfocused_border,
+                    unfocused_locked_border,
                    stackbar_focused_text,
                    stackbar_unfocused_text,
                    stackbar_background,
@@ -198,6 +211,10 @@ pub fn handle_notifications() -> color_eyre::Result<()> {
        border_manager::FLOATING.store(u32::from(Colour::from(floating_border)), Ordering::SeqCst);
        border_manager::UNFOCUSED
            .store(u32::from(Colour::from(unfocused_border)), Ordering::SeqCst);
+        border_manager::UNFOCUSED_LOCKED.store(
+            u32::from(Colour::from(unfocused_locked_border)),
+            Ordering::SeqCst,
+        );

        STACKBAR_TAB_BACKGROUND_COLOUR.store(
            u32::from(Colour::from(stackbar_background)),
--- a/komorebi/src/window_manager.rs
+++ b/komorebi/src/window_manager.rs
@@ -80,6 +80,7 @@ use crate::workspace::WorkspaceLayer;
 use crate::BorderColours;
 use crate::Colour;
 use crate::CrossBoundaryBehaviour;
+use crate::FloatingLayerBehaviour;
 use crate::Rgb;
 use crate::CUSTOM_FFM;
 use crate::DATA_DIR;
@@ -341,7 +342,9 @@ impl From<&WindowManager> for State {
                                .clone(),
                            float_override: workspace.float_override,
                            layer: workspace.layer,
+                            floating_layer_behaviour: workspace.floating_layer_behaviour,
                            globals: workspace.globals,
+                            locked_containers: workspace.locked_containers.clone(),
                            workspace_config: None,
                        })
                        .collect::<VecDeque<_>>();
@@ -643,10 +646,14 @@ impl WindowManager {
                    self.window_management_behaviour.float_override
                };

-                // If the workspace layer is `Floating`, then consider it as if it had float
-                // override so that new windows spawn as floating
-                float_override =
-                    float_override || matches!(workspace.layer, WorkspaceLayer::Floating);
+                // If the workspace layer is `Floating` and the floating layer behaviour is `Float`,
+                // then consider it as if it had float override so that new windows spawn as floating
+                float_override = float_override
+                    || (matches!(workspace.layer, WorkspaceLayer::Floating)
+                        && matches!(
+                            workspace.floating_layer_behaviour,
+                            FloatingLayerBehaviour::Float
+                        ));

                return WindowManagementBehaviour {
                    current_behaviour,
@@ -967,7 +974,7 @@ impl WindowManager {
            if op.floating {
                target_workspace
                    .floating_windows_mut()
-                    .push(Window::from(op.hwnd));
+                    .push_back(Window::from(op.hwnd));
            } else {
                //TODO(alex-ds13): should this take into account the target workspace
                //`window_container_behaviour`?
@@ -1144,18 +1151,18 @@ impl WindowManager {
            // There is no need to physically move the floating window between areas with
            // `move_to_area` because the user already did that, so we only need to transfer the
            // window to the target `floating_windows`
-            let floating_window = origin_workspace.floating_windows_mut().remove(idx);
+            if let Some(floating_window) = origin_workspace.floating_windows_mut().remove(idx) {
+                let target_workspace = self
+                    .monitors_mut()
+                    .get_mut(target_monitor_idx)
+                    .ok_or_else(|| anyhow!("there is no monitor at this idx"))?
+                    .focused_workspace_mut()
+                    .ok_or_else(|| anyhow!("there is no focused workspace for this monitor"))?;

-            let target_workspace = self
-                .monitors_mut()
-                .get_mut(target_monitor_idx)
-                .ok_or_else(|| anyhow!("there is no monitor at this idx"))?
-                .focused_workspace_mut()
-                .ok_or_else(|| anyhow!("there is no focused workspace for this monitor"))?;
-
-            target_workspace
-                .floating_windows_mut()
-                .push(floating_window);
+                target_workspace
+                    .floating_windows_mut()
+                    .push_back(floating_window);
+            }
        } else if origin_workspace
            .monocle_container()
            .as_ref()
@@ -1829,7 +1836,7 @@ impl WindowManager {
            .position(|w| w.hwnd == foreground_hwnd);

        let floating_window =
-            floating_window_index.map(|idx| workspace.floating_windows_mut().remove(idx));
+            floating_window_index.and_then(|idx| workspace.floating_windows_mut().remove(idx));
        let container = if floating_window_index.is_none() {
            Some(
                workspace
@@ -1858,7 +1865,7 @@ impl WindowManager {
            .ok_or_else(|| anyhow!("there is no focused workspace on target monitor"))?;

        if let Some(window) = floating_window {
-            target_workspace.floating_windows_mut().push(window);
+            target_workspace.floating_windows_mut().push_back(window);
            target_workspace.set_layer(WorkspaceLayer::Floating);
            Window::from(window.hwnd)
                .move_to_area(&current_area, target_monitor.work_area_size())?;
@@ -1977,45 +1984,251 @@ impl WindowManager {
        direction: OperationDirection,
    ) -> Result<()> {
        let mouse_follows_focus = self.mouse_follows_focus;
-        let focused_workspace = self.focused_workspace()?;
+        let focused_workspace = self.focused_workspace_mut()?;

        let mut target_idx = None;
        let len = focused_workspace.floating_windows().len();

        if len > 1 {
            let focused_hwnd = WindowsApi::foreground_window()?;
-            for (idx, window) in focused_workspace.floating_windows().iter().enumerate() {
-                if window.hwnd == focused_hwnd {
-                    match direction {
-                        OperationDirection::Left => {}
-                        OperationDirection::Right => {}
-                        OperationDirection::Up => {
-                            if idx == len - 1 {
-                                target_idx = Some(0)
-                            } else {
-                                target_idx = Some(idx + 1)
-                            }
-                        }
-                        OperationDirection::Down => {
-                            if idx == 0 {
-                                target_idx = Some(len - 1)
-                            } else {
-                                target_idx = Some(idx - 1)
-                            }
-                        }
+            let focused_rect = WindowsApi::window_rect(focused_hwnd)?;
+            match direction {
+                OperationDirection::Left => {
+                    let mut windows_in_direction = focused_workspace
+                        .floating_windows()
+                        .iter()
+                        .enumerate()
+                        .flat_map(|(idx, w)| {
+                            (w.hwnd != focused_hwnd)
+                                .then_some(WindowsApi::window_rect(w.hwnd).ok().map(|r| (idx, r)))
+                        })
+                        .flatten()
+                        .flat_map(|(idx, r)| {
+                            (r.left < focused_rect.left)
+                                .then_some((idx, i32::abs(r.left - focused_rect.left)))
+                        })
+                        .collect::<Vec<_>>();
+
+                    // Sort by distance to focused
+                    windows_in_direction.sort_by_key(|(_, d)| (*d as f32 * 1000.0).trunc() as i32);
+
+                    if let Some((idx, _)) = windows_in_direction.first() {
+                        target_idx = Some(*idx);
                    }
                }
-            }
+                OperationDirection::Right => {
+                    let mut windows_in_direction = focused_workspace
+                        .floating_windows()
+                        .iter()
+                        .enumerate()
+                        .flat_map(|(idx, w)| {
+                            (w.hwnd != focused_hwnd)
+                                .then_some(WindowsApi::window_rect(w.hwnd).ok().map(|r| (idx, r)))
+                        })
+                        .flatten()
+                        .flat_map(|(idx, r)| {
+                            (r.left > focused_rect.left)
+                                .then_some((idx, i32::abs(r.left - focused_rect.left)))
+                        })
+                        .collect::<Vec<_>>();

-            if target_idx.is_none() {
-                target_idx = Some(0);
-            }
+                    // Sort by distance to focused
+                    windows_in_direction.sort_by_key(|(_, d)| (*d as f32 * 1000.0).trunc() as i32);
+
+                    if let Some((idx, _)) = windows_in_direction.first() {
+                        target_idx = Some(*idx);
+                    }
+                }
+                OperationDirection::Up => {
+                    let mut windows_in_direction = focused_workspace
+                        .floating_windows()
+                        .iter()
+                        .enumerate()
+                        .flat_map(|(idx, w)| {
+                            (w.hwnd != focused_hwnd)
+                                .then_some(WindowsApi::window_rect(w.hwnd).ok().map(|r| (idx, r)))
+                        })
+                        .flatten()
+                        .flat_map(|(idx, r)| {
+                            (r.top < focused_rect.top)
+                                .then_some((idx, i32::abs(r.top - focused_rect.top)))
+                        })
+                        .collect::<Vec<_>>();
+
+                    // Sort by distance to focused
+                    windows_in_direction.sort_by_key(|(_, d)| (*d as f32 * 1000.0).trunc() as i32);
+
+                    if let Some((idx, _)) = windows_in_direction.first() {
+                        target_idx = Some(*idx);
+                    }
+                }
+                OperationDirection::Down => {
+                    let mut windows_in_direction = focused_workspace
+                        .floating_windows()
+                        .iter()
+                        .enumerate()
+                        .flat_map(|(idx, w)| {
+                            (w.hwnd != focused_hwnd)
+                                .then_some(WindowsApi::window_rect(w.hwnd).ok().map(|r| (idx, r)))
+                        })
+                        .flatten()
+                        .flat_map(|(idx, r)| {
+                            (r.top > focused_rect.top)
+                                .then_some((idx, i32::abs(r.top - focused_rect.top)))
+                        })
+                        .collect::<Vec<_>>();
+
+                    // Sort by distance to focused
+                    windows_in_direction.sort_by_key(|(_, d)| (*d as f32 * 1000.0).trunc() as i32);
+
+                    if let Some((idx, _)) = windows_in_direction.first() {
+                        target_idx = Some(*idx);
+                    }
+                }
+            };
        }

        if let Some(idx) = target_idx {
+            focused_workspace.floating_windows.focus(idx);
            if let Some(window) = focused_workspace.floating_windows().get(idx) {
                window.focus(mouse_follows_focus)?;
            }
+            return Ok(());
+        }
+
+        let mut cross_monitor_monocle_or_max = false;
+
+        let workspace_idx = self.focused_workspace_idx()?;
+
+        // this is for when we are scrolling across workspaces like PaperWM
+        if matches!(
+            self.cross_boundary_behaviour,
+            CrossBoundaryBehaviour::Workspace
+        ) && matches!(
+            direction,
+            OperationDirection::Left | OperationDirection::Right
+        ) {
+            let workspace_count = if let Some(monitor) = self.focused_monitor() {
+                monitor.workspaces().len()
+            } else {
+                1
+            };
+
+            let next_idx = match direction {
+                OperationDirection::Left => match workspace_idx {
+                    0 => workspace_count - 1,
+                    n => n - 1,
+                },
+                OperationDirection::Right => match workspace_idx {
+                    n if n == workspace_count - 1 => 0,
+                    n => n + 1,
+                },
+                _ => workspace_idx,
+            };
+
+            self.focus_workspace(next_idx)?;
+
+            if let Ok(focused_workspace) = self.focused_workspace_mut() {
+                if focused_workspace.monocle_container().is_none() {
+                    match direction {
+                        OperationDirection::Left => match focused_workspace.layout() {
+                            Layout::Default(layout) => {
+                                let target_index =
+                                    layout.rightmost_index(focused_workspace.containers().len());
+                                focused_workspace.focus_container(target_index);
+                            }
+                            Layout::Custom(_) => {
+                                focused_workspace.focus_container(
+                                    focused_workspace.containers().len().saturating_sub(1),
+                                );
+                            }
+                        },
+                        OperationDirection::Right => match focused_workspace.layout() {
+                            Layout::Default(layout) => {
+                                let target_index =
+                                    layout.leftmost_index(focused_workspace.containers().len());
+                                focused_workspace.focus_container(target_index);
+                            }
+                            Layout::Custom(_) => {
+                                focused_workspace.focus_container(0);
+                            }
+                        },
+                        _ => {}
+                    };
+                }
+            }
+
+            return Ok(());
+        }
+
+        // if there is no floating_window in that direction for this workspace
+        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)?;
+        let mouse_follows_focus = self.mouse_follows_focus;
+
+        if let Ok(focused_workspace) = self.focused_workspace_mut() {
+            if let Some(window) = focused_workspace.maximized_window() {
+                window.focus(mouse_follows_focus)?;
+                cross_monitor_monocle_or_max = true;
+            } else if let Some(monocle) = focused_workspace.monocle_container() {
+                if let Some(window) = monocle.focused_window() {
+                    window.focus(mouse_follows_focus)?;
+                    cross_monitor_monocle_or_max = true;
+                }
+            } else if focused_workspace.layer() == &WorkspaceLayer::Tiling {
+                match direction {
+                    OperationDirection::Left => match focused_workspace.layout() {
+                        Layout::Default(layout) => {
+                            let target_index =
+                                layout.rightmost_index(focused_workspace.containers().len());
+                            focused_workspace.focus_container(target_index);
+                        }
+                        Layout::Custom(_) => {
+                            focused_workspace.focus_container(
+                                focused_workspace.containers().len().saturating_sub(1),
+                            );
+                        }
+                    },
+                    OperationDirection::Right => match focused_workspace.layout() {
+                        Layout::Default(layout) => {
+                            let target_index =
+                                layout.leftmost_index(focused_workspace.containers().len());
+                            focused_workspace.focus_container(target_index);
+                        }
+                        Layout::Custom(_) => {
+                            focused_workspace.focus_container(0);
+                        }
+                    },
+                    _ => {}
+                };
+            }
+        }
+
+        if !cross_monitor_monocle_or_max {
+            let ws = self.focused_workspace_mut()?;
+            if ws.is_empty() {
+                // This is to remove focus from the previous monitor
+                let desktop_window = Window::from(WindowsApi::desktop_window()?);
+
+                match WindowsApi::raise_and_focus_window(desktop_window.hwnd) {
+                    Ok(()) => {}
+                    Err(error) => {
+                        tracing::warn!("{} {}:{}", error, file!(), line!());
+                    }
+                }
+            } else if ws.layer() == &WorkspaceLayer::Floating && !ws.floating_windows().is_empty() {
+                if let Some(window) = ws.focused_floating_window() {
+                    window.focus(self.mouse_follows_focus)?;
+                }
+            } else {
+                ws.set_layer(WorkspaceLayer::Tiling);
+                if let Ok(focused_window) = self.focused_window() {
+                    focused_window.focus(self.mouse_follows_focus)?;
+                }
+            }
        }

        Ok(())
@@ -2122,7 +2335,7 @@ impl WindowManager {
                            window.focus(mouse_follows_focus)?;
                            cross_monitor_monocle_or_max = true;
                        }
-                    } else {
+                    } else if focused_workspace.layer() == &WorkspaceLayer::Tiling {
                        match direction {
                            OperationDirection::Left => match focused_workspace.layout() {
                                Layout::Default(layout) => {
@@ -2158,8 +2371,26 @@ impl WindowManager {
        }

        if !cross_monitor_monocle_or_max {
-            if let Ok(focused_window) = self.focused_window_mut() {
-                focused_window.focus(self.mouse_follows_focus)?;
+            let ws = self.focused_workspace_mut()?;
+            if ws.is_empty() {
+                // This is to remove focus from the previous monitor
+                let desktop_window = Window::from(WindowsApi::desktop_window()?);
+
+                match WindowsApi::raise_and_focus_window(desktop_window.hwnd) {
+                    Ok(()) => {}
+                    Err(error) => {
+                        tracing::warn!("{} {}:{}", error, file!(), line!());
+                    }
+                }
+            } else if ws.layer() == &WorkspaceLayer::Floating && !ws.floating_windows().is_empty() {
+                if let Some(window) = ws.focused_floating_window() {
+                    window.focus(self.mouse_follows_focus)?;
+                }
+            } else {
+                ws.set_layer(WorkspaceLayer::Tiling);
+                if let Ok(focused_window) = self.focused_window() {
+                    focused_window.focus(self.mouse_follows_focus)?;
+                }
            }
        }

@@ -2849,6 +3080,20 @@ impl WindowManager {
        self.update_focused_workspace(is_floating_window, true)
    }

+    #[tracing::instrument(skip(self))]
+    pub fn toggle_lock(&mut self) -> Result<()> {
+        let workspace = self.focused_workspace_mut()?;
+        let index = workspace.focused_container_idx();
+
+        if workspace.locked_containers().contains(&index) {
+            workspace.locked_containers_mut().remove(&index);
+        } else {
+            workspace.locked_containers_mut().insert(index);
+        }
+
+        Ok(())
+    }
+
    #[tracing::instrument(skip(self))]
    pub fn float_window(&mut self) -> Result<()> {
        tracing::info!("floating window");
@@ -2860,7 +3105,7 @@ impl WindowManager {

        let window = workspace
            .floating_windows_mut()
-            .last_mut()
+            .back_mut()
            .ok_or_else(|| anyhow!("there is no floating window"))?;

        window.center(&work_area)?;
--- a/komorebi/src/workspace.rs
+++ b/komorebi/src/workspace.rs
@@ -1,3 +1,4 @@
+use std::collections::BTreeSet;
 use std::collections::VecDeque;
 use std::fmt::Display;
 use std::fmt::Formatter;
@@ -21,10 +22,12 @@ use crate::core::DefaultLayout;
 use crate::core::Layout;
 use crate::core::OperationDirection;
 use crate::core::Rect;
+use crate::FloatingLayerBehaviour;

 use crate::border_manager::BORDER_OFFSET;
 use crate::border_manager::BORDER_WIDTH;
 use crate::container::Container;
+use crate::locked_deque::LockedDeque;
 use crate::ring::Ring;
 use crate::should_act;
 use crate::stackbar_manager;
@@ -60,8 +63,7 @@ pub struct Workspace {
    #[serde(skip_serializing_if = "Option::is_none")]
    #[getset(get_copy = "pub", set = "pub")]
    pub maximized_window_restore_idx: Option<usize>,
-    #[getset(get = "pub", get_mut = "pub")]
-    pub floating_windows: Vec<Window>,
+    pub floating_windows: Ring<Window>,
    #[getset(get = "pub", get_mut = "pub", set = "pub")]
    pub layout: Layout,
    #[getset(get = "pub", get_mut = "pub", set = "pub")]
@@ -90,6 +92,10 @@ pub struct Workspace {
    pub globals: WorkspaceGlobals,
    #[getset(get = "pub", get_mut = "pub", set = "pub")]
    pub layer: WorkspaceLayer,
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
+    pub floating_layer_behaviour: FloatingLayerBehaviour,
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
+    pub locked_containers: BTreeSet<usize>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[getset(get = "pub", set = "pub")]
    pub workspace_config: Option<WorkspaceConfig>,
@@ -113,6 +119,7 @@ impl Display for WorkspaceLayer {
 }

 impl_ring_elements!(Workspace, Container);
+impl_ring_elements!(Workspace, Window, "floating_window");

 impl Default for Workspace {
    fn default() -> Self {
@@ -123,7 +130,7 @@ impl Default for Workspace {
            maximized_window: None,
            maximized_window_restore_idx: None,
            monocle_container_restore_idx: None,
-            floating_windows: Vec::default(),
+            floating_windows: Ring::default(),
            layout: Layout::Default(DefaultLayout::BSP),
            layout_rules: vec![],
            layout_flip: None,
@@ -137,8 +144,10 @@ impl Default for Workspace {
            window_container_behaviour_rules: None,
            float_override: None,
            layer: Default::default(),
+            floating_layer_behaviour: Default::default(),
            globals: Default::default(),
            workspace_config: None,
+            locked_containers: Default::default(),
        }
    }
 }
@@ -245,6 +254,7 @@ impl Workspace {

        self.set_float_override(config.float_override);
        self.set_layout_flip(config.layout_flip);
+        self.set_floating_layer_behaviour(config.floating_layer_behaviour.unwrap_or_default());

        self.set_workspace_config(Some(config.clone()));

@@ -320,13 +330,13 @@ impl Workspace {
            } else if let Some(maximized_window) = self.maximized_window() {
                maximized_window.restore();
                maximized_window.focus(mouse_follows_focus)?;
-            } else if let Some(floating_window) = self.floating_windows().first() {
+            } else if let Some(floating_window) = self.focused_floating_window() {
                floating_window.focus(mouse_follows_focus)?;
            }
        } else if let Some(maximized_window) = self.maximized_window() {
            maximized_window.restore();
            maximized_window.focus(mouse_follows_focus)?;
-        } else if let Some(floating_window) = self.floating_windows().first() {
+        } else if let Some(floating_window) = self.focused_floating_window() {
            floating_window.focus(mouse_follows_focus)?;
        }

@@ -603,6 +613,9 @@ impl Workspace {
        self.containers().get(self.container_idx_for_window(hwnd)?)
    }

+    /// If there is a container which holds the window with `hwnd` it will focus that container.
+    /// This function will only emit a focus on the window if it isn't the focused window of that
+    /// container already.
    pub fn focus_container_by_window(&mut self, hwnd: isize) -> Result<()> {
        let container_idx = self
            .container_idx_for_window(hwnd)
@@ -806,9 +819,8 @@ impl Workspace {
            ),
        };

-        self.containers_mut().insert(primary_idx, container);
-        self.resize_dimensions_mut().insert(primary_idx, resize);
-
+        let insertion_idx = self.insert_container_at_idx(primary_idx, container);
+        self.resize_dimensions_mut()[insertion_idx] = resize;
        self.focus_container(primary_idx);

        Ok(())
@@ -824,24 +836,41 @@ impl Workspace {
        self.focus_first_container();
    }

-    pub fn insert_container_at_idx(&mut self, idx: usize, container: Container) {
-        self.containers_mut().insert(idx, container);
-        self.focus_container(idx);
+    // this fn respects locked container indexes - we should use it for pretty much everything
+    // except monocle and maximize toggles
+    pub fn insert_container_at_idx(&mut self, idx: usize, container: Container) -> usize {
+        let mut locked_containers = self.locked_containers().clone();
+        let mut ld = LockedDeque::new(self.containers_mut(), &mut locked_containers);
+        let insertion_idx = ld.insert(idx, container);
+        self.locked_containers = locked_containers;
+
+        if insertion_idx > self.resize_dimensions().len() {
+            self.resize_dimensions_mut().push(None);
+        } else {
+            self.resize_dimensions_mut().insert(insertion_idx, None);
+        }
+
+        self.focus_container(insertion_idx);
+
+        insertion_idx
    }

+    // this fn respects locked container indexes - we should use it for pretty much everything
+    // except monocle and maximize toggles
    pub fn remove_container_by_idx(&mut self, idx: usize) -> Option<Container> {
+        let mut locked_containers = self.locked_containers().clone();
+        let mut ld = LockedDeque::new(self.containers_mut(), &mut locked_containers);
+        let container = ld.remove(idx);
+        self.locked_containers = locked_containers;
+
        if idx < self.resize_dimensions().len() {
            self.resize_dimensions_mut().remove(idx);
        }

-        if idx < self.containers().len() {
-            return self.containers_mut().remove(idx);
-        }
-
-        None
+        container
    }

-    fn container_idx_for_window(&self, hwnd: isize) -> Option<usize> {
+    pub fn container_idx_for_window(&self, hwnd: isize) -> Option<usize> {
        let mut idx = None;
        for (i, x) in self.containers().iter().enumerate() {
            if x.contains_window(hwnd) {
@@ -912,15 +941,7 @@ impl Workspace {
            .ok_or_else(|| anyhow!("there is no window"))?;

        if container.windows().is_empty() {
-            self.containers_mut()
-                .remove(container_idx)
-                .ok_or_else(|| anyhow!("there is no container"))?;
-
-            // Whenever a container is empty, we need to remove any resize dimensions for it too
-            if self.resize_dimensions().get(container_idx).is_some() {
-                self.resize_dimensions_mut().remove(container_idx);
-            }
-
+            self.remove_container_by_idx(container_idx);
            self.focus_previous_container();
        } else {
            container.load_focused_window();
@@ -957,6 +978,7 @@ impl Workspace {
            len,
        )
    }
+
    pub fn new_idx_for_cycle_direction(&self, direction: CycleDirection) -> Option<usize> {
        Option::from(direction.next_idx(
            self.focused_container_idx(),
@@ -964,6 +986,7 @@ impl Workspace {
        ))
    }

+    // this is what we use for stacking
    pub fn move_window_to_container(&mut self, target_container_idx: usize) -> Result<()> {
        let focused_idx = self.focused_container_idx();

@@ -977,8 +1000,7 @@ impl Workspace {

        // This is a little messy
        let adjusted_target_container_index = if container.windows().is_empty() {
-            self.containers_mut().remove(focused_idx);
-            self.resize_dimensions_mut().remove(focused_idx);
+            self.remove_container_by_idx(focused_idx);

            if focused_idx < target_container_idx {
                target_container_idx.saturating_sub(1)
@@ -1017,8 +1039,7 @@ impl Workspace {
            .ok_or_else(|| anyhow!("there is no window"))?;

        if container.windows().is_empty() {
-            self.containers_mut().remove(focused_container_idx);
-            self.resize_dimensions_mut().remove(focused_container_idx);
+            self.remove_container_by_idx(focused_container_idx);
        } else {
            container.load_focused_window();
        }
@@ -1038,8 +1059,8 @@ impl Workspace {

        let mut container = Container::default();
        container.add_window(window);
-        self.containers_mut().insert(focused_idx, container);
-        self.resize_dimensions_mut().insert(focused_idx, None);
+
+        self.insert_container_at_idx(focused_idx, container);

        Ok(())
    }
@@ -1054,19 +1075,7 @@ impl Workspace {
        let mut container = Container::default();
        container.add_window(window);

-        if next_idx > self.containers().len() {
-            self.containers_mut().push_back(container);
-        } else {
-            self.containers_mut().insert(next_idx, container);
-        }
-
-        if next_idx > self.resize_dimensions().len() {
-            self.resize_dimensions_mut().push(None);
-        } else {
-            self.resize_dimensions_mut().insert(next_idx, None);
-        }
-
-        self.focus_container(next_idx);
+        self.insert_container_at_idx(next_idx, container);
    }

    pub fn new_floating_window(&mut self) -> Result<()> {
@@ -1100,8 +1109,7 @@ impl Workspace {
                .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);
+                self.remove_container_by_idx(focused_idx);

                if focused_idx == self.containers().len() {
                    self.focus_container(focused_idx.saturating_sub(1));
@@ -1113,7 +1121,7 @@ impl Workspace {
            window
        };

-        self.floating_windows_mut().push(window);
+        self.floating_windows_mut().push_back(window);

        Ok(())
    }
@@ -1373,6 +1381,10 @@ impl Workspace {

    pub fn new_monocle_container(&mut self) -> Result<()> {
        let focused_idx = self.focused_container_idx();
+
+        // we shouldn't use remove_container_by_idx here because it doesn't make sense for
+        // monocle and maximized toggles which take over the whole screen before being reinserted
+        // at the same index to respect locked container indexes
        let container = self
            .containers_mut()
            .remove(focused_idx)
@@ -1410,6 +1422,9 @@ impl Workspace {
                .resize(restore_idx, Container::default());
        }

+        // we shouldn't use insert_container_at_index here because it doesn't make sense for
+        // monocle and maximized toggles which take over the whole screen before being reinserted
+        // at the same index to respect locked container indexes
        self.containers_mut().insert(restore_idx, container);
        self.focus_container(restore_idx);
        self.focused_container_mut()
@@ -1424,24 +1439,11 @@ 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));
+        if matches!(self.layer, WorkspaceLayer::Floating) {
+            let floating_window_idx = self.focused_floating_window_idx();
+            let floating_window = self.floating_windows_mut().remove(floating_window_idx);
+            self.set_maximized_window(floating_window);
            self.set_maximized_window_restore_idx(Option::from(focused_idx));
            if let Some(window) = self.maximized_window() {
                window.maximize();
@@ -1481,6 +1483,9 @@ impl Workspace {
            .ok_or_else(|| anyhow!("there is no window"))?;

        if container.windows().is_empty() {
+            // we shouldn't use remove_container_by_idx here because it doesn't make sense for
+            // monocle and maximized toggles which take over the whole screen before being reinserted
+            // at the same index to respect locked container indexes
            self.containers_mut().remove(focused_idx);
            if self.resize_dimensions().get(focused_idx).is_some() {
                self.resize_dimensions_mut().remove(focused_idx);
@@ -1520,8 +1525,11 @@ impl Workspace {

        let mut container = Container::default();
        container.windows_mut().push_back(window);
-        self.containers_mut().insert(restore_idx, container);

+        // we shouldn't use insert_container_at_index here because it doesn't make sense for
+        // monocle and maximized toggles which take over the whole screen before being reinserted
+        // at the same index to respect locked container indexes
+        self.containers_mut().insert(restore_idx, container);
        self.focus_container(restore_idx);

        self.focused_container_mut()
@@ -1550,7 +1558,7 @@ impl Workspace {
        let hwnd = WindowsApi::foreground_window().ok()?;

        let mut idx = None;
-        for (i, window) in self.floating_windows.iter().enumerate() {
+        for (i, window) in self.floating_windows().iter().enumerate() {
            if hwnd == window.hwnd {
                idx = Option::from(i);
            }
@@ -1559,8 +1567,8 @@ impl Workspace {
        match idx {
            None => None,
            Some(idx) => {
-                if self.floating_windows.get(idx).is_some() {
-                    Option::from(self.floating_windows_mut().remove(idx))
+                if self.floating_windows().get(idx).is_some() {
+                    self.floating_windows_mut().remove(idx)
                } else {
                    None
                }
@@ -1640,6 +1648,170 @@ impl Workspace {
 mod tests {
    use super::*;

+    use crate::container::Container;
+    use crate::Window;
+    use std::collections::BTreeSet;
+    use std::collections::HashMap;
+
+    #[test]
+    fn test_locked_containers_with_new_window() {
+        let mut ws = Workspace::default();
+
+        let mut state = HashMap::new();
+        let mut locked = BTreeSet::new();
+
+        // add 3 containers
+        for i in 0..4 {
+            let container = Container::default();
+            state.insert(i, container.id().to_string());
+            ws.add_container_to_back(container);
+        }
+        assert_eq!(ws.containers().len(), 4);
+
+        // set index 3 locked
+        locked.insert(3);
+        ws.locked_containers = locked;
+
+        // focus container at index 2
+        ws.focus_container(2);
+
+        // simulate a new window being launched on this workspace
+        ws.new_container_for_window(Window::from(123));
+
+        // new length should be 5, with the focus on the new window at index 4
+        assert_eq!(ws.containers().len(), 5);
+        assert_eq!(ws.focused_container_idx(), 4);
+        assert_eq!(
+            ws.focused_container()
+                .unwrap()
+                .focused_window()
+                .unwrap()
+                .hwnd,
+            123
+        );
+
+        // when inserting a new container at index 0, index 3's container should not change
+        ws.focus_container(0);
+        ws.new_container_for_window(Window::from(234));
+        assert_eq!(
+            ws.containers()[3].id().to_string(),
+            state.get(&3).unwrap().to_string()
+        );
+    }
+
+    #[test]
+    fn test_locked_containers_remove_window() {
+        let mut ws = Workspace::default();
+
+        let mut locked = BTreeSet::new();
+
+        // add 4 containers
+        for i in 0..4 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            ws.add_container_to_back(container);
+        }
+        assert_eq!(ws.containers().len(), 4);
+
+        // set index 1 locked
+        locked.insert(1);
+        ws.locked_containers = locked;
+
+        ws.remove_window(0).unwrap();
+        assert_eq!(ws.containers()[0].focused_window().unwrap().hwnd, 2);
+        // index 1 should still be the same
+        assert_eq!(ws.containers()[1].focused_window().unwrap().hwnd, 1);
+        assert_eq!(ws.containers()[2].focused_window().unwrap().hwnd, 3);
+    }
+
+    #[test]
+    fn test_locked_containers_toggle_float() {
+        let mut ws = Workspace::default();
+
+        let mut locked = BTreeSet::new();
+
+        // add 4 containers
+        for i in 0..4 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            ws.add_container_to_back(container);
+        }
+        assert_eq!(ws.containers().len(), 4);
+
+        // set index 1 locked
+        locked.insert(1);
+        ws.locked_containers = locked;
+
+        // set index 0 focused
+        ws.focus_container(0);
+
+        // float index 0
+        ws.new_floating_window().unwrap();
+
+        assert_eq!(ws.containers()[0].focused_window().unwrap().hwnd, 2);
+        // index 1 should still be the same
+        assert_eq!(ws.containers()[1].focused_window().unwrap().hwnd, 1);
+        assert_eq!(ws.containers()[2].focused_window().unwrap().hwnd, 3);
+
+        // unfloat - have to do this semi-manually becuase of calls to WindowsApi in
+        // new_container_for_floating_window which usually handles unfloating
+        let window = ws.floating_windows_mut().pop_back().unwrap();
+        let mut container = Container::default();
+        container.add_window(window);
+        ws.insert_container_at_idx(ws.focused_container_idx(), container);
+
+        // all indexes should be at their original position
+        for i in 0..4 {
+            assert_eq!(
+                ws.containers()[i].focused_window().unwrap().hwnd,
+                i as isize
+            );
+        }
+    }
+
+    #[test]
+    fn test_locked_containers_stack() {
+        let mut ws = Workspace::default();
+
+        let mut locked = BTreeSet::new();
+
+        // add 6 containers
+        for i in 0..6 {
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(i));
+            ws.add_container_to_back(container);
+        }
+        assert_eq!(ws.containers().len(), 6);
+
+        // set index 4 locked
+        locked.insert(4);
+        ws.locked_containers = locked;
+
+        // set index 3 focused
+        ws.focus_container(3);
+
+        // stack index 3 on top of index 2
+        ws.move_window_to_container(2).unwrap();
+
+        assert_eq!(ws.containers()[0].focused_window().unwrap().hwnd, 0);
+        assert_eq!(ws.containers()[1].focused_window().unwrap().hwnd, 1);
+        assert_eq!(ws.containers()[2].windows().len(), 2);
+        assert_eq!(ws.containers()[3].focused_window().unwrap().hwnd, 5);
+        // index 4 should still be the same
+        assert_eq!(ws.containers()[4].focused_window().unwrap().hwnd, 4);
+
+        // unstack
+        ws.new_container_for_focused_window().unwrap();
+
+        // all indexes should be at their original position
+        for i in 0..6 {
+            assert_eq!(
+                ws.containers()[i].focused_window().unwrap().hwnd,
+                i as isize
+            )
+        }
+    }
+
    #[test]
    fn test_contains_window() {
        // Create default workspace
@@ -2093,4 +2265,99 @@ mod tests {
            assert!(workspace.contains_window(0));
        }
    }
+
+    #[test]
+    fn test_focus_container_by_window() {
+        let mut workspace = Workspace::default();
+
+        {
+            // Container with 3 windows
+            let mut container = Container::default();
+            for i in 0..3 {
+                container.windows_mut().push_back(Window::from(i));
+            }
+            workspace.add_container_to_back(container);
+        }
+
+        {
+            // Container with 1 window
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(4));
+            workspace.add_container_to_back(container);
+        }
+
+        // Focus container by window
+        workspace.focus_container_by_window(1).unwrap();
+
+        // Should be focused on workspace 0
+        assert_eq!(workspace.focused_container_idx(), 0);
+
+        // Should be focused on window 1 and hwnd should be 1
+        let focused_container = workspace.focused_container_mut().unwrap();
+        assert_eq!(
+            focused_container.focused_window(),
+            Some(&Window { hwnd: 1 })
+        );
+        assert_eq!(focused_container.focused_window_idx(), 1);
+    }
+
+    #[test]
+    fn test_contains_managed_window() {
+        let mut workspace = Workspace::default();
+
+        {
+            // Container with 3 windows
+            let mut container = Container::default();
+            for i in 0..3 {
+                container.windows_mut().push_back(Window::from(i));
+            }
+            workspace.add_container_to_back(container);
+        }
+
+        {
+            // Container with 1 window
+            let mut container = Container::default();
+            container.windows_mut().push_back(Window::from(4));
+            workspace.add_container_to_back(container);
+        }
+
+        // Should return true, window is in container 1
+        assert!(workspace.contains_managed_window(4));
+
+        // Should return true, all the windows are in container 0
+        for i in 0..3 {
+            assert!(workspace.contains_managed_window(i));
+        }
+
+        // Should return false since window was never added
+        assert!(!workspace.contains_managed_window(5));
+    }
+
+    #[test]
+    fn test_new_floating_window() {
+        let mut workspace = Workspace::default();
+
+        {
+            // Container with 3 windows
+            let mut container = Container::default();
+            for i in 0..3 {
+                container.windows_mut().push_back(Window::from(i));
+            }
+            workspace.add_container_to_back(container);
+        }
+
+        // Add window to floating_windows
+        workspace.new_floating_window().ok();
+
+        // Should have 1 floating window
+        assert_eq!(workspace.floating_windows().len(), 1);
+
+        // Should have only 2 windows now
+        let container = workspace.focused_container_mut().unwrap();
+        assert_eq!(container.windows().len(), 2);
+
+        // Should contain hwnd 0 since this is the first window in the container
+        let floating_windows = workspace.floating_windows_mut();
+        assert!(floating_windows.contains(&Window { hwnd: 0 }));
+    }
 }
--- a/komorebi/src/workspace_reconciliator.rs
+++ b/komorebi/src/workspace_reconciliator.rs
@@ -1,130 +0,0 @@
-#![deny(clippy::unwrap_used, clippy::expect_used)]
-
-use crate::border_manager;
-use crate::WindowManager;
-use crossbeam_channel::Receiver;
-use crossbeam_channel::Sender;
-use crossbeam_utils::atomic::AtomicCell;
-use lazy_static::lazy_static;
-use parking_lot::Mutex;
-use std::sync::Arc;
-use std::sync::OnceLock;
-use std::time::Duration;
-use std::time::Instant;
-
-#[derive(Copy, Clone)]
-pub struct Notification {
-    pub monitor_idx: usize,
-    pub workspace_idx: usize,
-}
-
-pub static ALT_TAB_HWND: AtomicCell<Option<isize>> = AtomicCell::new(None);
-
-lazy_static! {
-    pub static ref ALT_TAB_HWND_INSTANT: Arc<Mutex<Instant>> = Arc::new(Mutex::new(Instant::now()));
-}
-
-static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
-
-pub fn channel() -> &'static (Sender<Notification>, Receiver<Notification>) {
-    CHANNEL.get_or_init(|| crossbeam_channel::bounded(1))
-}
-
-fn event_tx() -> Sender<Notification> {
-    channel().0.clone()
-}
-
-fn event_rx() -> Receiver<Notification> {
-    channel().1.clone()
-}
-
-pub fn send_notification(monitor_idx: usize, workspace_idx: usize) {
-    if event_tx()
-        .try_send(Notification {
-            monitor_idx,
-            workspace_idx,
-        })
-        .is_err()
-    {
-        tracing::warn!("channel is full; dropping notification")
-    }
-}
-
-pub fn listen_for_notifications(wm: Arc<Mutex<WindowManager>>) {
-    std::thread::spawn(move || loop {
-        match handle_notifications(wm.clone()) {
-            Ok(()) => {
-                tracing::warn!("restarting finished thread");
-            }
-            Err(error) => {
-                if cfg!(debug_assertions) {
-                    tracing::error!("restarting failed thread: {:?}", error)
-                } else {
-                    tracing::error!("restarting failed thread: {}", error)
-                }
-            }
-        }
-    });
-}
-pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
-    tracing::info!("listening");
-
-    let receiver = event_rx();
-    let arc = wm.clone();
-
-    for notification in receiver {
-        tracing::info!("running reconciliation");
-
-        let mut wm = wm.lock();
-        let focused_monitor_idx = wm.focused_monitor_idx();
-        let focused_workspace_idx =
-            wm.focused_workspace_idx_for_monitor_idx(focused_monitor_idx)?;
-
-        let focused_pair = (focused_monitor_idx, focused_workspace_idx);
-        let updated_pair = (notification.monitor_idx, notification.workspace_idx);
-
-        if focused_pair != updated_pair {
-            wm.focus_monitor(notification.monitor_idx)?;
-            let mouse_follows_focus = wm.mouse_follows_focus;
-
-            if let Some(monitor) = wm.focused_monitor_mut() {
-                let previous_idx = monitor.focused_workspace_idx();
-                monitor.set_last_focused_workspace(Option::from(previous_idx));
-                monitor.focus_workspace(notification.workspace_idx)?;
-                monitor.load_focused_workspace(mouse_follows_focus)?;
-            }
-
-            // Drop our lock on the window manager state here to not slow down updates
-            drop(wm);
-
-            // Check if there was an alt-tab across workspaces in the last second
-            if let Some(hwnd) = ALT_TAB_HWND.load() {
-                if ALT_TAB_HWND_INSTANT
-                    .lock()
-                    .elapsed()
-                    .lt(&Duration::from_secs(1))
-                {
-                    // Sleep for 100 millis to let other events pass
-                    std::thread::sleep(Duration::from_millis(100));
-                    tracing::info!("focusing alt-tabbed window");
-
-                    // Take a new lock on the wm and try to focus the container with
-                    // the recorded HWND from the alt-tab
-                    let mut wm = arc.lock();
-                    if let Ok(workspace) = wm.focused_workspace_mut() {
-                        // Regardless of if this fails, we need to get past this part
-                        // to unblock the border manager below
-                        let _ = workspace.focus_container_by_window(hwnd);
-                    }
-
-                    // Unblock the border manager
-                    ALT_TAB_HWND.store(None);
-                    // Send a notification to the border manager to update the borders
-                    border_manager::send_notification(None);
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
--- a/komorebic-no-console/Cargo.toml
+++ b/komorebic-no-console/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebic-no-console"
-version = "0.1.35"
+version = "0.1.36"
 description = "The command-line interface (without a console) for Komorebi, a tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"
--- a/komorebic/Cargo.toml
+++ b/komorebic/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "komorebic"
-version = "0.1.35"
+version = "0.1.36"
 description = "The command-line interface for Komorebi, a tiling window manager for Windows"
 repository = "https://github.com/LGUG2Z/komorebi"
 edition = "2021"
--- a/komorebic/src/main.rs
+++ b/komorebic/src/main.rs
@@ -1104,6 +1104,10 @@ enum SubCommand {
    /// Move the focused window to the specified monitor workspace
    #[clap(arg_required_else_help = true)]
    MoveToMonitorWorkspace(MoveToMonitorWorkspace),
+    /// Send the focused window to the last focused monitor workspace
+    SendToLastWorkspace,
+    /// Move the focused window to the last focused monitor workspace
+    MoveToLastWorkspace,
    /// Focus the specified monitor
    #[clap(arg_required_else_help = true)]
    FocusMonitor(FocusMonitor),
@@ -1283,6 +1287,8 @@ enum SubCommand {
    ToggleMonocle,
    /// Toggle native maximization for the focused window
    ToggleMaximize,
+    /// Toggle a lock for the focused container, ensuring it will not be displaced by any new windows
+    ToggleLock,
    /// Restore all hidden windows (debugging command)
    RestoreWindows,
    /// Force komorebi to manage the focused window
@@ -1855,6 +1861,12 @@ fn main() -> Result<()> {
                arg.cycle_direction,
            ))?;
        }
+        SubCommand::MoveToLastWorkspace => {
+            send_message(&SocketMessage::MoveContainerToLastWorkspace)?;
+        }
+        SubCommand::SendToLastWorkspace => {
+            send_message(&SocketMessage::SendContainerToLastWorkspace)?;
+        }
        SubCommand::SwapWorkspacesWithMonitor(arg) => {
            send_message(&SocketMessage::SwapWorkspacesToMonitorNumber(arg.target))?;
        }
@@ -1947,6 +1959,9 @@ fn main() -> Result<()> {
        SubCommand::ToggleMaximize => {
            send_message(&SocketMessage::ToggleMaximize)?;
        }
+        SubCommand::ToggleLock => {
+            send_message(&SocketMessage::ToggleLock)?;
+        }
        SubCommand::WorkspaceLayout(arg) => {
            send_message(&SocketMessage::WorkspaceLayout(
                arg.monitor,
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -133,6 +133,8 @@ nav:
      - cli/cycle-send-to-workspace.md
      - cli/send-to-monitor-workspace.md
      - cli/move-to-monitor-workspace.md
+      - cli/send-to-last-workspace.md
+      - cli/move-to-last-workspace.md
      - cli/focus-monitor.md
      - cli/focus-monitor-at-cursor.md
      - cli/focus-last-workspace.md
@@ -191,6 +193,7 @@ nav:
      - cli/toggle-float.md
      - cli/toggle-monocle.md
      - cli/toggle-maximize.md
+      - cli/toggle-lock.md
      - cli/restore-windows.md
      - cli/manage.md
      - cli/unmanage.md
--- a/schema.bar.json
+++ b/schema.bar.json
@@ -1,7 +1,7 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "KomobarConfig",
-  "description": "The `komorebi.bar.json` configuration file reference for `v0.1.35`",
+  "description": "The `komorebi.bar.json` configuration file reference for `v0.1.36`",
  "type": "object",
  "required": [
    "left_widgets",
--- a/schema.json
+++ b/schema.json
@@ -1,7 +1,7 @@
 {
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "StaticConfig",
-  "description": "The `komorebi.json` static configuration file reference for `v0.1.35`",
+  "description": "The `komorebi.json` static configuration file reference for `v0.1.36`",
  "type": "object",
  "properties": {
    "animation": {
@@ -1199,6 +1199,25 @@
                  "description": "Enable or disable float override, which makes it so every new window opens in floating mode (default: false)",
                  "type": "boolean"
                },
+                "floating_layer_behaviour": {
+                  "description": "Determine what happens to a new window when the Floating workspace layer is active (default: Tile)",
+                  "oneOf": [
+                    {
+                      "description": "Tile new windows (unless they match a float rule)",
+                      "type": "string",
+                      "enum": [
+                        "Tile"
+                      ]
+                    },
+                    {
+                      "description": "Float new windows",
+                      "type": "string",
+                      "enum": [
+                        "Float"
+                      ]
+                    }
+                  ]
+                },
                "initial_workspace_rules": {
                  "description": "Initial workspace application rules",
                  "type": "array",
@@ -2211,6 +2230,38 @@
                "Mantle",
                "Crust"
              ]
+            },
+            "unfocused_locked_border": {
+              "description": "Border colour when the container is unfocused and locked (default: Red)",
+              "type": "string",
+              "enum": [
+                "Rosewater",
+                "Flamingo",
+                "Pink",
+                "Mauve",
+                "Red",
+                "Maroon",
+                "Peach",
+                "Yellow",
+                "Green",
+                "Teal",
+                "Sky",
+                "Sapphire",
+                "Blue",
+                "Lavender",
+                "Text",
+                "Subtext1",
+                "Subtext0",
+                "Overlay2",
+                "Overlay1",
+                "Overlay0",
+                "Surface2",
+                "Surface1",
+                "Surface0",
+                "Base",
+                "Mantle",
+                "Crust"
+              ]
            }
          }
        },
@@ -2700,6 +2751,28 @@
                "Base0E",
                "Base0F"
              ]
+            },
+            "unfocused_locked_border": {
+              "description": "Border colour when the container is unfocused and locked (default: Base08)",
+              "type": "string",
+              "enum": [
+                "Base00",
+                "Base01",
+                "Base02",
+                "Base03",
+                "Base04",
+                "Base05",
+                "Base06",
+                "Base07",
+                "Base08",
+                "Base09",
+                "Base0A",
+                "Base0B",
+                "Base0C",
+                "Base0D",
+                "Base0E",
+                "Base0F"
+              ]
            }
          }
        }
--- a/wix/License.rtf
+++ b/wix/License.rtf
Author	SHA1	Message	Date
LGUG2Z	7fed31bc54	wip use cached monitor idx when handling newly spawned windows	2025-03-31 15:40:59 -07:00
alex-ds13	8fd18048a4	remove(wm): remove workspace_reconciliator	2025-03-31 15:23:33 -07:00
alex-ds13	5809735024	refactor(wm): refactor alt-tab reconciliation This commit changes the way the alt-tab reconciliation is done. It no longer uses the `workspace_reconciliator` with the sending of notifications. Instead there is a simple function that checks if the shown/uncloaked window is already handled by komorebi and if it is it will check if it is on an unfocused workspace and/or if it is an unfocused window of a stacked container, returning the monitor/workspace index pair of said window. If we get this pair then we perform the reconciliation immediately by focusing the monitor, workspace, container and window indices corresponding to that window.	2025-03-31 15:23:14 -07:00
alex-ds13	96fdbbd1fb	fix(client): re-export `FloatingLayerBehaviour`	2025-03-31 15:23:10 -07:00
Jerry Kingsbury	de131e9ca5	test(workspace): add more workspace tests Added tests for the focus_container_by_window and contains_managed_window functions. test_focus_container_by_window crates two containers with different distinct windows. The test checks to see if we are focused on the expected container and window. test_contains_managed_window creates two containers and checks to ensure that when calling the function returns the expected result when checking if a window is available in one of the containers. Added a test for adding a new floating window. The test creates a container with three windows and attempts to add one of the windows to the list of floating windows, then checks to see if the first window in the container was added to the floating window list and also checks the list of windows and floating windows to ensure we get the expected result.	2025-03-30 14:35:59 -07:00
LGUG2Z	07dba03255	docs(license): bump to 2.0.0	2025-03-30 12:59:41 -07:00
LGUG2Z	acd53dec1b	feat(wm): add flag to set logging verbosity This commit adds a --log-level flag to komorebi.exe which allows the user to set the logging verbosity without setting the RUST_LOG environment variable directly. If the RUST_LOG environment variable is set, it will take precedence over the --log-level flag.	2025-03-28 19:03:07 -07:00
LGUG2Z	a98968d179	feat(config): add floating ws layer behaviour opt This commit adds a new option to the WorkspaceConfig object, floating_layer_behaviour, which allows the user to either set FloatingLayerBehaviour::Tile or FloatingLayerBehaviour::Float. Although I prefer Float as a default, there was a good enough argument to make Tile the default based on the fact that the Floating layer is automatically engaged based on the focused window, and previously when the focused window was a floating window, new windows would be tiled unless they matched floating rules.	2025-03-28 16:38:00 -07:00
LGUG2Z	8a32219867	docs(coc): move document from discord to github	2025-03-27 09:07:57 -07:00
Jerry Kingsbury	ce4b75cc3c	test(monitor_reconciliator): add initial tests Added a test for sending a MonitorNotification using the send_notification function. The test sends a MonitorNotification and tests that the notification was recieved using event_rx. Added a test for inserting a monitor into the cache. The test creates a monitor and uses the insert_in_monitor_cache function to insert the monitor into cache, and will attempt to retrieve the monitor from the cache and check to see if it matches the expected value. Addaded a test for channel capacity. The test will send 20 notifications and then another notification, then check to ensure that all 20 messages match the notification we sent. The test will also check to ensure the last notification sent wasn't received. Added a test for the notification listener. The test will create a window manager and setup the notification listener, then check to see if we can send a notification and receive the notification. Created a Mock Monitor that can be used with testing functions that call the Win32 API. Added a test for the attach_display_devices function. The test will create a Mock Monitor and add the monitor to a closure that simulates a display_provider. The test passes the display_provider into the attach_display_devices function and checks to ensure we recieve the monitor we passed in.	2025-03-26 19:38:24 -07:00
alex-ds13	e4226ce623	feat(wm): show float windows in order on layer toggle This commit raises and lowers all the floating windows so that they show up with the smaller windows on top and the bigger windows on the bottom when we toggle between layers.	2025-03-26 15:48:35 -07:00
alex-ds13	4bfd7febb4	feat(wm): focus floats depending on direction This commit tries to focus the floating windows depending on the direction used. It takes into account the top left corner of each window and uses that to look for the closest top left corner in the direction provided. If there are no windows found in that direction, it then checks if it can focus across monitor.	2025-03-26 15:48:15 -07:00
alex-ds13	5cc688dc6b	feat(wm): track focused floating window This commit changes the `floating_windows` from a `Vec<Window>` to a `Ring<Window>` which allows us to keep track of the focused floating window. This combined with the existing layer switch allows us to know when we should focus the focused container or the focused floating window.	2025-03-26 15:48:07 -07:00
LGUG2Z	d897890032	fix(bar): fall back to older pid icon lookups This commit imports an older revision of my fork of windows-icons to call when attempting to look up the icon of an application by it's process id. This needs to be cleaned up before the next release.	2025-03-26 15:39:17 -07:00
LGUG2Z	e702d93a8a	feat(cli): add move/send-to-last-workspace cmds This commit adds two new komorebic commands, move-to-last-workspace and send-to-last-workspace, which move or send the focused window to the last focused workspace on the focused monitor.	2025-03-23 16:07:43 -07:00
LGUG2Z	a8c687d3d5	chore(deps): cargo update	2025-03-22 20:22:44 -07:00
alex-ds13	30fbc1ae73	feat(client): reexport win32_display_data This commit reexports the `win32_display_data` crate so that any 3rd party app that needs it can get it through the `komorebi-client` without having to keep manually synchronizing it with the version used by komorebi.	2025-03-22 19:35:23 -07:00
LGUG2Z	cb60e91842	feat(bar): show icons for uwp apps This commit integrates the excellent investigation and work done by @davor-skontra on the windows-icons repo to enable the retrieval of UWP applications, including all those annoying Microsoft applications which all share the ApplicationFrameHost.exe executable and the ApplicationFrameWindow class. Since these applications share the same executable, the icon cache in komorei-bar has been updated to use the window hwnd as a key intead of the window executable. resolve #1226	2025-03-22 19:31:30 -07:00
LGUG2Z	64d29d606a	refactor(wm): add dep injection to monitor reconiliator This commit adds some dependency injection to the monitor reconciliator module to make it easier to test the behaviour when different kinds of data are returned from win32_display_data.	2025-03-22 13:16:15 -07:00
LGUG2Z	072a62c314	perf(wm): clone-free locked deque insert/remove This commit replaces my initial clumsy LockedDeque insert/remove implementations with Clone-free implementations by @alex-ds13.	2025-03-22 12:33:40 -07:00
LGUG2Z	a95e6e9644	refactor(wm): consolidate handling of ws container insertion/removal	2025-03-22 12:33:39 -07:00
LGUG2Z	6ba19d3ea2	feat(wm): add locked containers per workspace This commit adds the concept of locked container indexes to komorebi workspaces. When a container index is locked, it can only be displaced by manual user actual - usually when another container is moved there, and when this happens, that container becomes the locked container. In the locked state, the container at the locked index should never be displaced by new windows opening or existing windows around it being closed. When the total number of containers on a workspace falls below the number of the locked index, the locked index will be removed. A locked index can be identified by a special border color linked to the new WindowKind::UnfocusedLocked variant. The implementation of locked container indexes is backed by a new data structure called a LockedDeque, which is a VecDeque with an auxiliary HashSet which keeps track of locked indices. A new komorebic command "toggle-lock" has been added to support programmatic use of this feature, as well as the LockMonitorWorkspaceContainer and UnlockMonitorWorkspaceContainer SocketMessage variants which can be used by status bars.	2025-03-22 12:28:15 -07:00
LGUG2Z	edf1943157	chore(dev): begin v0.1.36-dev	2025-03-22 12:14:43 -07:00
LGUG2Z	d0c847e5bc	docs(mkdocs): fix some broken relative links	2025-03-22 11:55:36 -07:00