feat(client): add subscribe_with_options

This commit adds a new method, subscribe_with_options to
komorebi-client.

The first option introduced is to tell komorebi to only send
notifications when the window manager state has been changed during the
processing of an event.

This new subscription option is now used with komorebi-bar to improve
rendering and update performance.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,52 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: "[BUG]: Short descriptive title"
-labels: bug
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See bug
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots and Videos**
-Add screenshots and videos to help explain your problem.
-
-**Operating System**
-Provide the output of `systeminfo | grep "^OS Name\|^OS Version"`
-
-For example:
-```
-OS Name:                   Microsoft Windows 11 Pro
-OS Version:                10.0.22000 N/A Build 22000
-```
-
-**`komorebic check` Output**
-Provide the output of `komorebic check`
-
-For example:
-```
-No KOMOREBI_CONFIG_HOME detected, defaulting to C:\Users\LGUG2Z
-
-Looking for configuration files in C:\Users\LGUG2Z
-
-No komorebi configuration found in C:\Users\LGUG2Z
-
-If running 'komorebic start --await-configuration', you will manually have to call the following command to begin tiling: komorebic complete-configuration
-```
-
-**Additional context**
-Add any other context about the problem here.
-
-In particular, if you have any other AHK scripts or software running that handle any aspect of window management or manipulation

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,55 @@
+name: Bug report
+description: File a bug report
+labels: [ bug ]
+body:
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Summary
+      description: >
+        Please provide a short summary of the bug, along with any information
+        you feel is relevant to replicating the bug.
+        
+        You may include screenshots and videos in this section.
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Version Information
+      description: >
+        Please provide information about the versions of Windows and komorebi
+        running on your machine.
+        
+        Do not submit a bug if you are not using an official version of Windows
+        such as AtlasOS; only official versions of Windows are supported.
+        
+        ```
+        systeminfo | findstr /B /C:"OS Name" /B /C:"OS Version"
+        ```
+
+        ```
+        komorebic --version
+        ```
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Komorebi Configuration
+      description: >
+        Please provide your configuration file (komorebi.json or komorebi.bar.json)
+      render: json
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Hotkey Configuration
+      description: >
+        Please provide your whkdrc or komorebi.ahk hotkey configuration file
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Output of komorebic check
+      description: >
+        Please provide the output of `komorebic check`

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Komorebi Documentation
+    url: https://lgug2z.github.io/komorebi/
+    about: Please search the documentation website before opening an issue

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: "[FEAT]: Short descriptive title"
-labels: enhancement
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,18 @@
+name: Feature request
+description: Suggest an improvement
+labels: [ enhancement ]
+body:
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Suggestion
+      description: >
+        Please share your suggestion here. Be sure to include all necessary context.
+  - type: textarea
+    validations:
+      required: true
+    attributes:
+      label: Alternatives Considered
+      description: >
+        Please share share alternatives you have considered here.

Cargo.toml

@@ -17,8 +17,8 @@ chrono = "0.4"
 crossbeam-channel = "0.5"
 crossbeam-utils = "0.8"
 color-eyre = "0.6"
-eframe = "0.28"
-egui_extras = "0.28"
+eframe = "0.29"
+egui_extras = "0.29"
 dirs = "5"
 dunce = "1"
 hotwatch = "0.5"
@@ -63,3 +63,6 @@ features = [
     "Media",
     "Media_Control"
 ]
+
+[profile.release]
+lto = true

komorebi-bar/Cargo.toml

@@ -9,7 +9,6 @@ edition = "2021"
 komorebi-client = { path = "../komorebi-client" }
 komorebi-themes = { path = "../komorebi-themes" }
 
-atomic_float = "1"
 chrono = { workspace = true }
 clap = { workspace = true }
 color-eyre = { workspace = true }
@@ -17,15 +16,15 @@ crossbeam-channel = { workspace = true }
 dirs = { workspace = true }
 dunce = { workspace = true }
 eframe = { workspace = true }
-egui-phosphor = "0.6.0"
+egui-phosphor = "0.7"
 font-loader = "0.11"
 hotwatch = { workspace = true }
 image = "0.25"
 netdev = "0.31"
-num = "0.4.3"
-num-derive = "0.4.2"
-num-traits = "0.2.19"
-random_word = { version = "0.4.3", features = ["en"] }
+num = "0.4"
+num-derive = "0.4"
+num-traits = "0.2"
+random_word = { version = "0.4", features = ["en"] }
 schemars = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

komorebi-bar/src/bar.rs

@@ -1,11 +1,17 @@
 use crate::config::KomobarConfig;
 use crate::config::KomobarTheme;
+use crate::config::Position;
+use crate::config::PositionConfig;
 use crate::komorebi::Komorebi;
 use crate::komorebi::KomorebiNotificationState;
+use crate::process_hwnd;
 use crate::widget::BarWidget;
 use crate::widget::WidgetConfig;
-use crate::DPI;
+use crate::BAR_HEIGHT;
 use crate::MAX_LABEL_WIDTH;
+use crate::MONITOR_LEFT;
+use crate::MONITOR_RIGHT;
+use crate::MONITOR_TOP;
 use crossbeam_channel::Receiver;
 use eframe::egui::Align;
 use eframe::egui::CentralPanel;
@@ -18,11 +24,8 @@ use eframe::egui::FontId;
 use eframe::egui::Frame;
 use eframe::egui::Layout;
 use eframe::egui::Margin;
-use eframe::egui::Pos2;
 use eframe::egui::Style;
 use eframe::egui::TextStyle;
-use eframe::egui::Vec2;
-use eframe::egui::ViewportCommand;
 use font_loader::system_fonts;
 use font_loader::system_fonts::FontPropertyBuilder;
 use komorebi_client::KomorebiTheme;
@@ -146,16 +149,43 @@ impl Komobar {
             Self::add_custom_font(ctx, font_family);
         }
 
-        if let Some(viewport) = &config.viewport {
-            let dpi = DPI.load(Ordering::SeqCst);
-            if let Some(position) = viewport.position {
-                let pos2 = Pos2::new(position.x / dpi, position.y / dpi);
-                ctx.send_viewport_cmd(ViewportCommand::OuterPosition(pos2));
-            }
+        let position = config.position.clone().unwrap_or(PositionConfig {
+            start: Some(Position {
+                x: MONITOR_LEFT.load(Ordering::SeqCst) as f32,
+                y: MONITOR_TOP.load(Ordering::SeqCst) as f32,
+            }),
+            end: Some(Position {
+                x: MONITOR_RIGHT.load(Ordering::SeqCst) as f32,
+                y: BAR_HEIGHT,
+            }),
+        });
 
-            if let Some(position) = viewport.inner_size {
-                let vec2 = Vec2::new(position.x / dpi, position.y / dpi);
-                ctx.send_viewport_cmd(ViewportCommand::InnerSize(vec2));
+        if let Some(hwnd) = process_hwnd() {
+            let start = position.start.unwrap_or(Position {
+                x: MONITOR_LEFT.load(Ordering::SeqCst) as f32,
+                y: MONITOR_TOP.load(Ordering::SeqCst) as f32,
+            });
+
+            let end = position.end.unwrap_or(Position {
+                x: MONITOR_RIGHT.load(Ordering::SeqCst) as f32,
+                y: BAR_HEIGHT,
+            });
+
+            let rect = komorebi_client::Rect {
+                left: start.x as i32,
+                top: start.y as i32,
+                right: end.x as i32,
+                bottom: end.y as i32,
+            };
+
+            let window = komorebi_client::Window::from(hwnd);
+            match window.set_position(&rect, false) {
+                Ok(_) => {
+                    tracing::info!("updated bar position");
+                }
+                Err(error) => {
+                    tracing::error!("{}", error.to_string())
+                }
             }
         }
 
@@ -294,6 +324,8 @@ impl Komobar {
             scale_factor: cc.egui_ctx.native_pixels_per_point().unwrap_or(1.0),
         };
 
+        komobar.apply_config(&cc.egui_ctx, &config, None);
+        // needs a double apply the first time for some reason
         komobar.apply_config(&cc.egui_ctx, &config, None);
 
         komobar

komorebi-bar/src/battery.rs

@@ -1,3 +1,4 @@
+use crate::config::LabelPrefix;
 use crate::widget::BarWidget;
 use crate::WIDGET_SPACING;
 use eframe::egui::text::LayoutJob;
@@ -23,6 +24,8 @@ pub struct BatteryConfig {
     pub enable: bool,
     /// Data refresh interval (default: 10 seconds)
     pub data_refresh_interval: Option<u64>,
+    /// Display label prefix
+    pub label_prefix: Option<LabelPrefix>,
 }
 
 impl From<BatteryConfig> for Battery {
@@ -30,6 +33,7 @@ impl From<BatteryConfig> for Battery {
         let manager = Manager::new().unwrap();
         let mut last_state = String::new();
         let mut state = None;
+        let prefix = value.label_prefix.unwrap_or(LabelPrefix::Icon);
 
         if let Ok(mut batteries) = manager.batteries() {
             if let Some(Ok(first)) = batteries.nth(0) {
@@ -40,7 +44,12 @@ impl From<BatteryConfig> for Battery {
                     _ => {}
                 }
 
-                last_state = format!("{percentage}%");
+                last_state = match prefix {
+                    LabelPrefix::Text | LabelPrefix::IconAndText => {
+                        format!("BAT: {percentage:.0}%")
+                    }
+                    LabelPrefix::None | LabelPrefix::Icon => format!("{percentage:.0}%"),
+                }
             }
         }
 
@@ -49,6 +58,7 @@ impl From<BatteryConfig> for Battery {
             manager,
             last_state,
             data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
+            label_prefix: prefix,
             state: state.unwrap_or(BatteryState::Discharging),
             last_updated: Instant::now(),
         }
@@ -65,6 +75,7 @@ pub struct Battery {
     manager: Manager,
     pub state: BatteryState,
     data_refresh_interval: u64,
+    label_prefix: LabelPrefix,
     last_state: String,
     last_updated: Instant,
 }
@@ -86,7 +97,12 @@ impl Battery {
                         _ => {}
                     }
 
-                    output = format!("{percentage:.0}%");
+                    output = match self.label_prefix {
+                        LabelPrefix::Text | LabelPrefix::IconAndText => {
+                            format!("BAT: {percentage:.0}%")
+                        }
+                        LabelPrefix::None | LabelPrefix::Icon => format!("{percentage:.0}%"),
+                    }
                 }
             }
 
@@ -116,7 +132,10 @@ impl BarWidget for Battery {
                     .unwrap_or_else(FontId::default);
 
                 let mut layout_job = LayoutJob::simple(
-                    emoji.to_string(),
+                    match self.label_prefix {
+                        LabelPrefix::Icon | LabelPrefix::IconAndText => emoji.to_string(),
+                        LabelPrefix::None | LabelPrefix::Text => String::new(),
+                    },
                     font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,

komorebi-bar/src/config.rs

@@ -7,13 +7,15 @@ use komorebi_client::Rect;
 use schemars::JsonSchema;
 use serde::Deserialize;
 use serde::Serialize;
+use std::collections::HashMap;
 use std::path::PathBuf;
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 /// The `komorebi.bar.json` configuration file reference for `v0.1.30`
 pub struct KomobarConfig {
-    /// Viewport options (see: https://docs.rs/egui/latest/egui/viewport/struct.ViewportBuilder.html)
-    pub viewport: Option<ViewportConfig>,
+    /// Bar positioning options
+    #[serde(alias = "viewport")]
+    pub position: Option<PositionConfig>,
     /// Frame options (see: https://docs.rs/egui/latest/egui/containers/struct.Frame.html)
     pub frame: Option<FrameConfig>,
     /// Monitor options
@@ -32,12 +34,43 @@ pub struct KomobarConfig {
     pub right_widgets: Vec<WidgetConfig>,
 }
 
+impl KomobarConfig {
+    pub fn aliases(raw: &str) {
+        let mut map = HashMap::new();
+        map.insert("position", ["viewport"]);
+        map.insert("end", ["inner_frame"]);
+
+        let mut display = false;
+
+        for aliases in map.values() {
+            for a in aliases {
+                if raw.contains(a) {
+                    display = true;
+                }
+            }
+        }
+
+        if display {
+            println!("\nYour bar configuration file contains some options that have been renamed or deprecated:\n");
+            for (canonical, aliases) in map {
+                for alias in aliases {
+                    if raw.contains(alias) {
+                        println!(r#""{alias}" is now "{canonical}""#);
+                    }
+                }
+            }
+        }
+    }
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-pub struct ViewportConfig {
+pub struct PositionConfig {
     /// The desired starting position of the bar (0,0 = top left of the screen)
-    pub position: Option<Position>,
+    #[serde(alias = "position")]
+    pub start: Option<Position>,
     /// The desired size of the bar from the starting position (usually monitor width x desired height)
-    pub inner_size: Option<Position>,
+    #[serde(alias = "inner_size")]
+    pub end: Option<Position>,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
@@ -131,3 +164,15 @@ impl From<KomorebiTheme> for KomobarTheme {
         }
     }
 }
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+pub enum LabelPrefix {
+    /// Show no prefix
+    None,
+    /// Show an icon
+    Icon,
+    /// Show text
+    Text,
+    /// Show an icon and text
+    IconAndText,
+}

komorebi-bar/src/cpu.rs

@@ -0,0 +1,120 @@
+use crate::config::LabelPrefix;
+use crate::widget::BarWidget;
+use crate::WIDGET_SPACING;
+use eframe::egui::text::LayoutJob;
+use eframe::egui::Context;
+use eframe::egui::FontId;
+use eframe::egui::Label;
+use eframe::egui::Sense;
+use eframe::egui::TextFormat;
+use eframe::egui::TextStyle;
+use eframe::egui::Ui;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde::Serialize;
+use std::process::Command;
+use std::time::Duration;
+use std::time::Instant;
+use sysinfo::RefreshKind;
+use sysinfo::System;
+
+#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema)]
+pub struct CpuConfig {
+    /// Enable the Cpu widget
+    pub enable: bool,
+    /// Data refresh interval (default: 10 seconds)
+    pub data_refresh_interval: Option<u64>,
+    /// Display label prefix
+    pub label_prefix: Option<LabelPrefix>,
+}
+
+impl From<CpuConfig> for Cpu {
+    fn from(value: CpuConfig) -> Self {
+        let mut system =
+            System::new_with_specifics(RefreshKind::default().without_memory().without_processes());
+
+        system.refresh_cpu_usage();
+
+        Self {
+            enable: value.enable,
+            system,
+            data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
+            label_prefix: value.label_prefix.unwrap_or(LabelPrefix::IconAndText),
+            last_updated: Instant::now(),
+        }
+    }
+}
+
+pub struct Cpu {
+    pub enable: bool,
+    system: System,
+    data_refresh_interval: u64,
+    label_prefix: LabelPrefix,
+    last_updated: Instant,
+}
+
+impl Cpu {
+    fn output(&mut self) -> String {
+        let now = Instant::now();
+        if now.duration_since(self.last_updated) > Duration::from_secs(self.data_refresh_interval) {
+            self.system.refresh_cpu_usage();
+            self.last_updated = now;
+        }
+
+        let used = self.system.global_cpu_usage();
+        match self.label_prefix {
+            LabelPrefix::Text | LabelPrefix::IconAndText => format!("CPU: {:.0}%", used),
+            LabelPrefix::None | LabelPrefix::Icon => format!("{:.0}%", used),
+        }
+    }
+}
+
+impl BarWidget for Cpu {
+    fn render(&mut self, ctx: &Context, ui: &mut Ui) {
+        if self.enable {
+            let output = self.output();
+            if !output.is_empty() {
+                let font_id = ctx
+                    .style()
+                    .text_styles
+                    .get(&TextStyle::Body)
+                    .cloned()
+                    .unwrap_or_else(FontId::default);
+
+                let mut layout_job = LayoutJob::simple(
+                    match self.label_prefix {
+                        LabelPrefix::Icon | LabelPrefix::IconAndText => {
+                            egui_phosphor::regular::CPU.to_string()
+                        }
+                        LabelPrefix::None | LabelPrefix::Text => String::new(),
+                    },
+                    font_id.clone(),
+                    ctx.style().visuals.selection.stroke.color,
+                    100.0,
+                );
+
+                layout_job.append(
+                    &output,
+                    10.0,
+                    TextFormat::simple(font_id, ctx.style().visuals.text_color()),
+                );
+
+                if ui
+                    .add(
+                        Label::new(layout_job)
+                            .selectable(false)
+                            .sense(Sense::click()),
+                    )
+                    .clicked()
+                {
+                    if let Err(error) = Command::new("cmd.exe").args(["/C", "taskmgr.exe"]).spawn()
+                    {
+                        eprintln!("{}", error)
+                    }
+                }
+            }
+
+            ui.add_space(WIDGET_SPACING);
+        }
+    }
+}

komorebi-bar/src/date.rs

@@ -1,3 +1,4 @@
+use crate::config::LabelPrefix;
 use crate::widget::BarWidget;
 use crate::WIDGET_SPACING;
 use eframe::egui::text::LayoutJob;
@@ -19,6 +20,8 @@ pub struct DateConfig {
     pub enable: bool,
     /// Set the Date format
     pub format: DateFormat,
+    /// Display label prefix
+    pub label_prefix: Option<LabelPrefix>,
 }
 
 impl From<DateConfig> for Date {
@@ -26,6 +29,7 @@ impl From<DateConfig> for Date {
         Self {
             enable: value.enable,
             format: value.format,
+            label_prefix: value.label_prefix.unwrap_or(LabelPrefix::Icon),
         }
     }
 }
@@ -70,6 +74,7 @@ impl DateFormat {
 pub struct Date {
     pub enable: bool,
     pub format: DateFormat,
+    label_prefix: LabelPrefix,
 }
 
 impl Date {
@@ -83,7 +88,7 @@ impl Date {
 impl BarWidget for Date {
     fn render(&mut self, ctx: &Context, ui: &mut Ui) {
         if self.enable {
-            let output = self.output();
+            let mut output = self.output();
             if !output.is_empty() {
                 let font_id = ctx
                     .style()
@@ -93,12 +98,21 @@ impl BarWidget for Date {
                     .unwrap_or_else(FontId::default);
 
                 let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::CALENDAR_DOTS.to_string(),
+                    match self.label_prefix {
+                        LabelPrefix::Icon | LabelPrefix::IconAndText => {
+                            egui_phosphor::regular::CALENDAR_DOTS.to_string()
+                        }
+                        LabelPrefix::None | LabelPrefix::Text => String::new(),
+                    },
                     font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,
                 );
 
+                if let LabelPrefix::Text | LabelPrefix::IconAndText = self.label_prefix {
+                    output.insert_str(0, "DATE: ");
+                }
+
                 layout_job.append(
                     &output,
                     10.0,

komorebi-bar/src/komorebi.rs

@@ -5,6 +5,7 @@ use crate::widget::BarWidget;
 use crate::MAX_LABEL_WIDTH;
 use crate::WIDGET_SPACING;
 use crossbeam_channel::Receiver;
+use crossbeam_channel::TryRecvError;
 use eframe::egui::text::LayoutJob;
 use eframe::egui::Color32;
 use eframe::egui::ColorImage;
@@ -83,14 +84,6 @@ impl From<&KomorebiConfig> for Komorebi {
             if let Some(configuration_switcher) = &value.configuration_switcher {
                 let mut configuration_switcher = configuration_switcher.clone();
                 for (_, location) in configuration_switcher.configurations.iter_mut() {
-                    if let Ok(expanded) = std::env::var("KOMOREBI_CONFIG_HOME") {
-                        *location = location.replace("$Env:KOMOREBI_CONFIG_HOME", &expanded);
-                    }
-
-                    if let Ok(expanded) = std::env::var("USERPROFILE") {
-                        *location = location.replace("$Env:USERPROFILE", &expanded);
-                    }
-
                     *location = dunce::simplified(&PathBuf::from(location.clone()))
                         .to_string_lossy()
                         .to_string();
@@ -445,93 +438,105 @@ impl KomorebiNotificationState {
         rx_gui: Receiver<komorebi_client::Notification>,
         bg_color: Rc<RefCell<Color32>>,
     ) {
-        if let Ok(notification) = rx_gui.try_recv() {
-            if let NotificationEvent::Socket(SocketMessage::ReloadStaticConfiguration(path)) =
-                notification.event
-            {
-                if let Ok(config) = komorebi_client::StaticConfig::read(&path) {
-                    if let Some(theme) = config.theme {
-                        apply_theme(ctx, KomobarTheme::from(theme), bg_color);
-                        tracing::info!("applied theme from updated komorebi.json");
+        match rx_gui.try_recv() {
+            Err(error) => match error {
+                TryRecvError::Empty => {}
+                TryRecvError::Disconnected => {
+                    tracing::error!(
+                        "failed to receive komorebi notification on gui thread: {error}"
+                    );
+                }
+            },
+            Ok(notification) => {
+                if let NotificationEvent::Socket(SocketMessage::ReloadStaticConfiguration(path)) =
+                    notification.event
+                {
+                    if let Ok(config) = komorebi_client::StaticConfig::read(&path) {
+                        if let Some(theme) = config.theme {
+                            apply_theme(ctx, KomobarTheme::from(theme), bg_color);
+                            tracing::info!("applied theme from updated komorebi.json");
+                        }
                     }
                 }
-            }
 
-            self.mouse_follows_focus = notification.state.mouse_follows_focus;
+                self.mouse_follows_focus = notification.state.mouse_follows_focus;
 
-            let monitor = &notification.state.monitors.elements()[monitor_index];
-            self.work_area_offset =
-                notification.state.monitors.elements()[monitor_index].work_area_offset();
+                let monitor = &notification.state.monitors.elements()[monitor_index];
+                self.work_area_offset =
+                    notification.state.monitors.elements()[monitor_index].work_area_offset();
 
-            let focused_workspace_idx = monitor.focused_workspace_idx();
+                let focused_workspace_idx = monitor.focused_workspace_idx();
 
-            let mut workspaces = vec![];
-            self.selected_workspace = monitor.workspaces()[focused_workspace_idx]
-                .name()
-                .to_owned()
-                .unwrap_or_else(|| format!("{}", focused_workspace_idx + 1));
+                let mut workspaces = vec![];
+                self.selected_workspace = monitor.workspaces()[focused_workspace_idx]
+                    .name()
+                    .to_owned()
+                    .unwrap_or_else(|| format!("{}", focused_workspace_idx + 1));
 
-            for (i, ws) in monitor.workspaces().iter().enumerate() {
-                let should_add = if self.hide_empty_workspaces {
-                    focused_workspace_idx == i || !ws.containers().is_empty()
-                } else {
-                    true
+                for (i, ws) in monitor.workspaces().iter().enumerate() {
+                    let should_add = if self.hide_empty_workspaces {
+                        focused_workspace_idx == i || !ws.containers().is_empty()
+                    } else {
+                        true
+                    };
+
+                    if should_add {
+                        workspaces
+                            .push(ws.name().to_owned().unwrap_or_else(|| format!("{}", i + 1)));
+                    }
+                }
+
+                self.workspaces = workspaces;
+                self.layout = match monitor.workspaces()[focused_workspace_idx].layout() {
+                    komorebi_client::Layout::Default(layout) => KomorebiLayout::Default(*layout),
+                    komorebi_client::Layout::Custom(_) => KomorebiLayout::Custom,
                 };
 
-                if should_add {
-                    workspaces.push(ws.name().to_owned().unwrap_or_else(|| format!("{}", i + 1)));
+                if !*monitor.workspaces()[focused_workspace_idx].tile() {
+                    self.layout = KomorebiLayout::Floating;
                 }
-            }
 
-            self.workspaces = workspaces;
-            self.layout = match monitor.workspaces()[focused_workspace_idx].layout() {
-                komorebi_client::Layout::Default(layout) => KomorebiLayout::Default(*layout),
-                komorebi_client::Layout::Custom(_) => KomorebiLayout::Custom,
-            };
+                if notification.state.is_paused {
+                    self.layout = KomorebiLayout::Paused;
+                }
 
-            if !*monitor.workspaces()[focused_workspace_idx].tile() {
-                self.layout = KomorebiLayout::Floating;
-            }
-
-            if notification.state.is_paused {
-                self.layout = KomorebiLayout::Paused;
-            }
-
-            if let Some(container) = monitor.workspaces()[focused_workspace_idx].monocle_container()
-            {
-                self.focused_container_information = (
-                    container
-                        .windows()
-                        .iter()
-                        .map(|w| w.title().unwrap_or_default())
-                        .collect::<Vec<_>>(),
-                    container
-                        .windows()
-                        .iter()
-                        .map(|w| windows_icons::get_icon_by_process_id(w.process_id()))
-                        .collect::<Vec<_>>(),
-                    container.focused_window_idx(),
-                );
-            } else if let Some(container) =
-                monitor.workspaces()[focused_workspace_idx].focused_container()
-            {
-                self.focused_container_information = (
-                    container
-                        .windows()
-                        .iter()
-                        .map(|w| w.title().unwrap_or_default())
-                        .collect::<Vec<_>>(),
-                    container
-                        .windows()
-                        .iter()
-                        .map(|w| windows_icons::get_icon_by_process_id(w.process_id()))
-                        .collect::<Vec<_>>(),
-                    container.focused_window_idx(),
-                );
-            } else {
-                self.focused_container_information.0.clear();
-                self.focused_container_information.1.clear();
-                self.focused_container_information.2 = 0;
+                if let Some(container) =
+                    monitor.workspaces()[focused_workspace_idx].monocle_container()
+                {
+                    self.focused_container_information = (
+                        container
+                            .windows()
+                            .iter()
+                            .map(|w| w.title().unwrap_or_default())
+                            .collect::<Vec<_>>(),
+                        container
+                            .windows()
+                            .iter()
+                            .map(|w| windows_icons::get_icon_by_process_id(w.process_id()))
+                            .collect::<Vec<_>>(),
+                        container.focused_window_idx(),
+                    );
+                } else if let Some(container) =
+                    monitor.workspaces()[focused_workspace_idx].focused_container()
+                {
+                    self.focused_container_information = (
+                        container
+                            .windows()
+                            .iter()
+                            .map(|w| w.title().unwrap_or_default())
+                            .collect::<Vec<_>>(),
+                        container
+                            .windows()
+                            .iter()
+                            .map(|w| windows_icons::get_icon_by_process_id(w.process_id()))
+                            .collect::<Vec<_>>(),
+                        container.focused_window_idx(),
+                    );
+                } else {
+                    self.focused_container_information.0.clear();
+                    self.focused_container_information.1.clear();
+                    self.focused_container_information.2 = 0;
+                }
             }
         }
     }

komorebi-bar/src/main.rs

@@ -1,6 +1,7 @@
 mod bar;
 mod battery;
 mod config;
+mod cpu;
 mod date;
 mod komorebi;
 mod media;
@@ -14,14 +15,14 @@ mod widget;
 use crate::bar::Komobar;
 use crate::config::KomobarConfig;
 use crate::config::Position;
-use atomic_float::AtomicF32;
+use crate::config::PositionConfig;
 use clap::Parser;
-use color_eyre::eyre::bail;
 use eframe::egui::ViewportBuilder;
 use font_loader::system_fonts;
 use hotwatch::EventKind;
 use hotwatch::Hotwatch;
 use komorebi_client::SocketMessage;
+use komorebi_client::SubscribeOptions;
 use schemars::gen::SchemaSettings;
 use std::io::BufReader;
 use std::io::Read;
@@ -31,12 +32,23 @@ use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::time::Duration;
 use tracing_subscriber::EnvFilter;
+use windows::Win32::Foundation::BOOL;
+use windows::Win32::Foundation::HWND;
+use windows::Win32::Foundation::LPARAM;
+use windows::Win32::System::Threading::GetCurrentProcessId;
+use windows::Win32::System::Threading::GetCurrentThreadId;
 use windows::Win32::UI::HiDpi::SetProcessDpiAwarenessContext;
 use windows::Win32::UI::HiDpi::DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2;
+use windows::Win32::UI::WindowsAndMessaging::EnumThreadWindows;
+use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
 
 pub static WIDGET_SPACING: f32 = 10.0;
+
 pub static MAX_LABEL_WIDTH: AtomicI32 = AtomicI32::new(400);
-pub static DPI: AtomicF32 = AtomicF32::new(1.0);
+pub static MONITOR_LEFT: AtomicI32 = AtomicI32::new(0);
+pub static MONITOR_TOP: AtomicI32 = AtomicI32::new(0);
+pub static MONITOR_RIGHT: AtomicI32 = AtomicI32::new(0);
+pub static BAR_HEIGHT: f32 = 50.0;
 
 #[derive(Parser)]
 #[clap(author, about, version)]
@@ -53,36 +65,41 @@ struct Opts {
     /// Write an example komorebi.bar.json to disk
     #[clap(long)]
     quickstart: bool,
+    /// Print a list of aliases that can be renamed to canonical variants
+    #[clap(long)]
+    #[clap(hide = true)]
+    aliases: bool,
 }
 
-macro_rules! as_ptr {
-    ($value:expr) => {
-        $value as *mut core::ffi::c_void
-    };
-}
-
-pub fn dpi_for_monitor(hmonitor: isize) -> color_eyre::Result<f32> {
-    use windows::Win32::Graphics::Gdi::HMONITOR;
-    use windows::Win32::UI::HiDpi::GetDpiForMonitor;
-    use windows::Win32::UI::HiDpi::MDT_EFFECTIVE_DPI;
-
-    let mut dpi_x = u32::default();
-    let mut dpi_y = u32::default();
-
+extern "system" fn enum_window(hwnd: HWND, lparam: LPARAM) -> BOOL {
     unsafe {
-        match GetDpiForMonitor(
-            HMONITOR(as_ptr!(hmonitor)),
-            MDT_EFFECTIVE_DPI,
-            std::ptr::addr_of_mut!(dpi_x),
-            std::ptr::addr_of_mut!(dpi_y),
-        ) {
-            Ok(_) => {}
-            Err(error) => bail!(error),
+        let mut process_id = 0;
+        GetWindowThreadProcessId(hwnd, Some(&mut process_id));
+
+        if process_id == GetCurrentProcessId() {
+            *(lparam.0 as *mut HWND) = hwnd;
+            BOOL::from(false) // Stop enumeration
+        } else {
+            BOOL::from(true) // Continue enumeration
         }
     }
+}
 
-    #[allow(clippy::cast_precision_loss)]
-    Ok(dpi_y as f32 / 96.0)
+fn process_hwnd() -> Option<isize> {
+    unsafe {
+        let mut hwnd = HWND::default();
+        let _ = EnumThreadWindows(
+            GetCurrentThreadId(),
+            Some(enum_window),
+            LPARAM(&mut hwnd as *mut HWND as isize),
+        );
+
+        if hwnd.0 as isize == 0 {
+            None
+        } else {
+            Some(hwnd.0 as isize)
+        }
+    }
 }
 
 fn main() -> color_eyre::Result<()> {
@@ -166,7 +183,7 @@ fn main() -> color_eyre::Result<()> {
         Option::from,
     );
 
-    let config = match config_path {
+    let mut config = match config_path {
         None => {
             let komorebi_bar_json =
                 include_str!("../../docs/komorebi.bar.example.json").to_string();
@@ -180,10 +197,12 @@ fn main() -> color_eyre::Result<()> {
             KomobarConfig::read(&default_config_path)?
         }
         Some(ref config) => {
-            tracing::info!(
-                "found configuration file: {}",
-                config.as_path().to_string_lossy()
-            );
+            if !opts.aliases {
+                tracing::info!(
+                    "found configuration file: {}",
+                    config.as_path().to_string_lossy()
+                );
+            }
 
             KomobarConfig::read(config)?
         }
@@ -191,46 +210,65 @@ fn main() -> color_eyre::Result<()> {
 
     let config_path = config_path.unwrap_or(default_config_path);
 
+    if opts.aliases {
+        KomobarConfig::aliases(&std::fs::read_to_string(&config_path)?);
+        std::process::exit(0);
+    }
+
     let state = serde_json::from_str::<komorebi_client::State>(&komorebi_client::send_query(
         &SocketMessage::State,
     )?)?;
 
-    let dpi = dpi_for_monitor(state.monitors.elements()[config.monitor.index].id())?;
-    DPI.store(dpi, Ordering::SeqCst);
+    MONITOR_RIGHT.store(
+        state.monitors.elements()[config.monitor.index].size().right,
+        Ordering::SeqCst,
+    );
 
-    let mut viewport_builder = ViewportBuilder::default()
-        .with_decorations(false)
-        // .with_transparent(config.transparent)
-        .with_taskbar(false)
-        .with_position(Position {
-            x: state.monitors.elements()[config.monitor.index].size().left as f32 / dpi,
-            y: state.monitors.elements()[config.monitor.index].size().top as f32 / dpi,
-        })
-        .with_inner_size({
-            Position {
-                x: state.monitors.elements()[config.monitor.index].size().right as f32 / dpi,
-                y: 50.0 / dpi,
-            }
-        });
+    MONITOR_TOP.store(
+        state.monitors.elements()[config.monitor.index].size().top,
+        Ordering::SeqCst,
+    );
 
-    if let Some(viewport) = &config.viewport {
-        if let Some(mut position) = &viewport.position {
-            position.x /= dpi;
-            position.y /= dpi;
+    MONITOR_TOP.store(
+        state.monitors.elements()[config.monitor.index].size().left,
+        Ordering::SeqCst,
+    );
 
-            let b = viewport_builder.clone();
-            viewport_builder = b.with_position(position);
+    match config.position {
+        None => {
+            config.position = Some(PositionConfig {
+                start: Some(Position {
+                    x: state.monitors.elements()[config.monitor.index].size().left as f32,
+                    y: state.monitors.elements()[config.monitor.index].size().top as f32,
+                }),
+                end: Some(Position {
+                    x: state.monitors.elements()[config.monitor.index].size().right as f32,
+                    y: 50.0,
+                }),
+            })
         }
+        Some(ref mut position) => {
+            if position.start.is_none() {
+                position.start = Some(Position {
+                    x: state.monitors.elements()[config.monitor.index].size().left as f32,
+                    y: state.monitors.elements()[config.monitor.index].size().top as f32,
+                });
+            }
 
-        if let Some(mut inner_size) = &viewport.inner_size {
-            inner_size.x /= dpi;
-            inner_size.y /= dpi;
-
-            let b = viewport_builder.clone();
-            viewport_builder = b.with_inner_size(inner_size);
+            if position.end.is_none() {
+                position.end = Some(Position {
+                    x: state.monitors.elements()[config.monitor.index].size().right as f32,
+                    y: 50.0,
+                })
+            }
         }
     }
 
+    let viewport_builder = ViewportBuilder::default()
+        .with_decorations(false)
+        // .with_transparent(config.transparent)
+        .with_taskbar(false);
+
     let native_options = eframe::NativeOptions {
         viewport: viewport_builder,
         ..Default::default()
@@ -291,7 +329,9 @@ fn main() -> color_eyre::Result<()> {
             std::thread::spawn(move || {
                 let subscriber_name = format!("komorebi-bar-{}", random_word::gen(random_word::Lang::En));
 
-                let listener = komorebi_client::subscribe(&subscriber_name)
+                let listener = komorebi_client::subscribe_with_options(&subscriber_name, SubscribeOptions {
+                    filter_state_changes: true,
+                })
                     .expect("could not subscribe to komorebi notifications");
 
                 tracing::info!("subscribed to komorebi notifications: \"{}\"", subscriber_name);
@@ -333,18 +373,21 @@ fn main() -> color_eyre::Result<()> {
 
                             match String::from_utf8(buffer) {
                                 Ok(notification_string) => {
-                                    if let Ok(notification) =
-                                        serde_json::from_str::<komorebi_client::Notification>(
-                                            &notification_string,
-                                        )
-                                    {
-                                        tracing::debug!("received notification from komorebi");
+                                    match serde_json::from_str::<komorebi_client::Notification>(
+                                        &notification_string,
+                                    ) {
+                                        Ok(notification) => {
+                                            tracing::debug!("received notification from komorebi");
 
-                                        if let Err(error) = tx_gui.send(notification) {
-                                            tracing::error!("could not send komorebi notification update to gui: {error}")
+                                            if let Err(error) = tx_gui.send(notification) {
+                                                tracing::error!("could not send komorebi notification update to gui thread: {error}")
+                                            }
+
+                                            ctx_komorebi.request_repaint();
+                                        }
+                                        Err(error) => {
+                                            tracing::error!("could not deserialize komorebi notification: {error}");
                                         }
-
-                                        ctx_komorebi.request_repaint();
                                     }
                                 }
                                 Err(error) => {

komorebi-bar/src/memory.rs

@@ -1,3 +1,4 @@
+use crate::config::LabelPrefix;
 use crate::widget::BarWidget;
 use crate::WIDGET_SPACING;
 use eframe::egui::text::LayoutJob;
@@ -23,6 +24,8 @@ pub struct MemoryConfig {
     pub enable: bool,
     /// Data refresh interval (default: 10 seconds)
     pub data_refresh_interval: Option<u64>,
+    /// Display label prefix
+    pub label_prefix: Option<LabelPrefix>,
 }
 
 impl From<MemoryConfig> for Memory {
@@ -36,6 +39,7 @@ impl From<MemoryConfig> for Memory {
             enable: value.enable,
             system,
             data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
+            label_prefix: value.label_prefix.unwrap_or(LabelPrefix::IconAndText),
             last_updated: Instant::now(),
         }
     }
@@ -45,6 +49,7 @@ pub struct Memory {
     pub enable: bool,
     system: System,
     data_refresh_interval: u64,
+    label_prefix: LabelPrefix,
     last_updated: Instant,
 }
 
@@ -58,7 +63,12 @@ impl Memory {
 
         let used = self.system.used_memory();
         let total = self.system.total_memory();
-        format!("RAM: {}%", (used * 100) / total)
+        match self.label_prefix {
+            LabelPrefix::Text | LabelPrefix::IconAndText => {
+                format!("RAM: {}%", (used * 100) / total)
+            }
+            LabelPrefix::None | LabelPrefix::Icon => format!("{}%", (used * 100) / total),
+        }
     }
 }
 
@@ -75,7 +85,12 @@ impl BarWidget for Memory {
                     .unwrap_or_else(FontId::default);
 
                 let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::MEMORY.to_string(),
+                    match self.label_prefix {
+                        LabelPrefix::Icon | LabelPrefix::IconAndText => {
+                            egui_phosphor::regular::MEMORY.to_string()
+                        }
+                        LabelPrefix::None | LabelPrefix::Text => String::new(),
+                    },
                     font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,

komorebi-bar/src/network.rs

@@ -1,3 +1,4 @@
+use crate::config::LabelPrefix;
 use crate::widget::BarWidget;
 use crate::WIDGET_SPACING;
 use eframe::egui::text::LayoutJob;
@@ -30,6 +31,8 @@ pub struct NetworkConfig {
     pub network_activity_fill_characters: Option<usize>,
     /// Data refresh interval (default: 10 seconds)
     pub data_refresh_interval: Option<u64>,
+    /// Display label prefix
+    pub label_prefix: Option<LabelPrefix>,
 }
 
 impl From<NetworkConfig> for Network {
@@ -42,6 +45,8 @@ impl From<NetworkConfig> for Network {
 
         let mut default_interface = String::new();
 
+        let prefix = value.label_prefix.unwrap_or(LabelPrefix::Icon);
+
         if let Ok(interface) = netdev::get_default_interface() {
             if let Some(friendly_name) = interface.friendly_name {
                 default_interface.clone_from(&friendly_name);
@@ -50,13 +55,32 @@ impl From<NetworkConfig> for Network {
                     networks_total_data_transmitted.refresh();
                     for (interface_name, data) in &networks_total_data_transmitted {
                         if friendly_name.eq(interface_name) {
-                            last_state_data.push(format!(
-                                "{} {} / {} {}",
-                                egui_phosphor::regular::ARROW_FAT_DOWN,
-                                to_pretty_bytes(data.total_received(), 1),
-                                egui_phosphor::regular::ARROW_FAT_UP,
-                                to_pretty_bytes(data.total_transmitted(), 1),
-                            ))
+                            last_state_data.push(match prefix {
+                                LabelPrefix::None => format!(
+                                    "{} | {}",
+                                    to_pretty_bytes(data.total_received(), 1),
+                                    to_pretty_bytes(data.total_transmitted(), 1),
+                                ),
+                                LabelPrefix::Icon => format!(
+                                    "{} {} | {} {}",
+                                    egui_phosphor::regular::ARROW_FAT_DOWN,
+                                    to_pretty_bytes(data.total_received(), 1),
+                                    egui_phosphor::regular::ARROW_FAT_UP,
+                                    to_pretty_bytes(data.total_transmitted(), 1),
+                                ),
+                                LabelPrefix::Text => format!(
+                                    "\u{2211}DOWN: {} | \u{2211}UP: {}",
+                                    to_pretty_bytes(data.total_received(), 1),
+                                    to_pretty_bytes(data.total_transmitted(), 1),
+                                ),
+                                LabelPrefix::IconAndText => format!(
+                                    "{} \u{2211}DOWN: {} | {} \u{2211}UP: {}",
+                                    egui_phosphor::regular::ARROW_FAT_DOWN,
+                                    to_pretty_bytes(data.total_received(), 1),
+                                    egui_phosphor::regular::ARROW_FAT_UP,
+                                    to_pretty_bytes(data.total_transmitted(), 1),
+                                ),
+                            })
                         }
                     }
                 }
@@ -65,14 +89,40 @@ impl From<NetworkConfig> for Network {
                     networks_network_activity.refresh();
                     for (interface_name, data) in &networks_network_activity {
                         if friendly_name.eq(interface_name) {
-                            last_state_transmitted.push(format!(
-                                "{} {: >width$}/s {} {: >width$}/s",
-                                egui_phosphor::regular::ARROW_FAT_DOWN,
-                                to_pretty_bytes(data.received(), 1),
-                                egui_phosphor::regular::ARROW_FAT_UP,
-                                to_pretty_bytes(data.transmitted(), 1),
-                                width = value.network_activity_fill_characters.unwrap_or_default(),
-                            ))
+                            last_state_transmitted.push(match prefix {
+                                LabelPrefix::None => format!(
+                                    "{: >width$}/s | {: >width$}/s",
+                                    to_pretty_bytes(data.received(), 1),
+                                    to_pretty_bytes(data.transmitted(), 1),
+                                    width =
+                                        value.network_activity_fill_characters.unwrap_or_default(),
+                                ),
+                                LabelPrefix::Icon => format!(
+                                    "{} {: >width$}/s | {} {: >width$}/s",
+                                    egui_phosphor::regular::ARROW_FAT_DOWN,
+                                    to_pretty_bytes(data.received(), 1),
+                                    egui_phosphor::regular::ARROW_FAT_UP,
+                                    to_pretty_bytes(data.transmitted(), 1),
+                                    width =
+                                        value.network_activity_fill_characters.unwrap_or_default(),
+                                ),
+                                LabelPrefix::Text => format!(
+                                    "DOWN: {: >width$}/s | UP: {: >width$}/s",
+                                    to_pretty_bytes(data.received(), 1),
+                                    to_pretty_bytes(data.transmitted(), 1),
+                                    width =
+                                        value.network_activity_fill_characters.unwrap_or_default(),
+                                ),
+                                LabelPrefix::IconAndText => format!(
+                                    "{} DOWN: {: >width$}/s | {} UP: {: >width$}/s",
+                                    egui_phosphor::regular::ARROW_FAT_DOWN,
+                                    to_pretty_bytes(data.received(), 1),
+                                    egui_phosphor::regular::ARROW_FAT_UP,
+                                    to_pretty_bytes(data.transmitted(), 1),
+                                    width =
+                                        value.network_activity_fill_characters.unwrap_or_default(),
+                                ),
+                            })
                         }
                     }
                 }
@@ -85,6 +135,7 @@ impl From<NetworkConfig> for Network {
             networks_network_activity,
             default_interface,
             data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
+            label_prefix: prefix,
             show_total_data_transmitted: value.show_total_data_transmitted,
             show_network_activity: value.show_network_activity,
             network_activity_fill_characters: value
@@ -105,6 +156,7 @@ pub struct Network {
     networks_total_data_transmitted: Networks,
     networks_network_activity: Networks,
     data_refresh_interval: u64,
+    label_prefix: LabelPrefix,
     default_interface: String,
     last_state_total_data_transmitted: Vec<String>,
     last_state_network_activity: Vec<String>,
@@ -138,14 +190,62 @@ impl Network {
                         self.networks_network_activity.refresh();
                         for (interface_name, data) in &self.networks_network_activity {
                             if friendly_name.eq(interface_name) {
-                                outputs.push(format!(
-                                    "{} {: >width$}/s {} {: >width$}/s",
-                                    egui_phosphor::regular::ARROW_FAT_DOWN,
-                                    to_pretty_bytes(data.received(), self.data_refresh_interval),
-                                    egui_phosphor::regular::ARROW_FAT_UP,
-                                    to_pretty_bytes(data.transmitted(), self.data_refresh_interval),
-                                    width = self.network_activity_fill_characters,
-                                ))
+                                outputs.push(match self.label_prefix {
+                                    LabelPrefix::None => format!(
+                                        "{: >width$}/s | {: >width$}/s",
+                                        to_pretty_bytes(
+                                            data.received(),
+                                            self.data_refresh_interval
+                                        ),
+                                        to_pretty_bytes(
+                                            data.transmitted(),
+                                            self.data_refresh_interval
+                                        ),
+                                        width = self.network_activity_fill_characters,
+                                    ),
+                                    LabelPrefix::Icon => format!(
+                                        "{} {: >width$}/s | {} {: >width$}/s",
+                                        egui_phosphor::regular::ARROW_FAT_DOWN,
+                                        to_pretty_bytes(
+                                            data.received(),
+                                            self.data_refresh_interval
+                                        ),
+                                        egui_phosphor::regular::ARROW_FAT_UP,
+                                        to_pretty_bytes(
+                                            data.transmitted(),
+                                            self.data_refresh_interval
+                                        ),
+                                        width = self.network_activity_fill_characters,
+                                    ),
+                                    LabelPrefix::Text => format!(
+                                        "DOWN: {: >width$}/s | UP: {: >width$}/s",
+                                        to_pretty_bytes(
+                                            data.received(),
+                                            self.data_refresh_interval
+                                        ),
+                                        to_pretty_bytes(
+                                            data.transmitted(),
+                                            self.data_refresh_interval
+                                        ),
+                                        width = self.network_activity_fill_characters,
+                                    ),
+                                    LabelPrefix::IconAndText => {
+                                        format!(
+                                            "{} DOWN: {: >width$}/s | {} UP: {: >width$}/s",
+                                            egui_phosphor::regular::ARROW_FAT_DOWN,
+                                            to_pretty_bytes(
+                                                data.received(),
+                                                self.data_refresh_interval
+                                            ),
+                                            egui_phosphor::regular::ARROW_FAT_UP,
+                                            to_pretty_bytes(
+                                                data.transmitted(),
+                                                self.data_refresh_interval
+                                            ),
+                                            width = self.network_activity_fill_characters,
+                                        )
+                                    }
+                                })
                             }
                         }
                     }
@@ -176,13 +276,32 @@ impl Network {
 
                         for (interface_name, data) in &self.networks_total_data_transmitted {
                             if friendly_name.eq(interface_name) {
-                                outputs.push(format!(
-                                    "{} {} / {} {}",
-                                    egui_phosphor::regular::ARROW_FAT_DOWN,
-                                    to_pretty_bytes(data.total_received(), 1),
-                                    egui_phosphor::regular::ARROW_FAT_UP,
-                                    to_pretty_bytes(data.total_transmitted(), 1),
-                                ))
+                                outputs.push(match self.label_prefix {
+                                    LabelPrefix::None => format!(
+                                        "{} | {}",
+                                        to_pretty_bytes(data.total_received(), 1),
+                                        to_pretty_bytes(data.total_transmitted(), 1),
+                                    ),
+                                    LabelPrefix::Icon => format!(
+                                        "{} {} | {} {}",
+                                        egui_phosphor::regular::ARROW_FAT_DOWN,
+                                        to_pretty_bytes(data.total_received(), 1),
+                                        egui_phosphor::regular::ARROW_FAT_UP,
+                                        to_pretty_bytes(data.total_transmitted(), 1),
+                                    ),
+                                    LabelPrefix::Text => format!(
+                                        "\u{2211}DOWN: {} | \u{2211}UP: {}",
+                                        to_pretty_bytes(data.total_received(), 1),
+                                        to_pretty_bytes(data.total_transmitted(), 1),
+                                    ),
+                                    LabelPrefix::IconAndText => format!(
+                                        "{} \u{2211}DOWN: {} | {} \u{2211}UP: {}",
+                                        egui_phosphor::regular::ARROW_FAT_DOWN,
+                                        to_pretty_bytes(data.total_received(), 1),
+                                        egui_phosphor::regular::ARROW_FAT_UP,
+                                        to_pretty_bytes(data.total_transmitted(), 1),
+                                    ),
+                                })
                             }
                         }
                     }
@@ -227,12 +346,21 @@ impl BarWidget for Network {
                     .unwrap_or_else(FontId::default);
 
                 let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::WIFI_HIGH.to_string(),
+                    match self.label_prefix {
+                        LabelPrefix::Icon | LabelPrefix::IconAndText => {
+                            egui_phosphor::regular::WIFI_HIGH.to_string()
+                        }
+                        LabelPrefix::None | LabelPrefix::Text => String::new(),
+                    },
                     font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,
                 );
 
+                if let LabelPrefix::Text | LabelPrefix::IconAndText = self.label_prefix {
+                    self.default_interface.insert_str(0, "NET: ");
+                }
+
                 layout_job.append(
                     &self.default_interface,
                     10.0,

komorebi-bar/src/storage.rs

@@ -1,3 +1,4 @@
+use crate::config::LabelPrefix;
 use crate::widget::BarWidget;
 use crate::WIDGET_SPACING;
 use eframe::egui::text::LayoutJob;
@@ -22,6 +23,8 @@ pub struct StorageConfig {
     pub enable: bool,
     /// Data refresh interval (default: 10 seconds)
     pub data_refresh_interval: Option<u64>,
+    /// Display label prefix
+    pub label_prefix: Option<LabelPrefix>,
 }
 
 impl From<StorageConfig> for Storage {
@@ -30,6 +33,7 @@ impl From<StorageConfig> for Storage {
             enable: value.enable,
             disks: Disks::new_with_refreshed_list(),
             data_refresh_interval: value.data_refresh_interval.unwrap_or(10),
+            label_prefix: value.label_prefix.unwrap_or(LabelPrefix::IconAndText),
             last_updated: Instant::now(),
         }
     }
@@ -39,6 +43,7 @@ pub struct Storage {
     pub enable: bool,
     disks: Disks,
     data_refresh_interval: u64,
+    label_prefix: LabelPrefix,
     last_updated: Instant,
 }
 
@@ -58,11 +63,12 @@ impl Storage {
             let available = disk.available_space();
             let used = total - available;
 
-            disks.push(format!(
-                "{} {}%",
-                mount.to_string_lossy(),
-                (used * 100) / total
-            ))
+            disks.push(match self.label_prefix {
+                LabelPrefix::Text | LabelPrefix::IconAndText => {
+                    format!("{} {}%", mount.to_string_lossy(), (used * 100) / total)
+                }
+                LabelPrefix::None | LabelPrefix::Icon => format!("{}%", (used * 100) / total),
+            })
         }
 
         disks.sort();
@@ -84,7 +90,12 @@ impl BarWidget for Storage {
 
             for output in self.output() {
                 let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::HARD_DRIVES.to_string(),
+                    match self.label_prefix {
+                        LabelPrefix::Icon | LabelPrefix::IconAndText => {
+                            egui_phosphor::regular::HARD_DRIVES.to_string()
+                        }
+                        LabelPrefix::None | LabelPrefix::Text => String::new(),
+                    },
                     font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,

komorebi-bar/src/time.rs

@@ -1,3 +1,4 @@
+use crate::config::LabelPrefix;
 use crate::widget::BarWidget;
 use crate::WIDGET_SPACING;
 use eframe::egui::text::LayoutJob;
@@ -18,6 +19,8 @@ pub struct TimeConfig {
     pub enable: bool,
     /// Set the Time format
     pub format: TimeFormat,
+    /// Display label prefix
+    pub label_prefix: Option<LabelPrefix>,
 }
 
 impl From<TimeConfig> for Time {
@@ -25,6 +28,7 @@ impl From<TimeConfig> for Time {
         Self {
             enable: value.enable,
             format: value.format,
+            label_prefix: value.label_prefix.unwrap_or(LabelPrefix::Icon),
         }
     }
 }
@@ -61,6 +65,7 @@ impl TimeFormat {
 pub struct Time {
     pub enable: bool,
     pub format: TimeFormat,
+    label_prefix: LabelPrefix,
 }
 
 impl Time {
@@ -74,7 +79,7 @@ impl Time {
 impl BarWidget for Time {
     fn render(&mut self, ctx: &Context, ui: &mut Ui) {
         if self.enable {
-            let output = self.output();
+            let mut output = self.output();
             if !output.is_empty() {
                 let font_id = ctx
                     .style()
@@ -84,12 +89,21 @@ impl BarWidget for Time {
                     .unwrap_or_else(FontId::default);
 
                 let mut layout_job = LayoutJob::simple(
-                    egui_phosphor::regular::CLOCK.to_string(),
+                    match self.label_prefix {
+                        LabelPrefix::Icon | LabelPrefix::IconAndText => {
+                            egui_phosphor::regular::CLOCK.to_string()
+                        }
+                        LabelPrefix::None | LabelPrefix::Text => String::new(),
+                    },
                     font_id.clone(),
                     ctx.style().visuals.selection.stroke.color,
                     100.0,
                 );
 
+                if let LabelPrefix::Text | LabelPrefix::IconAndText = self.label_prefix {
+                    output.insert_str(0, "TIME: ");
+                }
+
                 layout_job.append(
                     &output,
                     10.0,

komorebi-bar/src/widget.rs

@@ -1,5 +1,7 @@
 use crate::battery::Battery;
 use crate::battery::BatteryConfig;
+use crate::cpu::Cpu;
+use crate::cpu::CpuConfig;
 use crate::date::Date;
 use crate::date::DateConfig;
 use crate::komorebi::Komorebi;
@@ -27,6 +29,7 @@ pub trait BarWidget {
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 pub enum WidgetConfig {
     Battery(BatteryConfig),
+    Cpu(CpuConfig),
     Date(DateConfig),
     Komorebi(KomorebiConfig),
     Media(MediaConfig),
@@ -40,6 +43,7 @@ impl WidgetConfig {
     pub fn as_boxed_bar_widget(&self) -> Box<dyn BarWidget> {
         match self {
             WidgetConfig::Battery(config) => Box::new(Battery::from(*config)),
+            WidgetConfig::Cpu(config) => Box::new(Cpu::from(*config)),
             WidgetConfig::Date(config) => Box::new(Date::from(config.clone())),
             WidgetConfig::Komorebi(config) => Box::new(Komorebi::from(config)),
             WidgetConfig::Media(config) => Box::new(Media::from(*config)),

komorebi-client/src/lib.rs

@@ -44,6 +44,7 @@ pub use komorebi::RuleDebug;
 pub use komorebi::StackbarConfig;
 pub use komorebi::State;
 pub use komorebi::StaticConfig;
+pub use komorebi::SubscribeOptions;
 pub use komorebi::TabsConfig;
 
 use komorebi::DATA_DIR;
@@ -96,3 +97,29 @@ pub fn subscribe(name: &str) -> std::io::Result<UnixListener> {
 
     Ok(listener)
 }
+
+pub fn subscribe_with_options(
+    name: &str,
+    options: SubscribeOptions,
+) -> std::io::Result<UnixListener> {
+    let socket = DATA_DIR.join(name);
+
+    match std::fs::remove_file(&socket) {
+        Ok(()) => {}
+        Err(error) => match error.kind() {
+            std::io::ErrorKind::NotFound => {}
+            _ => {
+                return Err(error);
+            }
+        },
+    };
+
+    let listener = UnixListener::bind(&socket)?;
+
+    send_message(&SocketMessage::AddSubscriberSocketWithOptions(
+        name.to_string(),
+        options,
+    ))?;
+
+    Ok(listener)
+}

komorebi-gui/src/main.rs

@@ -27,7 +27,6 @@ fn main() {
         viewport: ViewportBuilder::default()
             .with_always_on_top()
             .with_inner_size([320.0, 500.0]),
-        follow_system_theme: true,
         ..Default::default()
     };
 
@@ -234,7 +233,8 @@ extern "system" fn enum_window(
 
 fn json_view_ui(ui: &mut egui::Ui, code: &str) {
     let language = "json";
-    let theme = egui_extras::syntax_highlighting::CodeTheme::from_memory(ui.ctx());
+    let theme =
+        egui_extras::syntax_highlighting::CodeTheme::from_memory(ui.ctx(), &ui.ctx().style());
     egui_extras::syntax_highlighting::code_view_ui(ui, &theme, code, language);
 }
 

komorebi-themes/Cargo.toml

@@ -4,8 +4,9 @@ version = "0.1.30"
 edition = "2021"
 
 [dependencies]
-base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "a2c48f45782c5604bf5482d3873021a9fe45ea1a" }
-catppuccin-egui = { version = "5.1", default-features = false, features = ["egui28"] }
+base16-egui-themes = { git = "https://github.com/LGUG2Z/base16-egui-themes", rev = "57c38257cb0c6434321320d3746049bd58c34674" }
+catppuccin-egui = { git = "https://github.com/LGUG2Z/catppuccin-egui", rev = "f579847bf2f552b144361d5a78ed8cf360b55cbb" }
+#catppuccin-egui = { version = "5", default-features = false, features = ["egui28"] }
 eframe = { workspace = true }
 schemars = { workspace = true }
 serde = { workspace = true }

komorebi-themes/src/lib.rs

@@ -124,35 +124,39 @@ pub enum CatppuccinValue {
     Crust,
 }
 
+pub fn color32_compat(rgba: [u8; 4]) -> Color32 {
+    Color32::from_rgba_unmultiplied(rgba[0], rgba[1], rgba[2], rgba[3])
+}
+
 impl CatppuccinValue {
     pub fn color32(&self, theme: catppuccin_egui::Theme) -> Color32 {
         match self {
-            CatppuccinValue::Rosewater => theme.rosewater,
-            CatppuccinValue::Flamingo => theme.flamingo,
-            CatppuccinValue::Pink => theme.pink,
-            CatppuccinValue::Mauve => theme.mauve,
-            CatppuccinValue::Red => theme.red,
-            CatppuccinValue::Maroon => theme.maroon,
-            CatppuccinValue::Peach => theme.peach,
-            CatppuccinValue::Yellow => theme.yellow,
-            CatppuccinValue::Green => theme.green,
-            CatppuccinValue::Teal => theme.teal,
-            CatppuccinValue::Sky => theme.sky,
-            CatppuccinValue::Sapphire => theme.sapphire,
-            CatppuccinValue::Blue => theme.blue,
-            CatppuccinValue::Lavender => theme.lavender,
-            CatppuccinValue::Text => theme.text,
-            CatppuccinValue::Subtext1 => theme.subtext1,
-            CatppuccinValue::Subtext0 => theme.subtext0,
-            CatppuccinValue::Overlay2 => theme.overlay2,
-            CatppuccinValue::Overlay1 => theme.overlay1,
-            CatppuccinValue::Overlay0 => theme.overlay0,
-            CatppuccinValue::Surface2 => theme.surface2,
-            CatppuccinValue::Surface1 => theme.surface1,
-            CatppuccinValue::Surface0 => theme.surface0,
-            CatppuccinValue::Base => theme.base,
-            CatppuccinValue::Mantle => theme.mantle,
-            CatppuccinValue::Crust => theme.crust,
+            CatppuccinValue::Rosewater => color32_compat(theme.rosewater.to_srgba_unmultiplied()),
+            CatppuccinValue::Flamingo => color32_compat(theme.flamingo.to_srgba_unmultiplied()),
+            CatppuccinValue::Pink => color32_compat(theme.pink.to_srgba_unmultiplied()),
+            CatppuccinValue::Mauve => color32_compat(theme.mauve.to_srgba_unmultiplied()),
+            CatppuccinValue::Red => color32_compat(theme.red.to_srgba_unmultiplied()),
+            CatppuccinValue::Maroon => color32_compat(theme.maroon.to_srgba_unmultiplied()),
+            CatppuccinValue::Peach => color32_compat(theme.peach.to_srgba_unmultiplied()),
+            CatppuccinValue::Yellow => color32_compat(theme.yellow.to_srgba_unmultiplied()),
+            CatppuccinValue::Green => color32_compat(theme.green.to_srgba_unmultiplied()),
+            CatppuccinValue::Teal => color32_compat(theme.teal.to_srgba_unmultiplied()),
+            CatppuccinValue::Sky => color32_compat(theme.sky.to_srgba_unmultiplied()),
+            CatppuccinValue::Sapphire => color32_compat(theme.sapphire.to_srgba_unmultiplied()),
+            CatppuccinValue::Blue => color32_compat(theme.blue.to_srgba_unmultiplied()),
+            CatppuccinValue::Lavender => color32_compat(theme.lavender.to_srgba_unmultiplied()),
+            CatppuccinValue::Text => color32_compat(theme.text.to_srgba_unmultiplied()),
+            CatppuccinValue::Subtext1 => color32_compat(theme.subtext1.to_srgba_unmultiplied()),
+            CatppuccinValue::Subtext0 => color32_compat(theme.subtext0.to_srgba_unmultiplied()),
+            CatppuccinValue::Overlay2 => color32_compat(theme.overlay2.to_srgba_unmultiplied()),
+            CatppuccinValue::Overlay1 => color32_compat(theme.overlay1.to_srgba_unmultiplied()),
+            CatppuccinValue::Overlay0 => color32_compat(theme.overlay0.to_srgba_unmultiplied()),
+            CatppuccinValue::Surface2 => color32_compat(theme.surface2.to_srgba_unmultiplied()),
+            CatppuccinValue::Surface1 => color32_compat(theme.surface1.to_srgba_unmultiplied()),
+            CatppuccinValue::Surface0 => color32_compat(theme.surface0.to_srgba_unmultiplied()),
+            CatppuccinValue::Base => color32_compat(theme.base.to_srgba_unmultiplied()),
+            CatppuccinValue::Mantle => color32_compat(theme.mantle.to_srgba_unmultiplied()),
+            CatppuccinValue::Crust => color32_compat(theme.crust.to_srgba_unmultiplied()),
         }
     }
 }

komorebi/src/border_manager/mod.rs

@@ -49,6 +49,8 @@ lazy_static! {
     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))));
+    pub static ref FLOATING: AtomicU32 =
+        AtomicU32::new(u32::from(Colour::Rgb(Rgb::new(245, 245, 165))));
 }
 
 lazy_static! {
@@ -57,7 +59,7 @@ lazy_static! {
     static ref FOCUS_STATE: Mutex<HashMap<isize, WindowKind>> = Mutex::new(HashMap::new());
 }
 
-pub struct Notification;
+pub struct Notification(pub Option<isize>);
 
 static CHANNEL: OnceLock<(Sender<Notification>, Receiver<Notification>)> = OnceLock::new();
 
@@ -73,8 +75,8 @@ fn event_rx() -> Receiver<Notification> {
     channel().1.clone()
 }
 
-pub fn send_notification() {
-    if event_tx().try_send(Notification).is_err() {
+pub fn send_notification(hwnd: Option<isize>) {
+    if event_tx().try_send(Notification(hwnd)).is_err() {
         tracing::warn!("channel is full; dropping notification")
     }
 }
@@ -118,6 +120,7 @@ fn window_kind_colour(focus_kind: WindowKind) -> u32 {
         WindowKind::Single => FOCUSED.load(Ordering::SeqCst),
         WindowKind::Stack => STACK.load(Ordering::SeqCst),
         WindowKind::Monocle => MONOCLE.load(Ordering::SeqCst),
+        WindowKind::Floating => FLOATING.load(Ordering::SeqCst),
     }
 }
 
@@ -139,19 +142,29 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
     BORDER_TEMPORARILY_DISABLED.store(false, Ordering::SeqCst);
     let receiver = event_rx();
-    event_tx().send(Notification)?;
+    event_tx().send(Notification(None))?;
 
     let mut previous_snapshot = Ring::default();
     let mut previous_pending_move_op = None;
     let mut previous_is_paused = false;
+    let mut previous_notification: Option<Notification> = None;
 
-    'receiver: for _ in receiver {
+    'receiver: for notification in receiver {
         // Check the wm state every time we receive a notification
         let state = wm.lock();
         let is_paused = state.is_paused;
         let focused_monitor_idx = state.focused_monitor_idx();
+        let focused_workspace_idx =
+            state.monitors.elements()[focused_monitor_idx].focused_workspace_idx();
         let monitors = state.monitors.clone();
         let pending_move_op = state.pending_move_op;
+        let floating_window_hwnds = state.monitors.elements()[focused_monitor_idx].workspaces()
+            [focused_workspace_idx]
+            .floating_windows()
+            .iter()
+            .map(|w| w.hwnd)
+            .collect::<Vec<_>>();
+
         drop(state);
 
         match IMPLEMENTATION.load() {
@@ -220,6 +233,21 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     should_process_notification = true;
                 }
 
+                // when we switch focus to a floating window
+                if !should_process_notification
+                    && floating_window_hwnds.contains(&notification.0.unwrap_or_default())
+                {
+                    should_process_notification = true;
+                }
+
+                if !should_process_notification {
+                    if let Some(ref previous) = previous_notification {
+                        if previous.0.unwrap_or_default() != notification.0.unwrap_or_default() {
+                            should_process_notification = true;
+                        }
+                    }
+                }
+
                 if !should_process_notification {
                     tracing::trace!("monitor state matches latest snapshot, skipping notification");
                     continue 'receiver;
@@ -345,16 +373,20 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         }
 
                         // Destroy any borders not associated with the focused workspace
-                        let container_ids = ws
+                        let mut container_and_floating_window_ids = ws
                             .containers()
                             .iter()
                             .map(|c| c.id().clone())
                             .collect::<Vec<_>>();
 
+                        for w in ws.floating_windows() {
+                            container_and_floating_window_ids.push(w.hwnd.to_string());
+                        }
+
                         let mut to_remove = vec![];
                         for (id, border) in borders.iter() {
                             if borders_monitors.get(id).copied().unwrap_or_default() == monitor_idx
-                                && !container_ids.contains(id)
+                                && !container_and_floating_window_ids.contains(id)
                             {
                                 border.destroy()?;
                                 to_remove.push(id.clone());
@@ -366,8 +398,14 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         }
 
                         for (idx, c) in ws.containers().iter().enumerate() {
+                            let hwnd = c.focused_window().copied().unwrap_or_default().hwnd;
+                            let notification_hwnd = notification.0.unwrap_or_default();
+
                             // Update border when moving or resizing with mouse
-                            if pending_move_op.is_some() && idx == ws.focused_container_idx() {
+                            if pending_move_op.is_some()
+                                && idx == ws.focused_container_idx()
+                                && hwnd == notification_hwnd
+                            {
                                 let restore_z_order = Z_ORDER.load();
                                 Z_ORDER.store(ZOrder::TopMost);
 
@@ -446,6 +484,101 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
 
                             border.update(&rect, should_invalidate)?;
                         }
+
+                        {
+                            let restore_z_order = Z_ORDER.load();
+                            Z_ORDER.store(ZOrder::TopMost);
+
+                            'windows: for window in ws.floating_windows() {
+                                let hwnd = window.hwnd;
+                                let notification_hwnd = notification.0.unwrap_or_default();
+
+                                if pending_move_op.is_some() && hwnd == notification_hwnd {
+                                    let mut rect = WindowsApi::window_rect(hwnd)?;
+
+                                    while WindowsApi::lbutton_is_pressed() {
+                                        let border = match borders.entry(hwnd.to_string()) {
+                                            Entry::Occupied(entry) => entry.into_mut(),
+                                            Entry::Vacant(entry) => {
+                                                if let Ok(border) =
+                                                    Border::create(&hwnd.to_string())
+                                                {
+                                                    entry.insert(border)
+                                                } else {
+                                                    continue 'monitors;
+                                                }
+                                            }
+                                        };
+
+                                        let new_rect = WindowsApi::window_rect(hwnd)?;
+
+                                        if rect != new_rect {
+                                            rect = new_rect;
+                                            border.update(&rect, true)?;
+                                        }
+                                    }
+
+                                    Z_ORDER.store(restore_z_order);
+
+                                    continue 'monitors;
+                                }
+
+                                let border = match borders.entry(window.hwnd.to_string()) {
+                                    Entry::Occupied(entry) => entry.into_mut(),
+                                    Entry::Vacant(entry) => {
+                                        if let Ok(border) = Border::create(&window.hwnd.to_string())
+                                        {
+                                            entry.insert(border)
+                                        } else {
+                                            continue 'monitors;
+                                        }
+                                    }
+                                };
+
+                                borders_monitors.insert(window.hwnd.to_string(), monitor_idx);
+
+                                let mut should_destroy = false;
+
+                                if let Some(notification_hwnd) = notification.0 {
+                                    if notification_hwnd != window.hwnd {
+                                        should_destroy = true;
+                                    }
+                                }
+
+                                if WindowsApi::foreground_window().unwrap_or_default()
+                                    != window.hwnd
+                                {
+                                    should_destroy = true;
+                                }
+
+                                if should_destroy {
+                                    border.destroy()?;
+                                    borders.remove(&window.hwnd.to_string());
+                                    borders_monitors.remove(&window.hwnd.to_string());
+                                    continue 'windows;
+                                }
+
+                                #[allow(unused_assignments)]
+                                let mut last_focus_state = None;
+                                let new_focus_state = WindowKind::Floating;
+                                {
+                                    let mut focus_state = FOCUS_STATE.lock();
+                                    last_focus_state =
+                                        focus_state.insert(border.hwnd, new_focus_state);
+                                }
+
+                                let rect = WindowsApi::window_rect(window.hwnd)?;
+
+                                let should_invalidate = match last_focus_state {
+                                    None => true,
+                                    Some(last_focus_state) => last_focus_state != new_focus_state,
+                                };
+
+                                border.update(&rect, should_invalidate)?;
+                            }
+
+                            Z_ORDER.store(restore_z_order);
+                        }
                     }
                 }
             }
@@ -454,6 +587,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
         previous_snapshot = monitors;
         previous_pending_move_op = pending_move_op;
         previous_is_paused = is_paused;
+        previous_notification = Some(notification);
     }
 
     Ok(())

komorebi/src/container.rs

@@ -9,7 +9,7 @@ use serde::Serialize;
 use crate::ring::Ring;
 use crate::window::Window;
 
-#[derive(Debug, Clone, Serialize, Deserialize, Getters, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Getters, JsonSchema)]
 pub struct Container {
     #[getset(get = "pub")]
     id: String,
@@ -27,12 +27,6 @@ impl Default for Container {
     }
 }
 
-impl PartialEq for Container {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
-    }
-}
-
 impl Container {
     pub fn hide(&self, omit: Option<isize>) {
         for window in self.windows().iter().rev() {

komorebi/src/core/config_generation.rs

@@ -116,7 +116,8 @@ pub struct ApplicationConfiguration {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub options: Option<Vec<ApplicationOptions>>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub float_identifiers: Option<Vec<MatchingRule>>,
+    #[serde(alias = "float_identifiers")]
+    pub ignore_identifiers: Option<Vec<MatchingRule>>,
 }
 
 impl ApplicationConfiguration {
@@ -187,7 +188,7 @@ impl ApplicationConfigurationGenerator {
 
         let mut lines = vec![String::from("# Generated by komorebic.exe"), String::new()];
 
-        let mut float_rules = vec![];
+        let mut ignore_rules = vec![];
 
         for app in cfgen {
             lines.push(format!("# {}", app.name));
@@ -201,15 +202,15 @@ impl ApplicationConfigurationGenerator {
                 }
             }
 
-            if let Some(float_identifiers) = app.float_identifiers {
-                for matching_rule in float_identifiers {
+            if let Some(ignore_identifiers) = app.ignore_identifiers {
+                for matching_rule in ignore_identifiers {
                     if let MatchingRule::Simple(float) = matching_rule {
                         let float_rule =
                             format!("komorebic.exe float-rule {} \"{}\"", float.kind, float.id);
 
                         // Don't want to send duped signals especially as configs get larger
-                        if !float_rules.contains(&float_rule) {
-                            float_rules.push(float_rule.clone());
+                        if !ignore_rules.contains(&float_rule) {
+                            ignore_rules.push(float_rule.clone());
 
                             // if let Some(comment) = float.comment {
                             //     lines.push(format!("# {comment}"));
@@ -238,7 +239,7 @@ impl ApplicationConfigurationGenerator {
 
         let mut lines = vec![String::from("; Generated by komorebic.exe"), String::new()];
 
-        let mut float_rules = vec![];
+        let mut ignore_rules = vec![];
 
         for app in cfgen {
             lines.push(format!("; {}", app.name));
@@ -252,8 +253,8 @@ impl ApplicationConfigurationGenerator {
                 }
             }
 
-            if let Some(float_identifiers) = app.float_identifiers {
-                for matching_rule in float_identifiers {
+            if let Some(ignore_identifiers) = app.ignore_identifiers {
+                for matching_rule in ignore_identifiers {
                     if let MatchingRule::Simple(float) = matching_rule {
                         let float_rule = format!(
                             "RunWait('komorebic.exe float-rule {} \"{}\"', , \"Hide\")",
@@ -261,8 +262,8 @@ impl ApplicationConfigurationGenerator {
                         );
 
                         // Don't want to send duped signals especially as configs get larger
-                        if !float_rules.contains(&float_rule) {
-                            float_rules.push(float_rule.clone());
+                        if !ignore_rules.contains(&float_rule) {
+                            ignore_rules.push(float_rule.clone());
 
                             // if let Some(comment) = float.comment {
                             //     lines.push(format!("; {comment}"));

komorebi/src/core/mod.rs

@@ -77,6 +77,7 @@ pub enum SocketMessage {
     ToggleMonocle,
     ToggleMaximize,
     ToggleWindowContainerBehaviour,
+    ToggleFloatOverride,
     WindowHidingBehaviour(HidingBehaviour),
     ToggleCrossMonitorMoveBehaviour,
     CrossMonitorMoveBehaviour(MoveBehaviour),
@@ -90,6 +91,8 @@ pub enum SocketMessage {
     CycleLayout(CycleDirection),
     ChangeLayoutCustom(PathBuf),
     FlipLayout(Axis),
+    ToggleWorkspaceWindowContainerBehaviour,
+    ToggleWorkspaceFloatOverride,
     // Monitor and Workspace Commands
     MonitorIndexPreference(usize, i32, i32, i32, i32),
     DisplayIndexPreference(usize, String),
@@ -174,7 +177,8 @@ pub enum SocketMessage {
     ClearWorkspaceRules(usize, usize),
     ClearNamedWorkspaceRules(String),
     ClearAllWorkspaceRules,
-    FloatRule(ApplicationIdentifier, String),
+    #[serde(alias = "FloatRule")]
+    IgnoreRule(ApplicationIdentifier, String),
     ManageRule(ApplicationIdentifier, String),
     IdentifyObjectNameChangeApplication(ApplicationIdentifier, String),
     IdentifyTrayApplication(ApplicationIdentifier, String),
@@ -192,6 +196,7 @@ pub enum SocketMessage {
     RemoveTitleBar(ApplicationIdentifier, String),
     ToggleTitleBars,
     AddSubscriberSocket(String),
+    AddSubscriberSocketWithOptions(String, SubscribeOptions),
     RemoveSubscriberSocket(String),
     AddSubscriberPipe(String),
     RemoveSubscriberPipe(String),
@@ -217,6 +222,12 @@ impl FromStr for SocketMessage {
     }
 }
 
+#[derive(Default, Debug, Copy, Clone, Eq, PartialEq, Serialize, Deserialize, JsonSchema)]
+pub struct SubscribeOptions {
+    /// Only emit notifications when the window manager state has changed
+    pub filter_state_changes: bool,
+}
+
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Display, Serialize, Deserialize, JsonSchema)]
 pub enum StackbarMode {
     Always,
@@ -294,6 +305,7 @@ pub enum WindowKind {
     Stack,
     Monocle,
     Unfocused,
+    Floating,
 }
 
 #[derive(
@@ -331,7 +343,16 @@ pub enum ApplicationIdentifier {
 }
 
 #[derive(
-    Copy, Clone, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+    Copy,
+    Clone,
+    Debug,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
 )]
 pub enum FocusFollowsMouseImplementation {
     /// A custom FFM implementation (slightly more CPU-intensive)
@@ -340,18 +361,48 @@ pub enum FocusFollowsMouseImplementation {
     Windows,
 }
 
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, JsonSchema, PartialEq)]
+pub struct WindowManagementBehaviour {
+    /// The current WindowContainerBehaviour to be used
+    pub current_behaviour: WindowContainerBehaviour,
+    /// Override of `current_behaviour` to open new windows as floating windows
+    /// that can be later toggled to tiled, when false it will default to
+    /// `current_behaviour` again.
+    pub float_override: bool,
+}
+
 #[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
+    PartialEq,
 )]
 pub enum WindowContainerBehaviour {
     /// Create a new container for each new window
+    #[default]
     Create,
     /// Append new windows to the focused window container
     Append,
 }
 
 #[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+    Clone,
+    Copy,
+    Debug,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
 )]
 pub enum MoveBehaviour {
     /// Swap the window container with the window container at the edge of the adjacent monitor
@@ -385,7 +436,16 @@ pub enum HidingBehaviour {
 }
 
 #[derive(
-    Clone, Copy, Debug, Serialize, Deserialize, Display, EnumString, ValueEnum, JsonSchema,
+    Clone,
+    Copy,
+    Debug,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    Display,
+    EnumString,
+    ValueEnum,
+    JsonSchema,
 )]
 pub enum OperationBehaviour {
     /// Process komorebic commands on temporarily unmanaged/floated windows

komorebi/src/lib.rs

@@ -139,7 +139,7 @@ lazy_static! {
     static ref REGEX_IDENTIFIERS: Arc<Mutex<HashMap<String, Regex>>> =
         Arc::new(Mutex::new(HashMap::new()));
     static ref MANAGE_IDENTIFIERS: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![]));
-    static ref FLOAT_IDENTIFIERS: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![
+    static ref IGNORE_IDENTIFIERS: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(vec![
         // mstsc.exe creates these on Windows 11 when a WSL process is launched
         // https://github.com/LGUG2Z/komorebi/issues/74
         MatchingRule::Simple(IdWithIdentifier {
@@ -158,6 +158,7 @@ lazy_static! {
             matching_strategy: Option::from(MatchingStrategy::Equals),
         })
     ]));
+    static ref FLOATING_APPLICATIONS: Arc<Mutex<Vec<MatchingRule>>> = Arc::new(Mutex::new(Vec::new()));
     static ref PERMAIGNORE_CLASSES: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(vec![
         "Chrome_RenderWidgetHostHWND".to_string(),
     ]));
@@ -176,6 +177,8 @@ lazy_static! {
         Arc::new(Mutex::new(HashMap::new()));
     pub static ref SUBSCRIPTION_SOCKETS: Arc<Mutex<HashMap<String, PathBuf>>> =
         Arc::new(Mutex::new(HashMap::new()));
+    pub static ref SUBSCRIPTION_SOCKET_OPTIONS: Arc<Mutex<HashMap<String, SubscribeOptions>>> =
+        Arc::new(Mutex::new(HashMap::new()));
     static ref TCP_CONNECTIONS: Arc<Mutex<HashMap<String, TcpStream>>> =
         Arc::new(Mutex::new(HashMap::new()));
     static ref HIDING_BEHAVIOUR: Arc<Mutex<HidingBehaviour>> =
@@ -224,7 +227,6 @@ lazy_static! {
 
     static ref WINDOWS_BY_BAR_HWNDS: Arc<Mutex<HashMap<isize, VecDeque<isize>>>> =
         Arc::new(Mutex::new(HashMap::new()));
-
 }
 
 pub static DEFAULT_WORKSPACE_PADDING: AtomicI32 = AtomicI32::new(10);
@@ -297,18 +299,34 @@ pub struct Notification {
     pub state: State,
 }
 
-pub fn notify_subscribers(notification: &str) -> Result<()> {
+pub fn notify_subscribers(notification: Notification, state_has_been_modified: bool) -> Result<()> {
+    let is_subscription_event = matches!(
+        notification.event,
+        NotificationEvent::Socket(SocketMessage::AddSubscriberSocket(_))
+            | NotificationEvent::Socket(SocketMessage::AddSubscriberSocketWithOptions(_, _))
+    );
+
+    let notification = &serde_json::to_string(&notification)?;
     let mut stale_sockets = vec![];
     let mut sockets = SUBSCRIPTION_SOCKETS.lock();
+    let options = SUBSCRIPTION_SOCKET_OPTIONS.lock();
 
     for (socket, path) in &mut *sockets {
-        match UnixStream::connect(path) {
-            Ok(mut stream) => {
-                tracing::debug!("pushed notification to subscriber: {socket}");
-                stream.write_all(notification.as_bytes())?;
-            }
-            Err(_) => {
-                stale_sockets.push(socket.clone());
+        let apply_state_filter = (*options)
+            .get(socket)
+            .copied()
+            .unwrap_or_default()
+            .filter_state_changes;
+
+        if !apply_state_filter || state_has_been_modified || is_subscription_event {
+            match UnixStream::connect(path) {
+                Ok(mut stream) => {
+                    tracing::debug!("pushed notification to subscriber: {socket}");
+                    stream.write_all(notification.as_bytes())?;
+                }
+                Err(_) => {
+                    stale_sockets.push(socket.clone());
+                }
             }
         }
     }
@@ -316,6 +334,13 @@ pub fn notify_subscribers(notification: &str) -> Result<()> {
     for socket in stale_sockets {
         tracing::warn!("removing stale subscription: {socket}");
         sockets.remove(&socket);
+        let socket_path = DATA_DIR.join(socket);
+        if let Err(error) = std::fs::remove_file(&socket_path) {
+            tracing::error!(
+                "could not remove stale subscriber socket file at {}: {error}",
+                socket_path.display()
+            )
+        }
     }
 
     let mut stale_pipes = vec![];

komorebi/src/monitor.rs

@@ -20,6 +20,7 @@ use crate::workspace::Workspace;
 use crate::DefaultLayout;
 use crate::Layout;
 use crate::OperationDirection;
+use crate::WindowsApi;
 
 #[derive(
     Debug,
@@ -178,66 +179,90 @@ impl Monitor {
             bail!("cannot move native maximized window to another monitor or workspace");
         }
 
-        let container = workspace
-            .remove_focused_container()
-            .ok_or_else(|| anyhow!("there is no container"))?;
+        let foreground_hwnd = WindowsApi::foreground_window()?;
+        let floating_window_index = workspace
+            .floating_windows()
+            .iter()
+            .position(|w| w.hwnd == foreground_hwnd);
 
-        let workspaces = self.workspaces_mut();
+        if let Some(idx) = floating_window_index {
+            let window = workspace.floating_windows_mut().remove(idx);
 
-        #[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,
-        };
-
-        match direction {
-            Some(OperationDirection::Left) => match target_workspace.layout() {
-                Layout::Default(layout) => match layout {
-                    DefaultLayout::RightMainVerticalStack => {
-                        target_workspace.add_container_to_front(container);
-                    }
-                    DefaultLayout::UltrawideVerticalStack => {
-                        if target_workspace.containers().len() == 1 {
-                            target_workspace.insert_container_at_idx(0, container);
-                        } else {
-                            target_workspace.add_container_to_back(container);
-                        }
-                    }
-                    _ => {
-                        target_workspace.add_container_to_back(container);
-                    }
-                },
-                Layout::Custom(_) => {
-                    target_workspace.add_container_to_back(container);
+            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(OperationDirection::Right) => match target_workspace.layout() {
-                Layout::Default(layout) => {
-                    let target_index = layout.leftmost_index(target_workspace.containers().len());
+                Some(workspace) => workspace,
+            };
 
-                    match layout {
-                        DefaultLayout::RightMainVerticalStack
-                        | DefaultLayout::UltrawideVerticalStack => {
+            target_workspace.floating_windows_mut().push(window);
+        } else {
+            let container = workspace
+                .remove_focused_container()
+                .ok_or_else(|| anyhow!("there is no container"))?;
+
+            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,
+            };
+
+            match direction {
+                Some(OperationDirection::Left) => match target_workspace.layout() {
+                    Layout::Default(layout) => match layout {
+                        DefaultLayout::RightMainVerticalStack => {
+                            target_workspace.add_container_to_front(container);
+                        }
+                        DefaultLayout::UltrawideVerticalStack => {
                             if target_workspace.containers().len() == 1 {
-                                target_workspace.add_container_to_back(container);
+                                target_workspace.insert_container_at_idx(0, container);
                             } else {
-                                target_workspace.insert_container_at_idx(target_index, container);
+                                target_workspace.add_container_to_back(container);
                             }
                         }
                         _ => {
-                            target_workspace.insert_container_at_idx(target_index, container);
+                            target_workspace.add_container_to_back(container);
+                        }
+                    },
+                    Layout::Custom(_) => {
+                        target_workspace.add_container_to_back(container);
+                    }
+                },
+                Some(OperationDirection::Right) => match target_workspace.layout() {
+                    Layout::Default(layout) => {
+                        let target_index =
+                            layout.leftmost_index(target_workspace.containers().len());
+
+                        match layout {
+                            DefaultLayout::RightMainVerticalStack
+                            | DefaultLayout::UltrawideVerticalStack => {
+                                if target_workspace.containers().len() == 1 {
+                                    target_workspace.add_container_to_back(container);
+                                } else {
+                                    target_workspace
+                                        .insert_container_at_idx(target_index, container);
+                                }
+                            }
+                            _ => {
+                                target_workspace.insert_container_at_idx(target_index, container);
+                            }
                         }
                     }
+                    Layout::Custom(_) => {
+                        target_workspace.add_container_to_front(container);
+                    }
+                },
+                _ => {
+                    target_workspace.add_container_to_back(container);
                 }
-                Layout::Custom(_) => {
-                    target_workspace.add_container_to_front(container);
-                }
-            },
-            _ => {
-                target_workspace.add_container_to_back(container);
             }
         }
 

komorebi/src/monitor_reconciliator/mod.rs

@@ -172,7 +172,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     if should_update {
                         tracing::info!("updated work area for {}", monitor.device_id());
                         monitor.update_focused_workspace(offset)?;
-                        border_manager::send_notification();
+                        border_manager::send_notification(None);
                     } else {
                         tracing::debug!(
                             "work areas match, reconciliation not required for {}",
@@ -219,7 +219,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                         );
 
                         monitor.update_focused_workspace(offset)?;
-                        border_manager::send_notification();
+                        border_manager::send_notification(None);
                     } else {
                         tracing::debug!(
                             "resolutions match, reconciliation not required for {}",
@@ -406,7 +406,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     // Second retile to fix DPI/resolution related jank
                     wm.retile_all(true)?;
                     // Border updates to fix DPI/resolution related jank
-                    border_manager::send_notification();
+                    border_manager::send_notification(None);
                 }
             }
         }

komorebi/src/process_command.rs

@@ -61,6 +61,7 @@ use crate::winevent_listener;
 use crate::GlobalState;
 use crate::Notification;
 use crate::NotificationEvent;
+use crate::State;
 use crate::ANIMATION_DURATION;
 use crate::ANIMATION_ENABLED;
 use crate::ANIMATION_FPS;
@@ -68,8 +69,8 @@ use crate::ANIMATION_STYLE;
 use crate::CUSTOM_FFM;
 use crate::DATA_DIR;
 use crate::DISPLAY_INDEX_PREFERENCES;
-use crate::FLOAT_IDENTIFIERS;
 use crate::HIDING_BEHAVIOUR;
+use crate::IGNORE_IDENTIFIERS;
 use crate::INITIAL_CONFIGURATION_LOADED;
 use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
@@ -79,6 +80,7 @@ use crate::OBJECT_NAME_CHANGE_ON_LAUNCH;
 use crate::REMOVE_TITLEBARS;
 use crate::SUBSCRIPTION_PIPES;
 use crate::SUBSCRIPTION_SOCKETS;
+use crate::SUBSCRIPTION_SOCKET_OPTIONS;
 use crate::TCP_CONNECTIONS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
 use crate::WINDOWS_11;
@@ -187,6 +189,10 @@ impl WindowManager {
             }
         }
 
+        #[allow(clippy::useless_asref)]
+        // We don't have From implemented for &mut WindowManager
+        let initial_state = State::from(self.as_ref());
+
         match message {
             SocketMessage::CycleFocusWorkspace(_) | SocketMessage::FocusWorkspaceNumber(_) => {
                 if let Some(monitor) = self.focused_monitor_mut() {
@@ -232,6 +238,13 @@ impl WindowManager {
                 self.focused_window()?.focus(self.mouse_follows_focus)?;
             }
             SocketMessage::FocusStackWindow(idx) => {
+                // In case you are using this command on a bar on a monitor
+                // different from the currently focused one, you'd want that
+                // monitor to be focused so that the FocusStackWindow happens
+                // on the monitor with the bar you just pressed.
+                if let Some(monitor_idx) = self.monitor_idx_from_current_pos() {
+                    self.focus_monitor(monitor_idx)?;
+                }
                 self.focus_container_window(idx)?;
                 self.focused_window()?.focus(self.mouse_follows_focus)?;
             }
@@ -387,20 +400,20 @@ impl WindowManager {
                     }));
                 }
             }
-            SocketMessage::FloatRule(identifier, ref id) => {
-                let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
+            SocketMessage::IgnoreRule(identifier, ref id) => {
+                let mut ignore_identifiers = IGNORE_IDENTIFIERS.lock();
 
                 let mut should_push = true;
-                for f in &*float_identifiers {
-                    if let MatchingRule::Simple(f) = f {
-                        if f.id.eq(id) {
+                for i in &*ignore_identifiers {
+                    if let MatchingRule::Simple(i) = i {
+                        if i.id.eq(id) {
                             should_push = false;
                         }
                     }
                 }
 
                 if should_push {
-                    float_identifiers.push(MatchingRule::Simple(IdWithIdentifier {
+                    ignore_identifiers.push(MatchingRule::Simple(IdWithIdentifier {
                         kind: identifier,
                         id: id.clone(),
                         matching_strategy: Option::from(MatchingStrategy::Legacy),
@@ -1312,6 +1325,14 @@ impl WindowManager {
                 let socket_path = DATA_DIR.join(socket);
                 sockets.insert(socket.clone(), socket_path);
             }
+            SocketMessage::AddSubscriberSocketWithOptions(ref socket, options) => {
+                let mut sockets = SUBSCRIPTION_SOCKETS.lock();
+                let socket_path = DATA_DIR.join(socket);
+                sockets.insert(socket.clone(), socket_path);
+
+                let mut socket_options = SUBSCRIPTION_SOCKET_OPTIONS.lock();
+                socket_options.insert(socket.clone(), options);
+            }
             SocketMessage::RemoveSubscriberSocket(ref socket) => {
                 let mut sockets = SUBSCRIPTION_SOCKETS.lock();
                 sockets.remove(socket);
@@ -1339,15 +1360,52 @@ impl WindowManager {
                 self.resize_delta = delta;
             }
             SocketMessage::ToggleWindowContainerBehaviour => {
-                match self.window_container_behaviour {
+                match self.window_management_behaviour.current_behaviour {
                     WindowContainerBehaviour::Create => {
-                        self.window_container_behaviour = WindowContainerBehaviour::Append;
+                        self.window_management_behaviour.current_behaviour =
+                            WindowContainerBehaviour::Append;
                     }
                     WindowContainerBehaviour::Append => {
-                        self.window_container_behaviour = WindowContainerBehaviour::Create;
+                        self.window_management_behaviour.current_behaviour =
+                            WindowContainerBehaviour::Create;
                     }
                 }
             }
+            SocketMessage::ToggleFloatOverride => {
+                self.window_management_behaviour.float_override =
+                    !self.window_management_behaviour.float_override;
+            }
+            SocketMessage::ToggleWorkspaceWindowContainerBehaviour => {
+                let current_global_behaviour = self.window_management_behaviour.current_behaviour;
+                if let Some(behaviour) = self
+                    .focused_workspace_mut()?
+                    .window_container_behaviour_mut()
+                {
+                    match behaviour {
+                        WindowContainerBehaviour::Create => {
+                            *behaviour = WindowContainerBehaviour::Append
+                        }
+                        WindowContainerBehaviour::Append => {
+                            *behaviour = WindowContainerBehaviour::Create
+                        }
+                    }
+                } else {
+                    self.focused_workspace_mut()?
+                        .set_window_container_behaviour(Some(match current_global_behaviour {
+                            WindowContainerBehaviour::Create => WindowContainerBehaviour::Append,
+                            WindowContainerBehaviour::Append => WindowContainerBehaviour::Create,
+                        }));
+                };
+            }
+            SocketMessage::ToggleWorkspaceFloatOverride => {
+                let current_global_override = self.window_management_behaviour.float_override;
+                if let Some(float_override) = self.focused_workspace_mut()?.float_override_mut() {
+                    *float_override = !*float_override;
+                } else {
+                    self.focused_workspace_mut()?
+                        .set_float_override(Some(!current_global_override));
+                };
+            }
             SocketMessage::WindowHidingBehaviour(behaviour) => {
                 let mut hiding_behaviour = HIDING_BEHAVIOUR.lock();
                 *hiding_behaviour = behaviour;
@@ -1388,7 +1446,7 @@ impl WindowManager {
                         }
                     }
 
-                    border_manager::send_notification();
+                    border_manager::send_notification(None);
                 }
             }
             SocketMessage::BorderColour(kind, r, g, b) => match kind {
@@ -1404,6 +1462,9 @@ impl WindowManager {
                 WindowKind::Unfocused => {
                     border_manager::UNFOCUSED.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
                 }
+                WindowKind::Floating => {
+                    border_manager::FLOATING.store(Rgb::new(r, g, b).into(), Ordering::SeqCst);
+                }
             },
             SocketMessage::BorderStyle(style) => {
                 STYLE.store(style);
@@ -1527,13 +1588,15 @@ impl WindowManager {
             | SocketMessage::IdentifyBorderOverflowApplication(_, _) => {}
         };
 
-        let notification = Notification {
-            event: NotificationEvent::Socket(message.clone()),
-            state: self.as_ref().into(),
-        };
+        notify_subscribers(
+            Notification {
+                event: NotificationEvent::Socket(message.clone()),
+                state: self.as_ref().into(),
+            },
+            initial_state.has_been_modified(self.as_ref()),
+        )?;
 
-        notify_subscribers(&serde_json::to_string(&notification)?)?;
-        border_manager::send_notification();
+        border_manager::send_notification(None);
         transparency_manager::send_notification();
         stackbar_manager::send_notification();
 

komorebi/src/process_event.rs

@@ -32,7 +32,9 @@ 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::DATA_DIR;
+use crate::FLOATING_APPLICATIONS;
 use crate::HIDDEN_HWNDS;
 use crate::REGEX_IDENTIFIERS;
 use crate::TRAY_AND_MULTI_WINDOW_IDENTIFIERS;
@@ -101,6 +103,10 @@ impl WindowManager {
             }
 
             if !transparency_override {
+                if rule_debug.matches_ignore_identifier.is_some() {
+                    border_manager::send_notification(Option::from(event.hwnd()));
+                }
+
                 return Ok(());
             }
         }
@@ -117,6 +123,10 @@ impl WindowManager {
             }
         }
 
+        #[allow(clippy::useless_asref)]
+        // We don't have From implemented for &mut WindowManager
+        let initial_state = State::from(self.as_ref());
+
         // Make sure we have the most recently focused monitor from any event
         match event {
             WindowManagerEvent::FocusChange(_, window)
@@ -149,14 +159,6 @@ impl WindowManager {
             _ => {}
         }
 
-        for monitor in self.monitors_mut() {
-            for workspace in monitor.workspaces_mut() {
-                if let WindowManagerEvent::FocusChange(_, window) = event {
-                    let _ = workspace.focus_changed(window.hwnd);
-                }
-            }
-        }
-
         self.enforce_workspace_rules()?;
 
         if matches!(event, WindowManagerEvent::MouseCapture(..)) {
@@ -246,24 +248,31 @@ impl WindowManager {
                 self.update_focused_workspace(self.mouse_follows_focus, false)?;
 
                 let workspace = self.focused_workspace_mut()?;
-                if !workspace
+                let floating_window_idx = workspace
                     .floating_windows()
                     .iter()
-                    .any(|w| w.hwnd == window.hwnd)
-                {
-                    if let Some(w) = workspace.maximized_window() {
-                        if w.hwnd == window.hwnd {
-                            return Ok(());
+                    .position(|w| w.hwnd == window.hwnd);
+
+                match floating_window_idx {
+                    None => {
+                        if let Some(w) = workspace.maximized_window() {
+                            if w.hwnd == window.hwnd {
+                                return Ok(());
+                            }
+                        }
+
+                        if let Some(monocle) = workspace.monocle_container() {
+                            if let Some(window) = monocle.focused_window() {
+                                window.focus(false)?;
+                            }
+                        } else {
+                            workspace.focus_container_by_window(window.hwnd)?;
                         }
                     }
-
-                    if let Some(monocle) = workspace.monocle_container() {
-                        if let Some(window) = monocle.focused_window() {
+                    Some(idx) => {
+                        if let Some(window) = workspace.floating_windows().get(idx) {
                             window.focus(false)?;
                         }
-                    } else {
-                        self.focused_workspace_mut()?
-                            .focus_container_by_window(window.hwnd)?;
                     }
                 }
             }
@@ -329,26 +338,53 @@ impl WindowManager {
                 }
 
                 if proceed {
-                    let behaviour =
-                        self.window_container_behaviour(focused_monitor_idx, focused_workspace_idx);
+                    let mut behaviour = self
+                        .window_management_behaviour(focused_monitor_idx, focused_workspace_idx);
                     let workspace = self.focused_workspace_mut()?;
                     let workspace_contains_window = workspace.contains_window(window.hwnd);
                     let monocle_container = workspace.monocle_container().clone();
 
                     if !workspace_contains_window && !needs_reconciliation {
-                        match behaviour {
-                            WindowContainerBehaviour::Create => {
-                                workspace.new_container_for_window(window);
-                                self.update_focused_workspace(false, false)?;
-                            }
-                            WindowContainerBehaviour::Append => {
-                                workspace
-                                    .focused_container_mut()
-                                    .ok_or_else(|| anyhow!("there is no focused container"))?
-                                    .add_window(window);
-                                self.update_focused_workspace(true, false)?;
+                        let floating_applications = FLOATING_APPLICATIONS.lock();
+                        let regex_identifiers = REGEX_IDENTIFIERS.lock();
+                        let mut should_float = false;
 
-                                stackbar_manager::send_notification();
+                        if !floating_applications.is_empty() {
+                            if let (Ok(title), Ok(exe_name), Ok(class), Ok(path)) =
+                                (window.title(), window.exe(), window.class(), window.path())
+                            {
+                                should_float = should_act(
+                                    &title,
+                                    &exe_name,
+                                    &class,
+                                    &path,
+                                    &floating_applications,
+                                    &regex_identifiers,
+                                )
+                                .is_some();
+                            }
+                        }
+
+                        behaviour.float_override = behaviour.float_override
+                            || (should_float && !matches!(event, WindowManagerEvent::Manage(_)));
+
+                        if behaviour.float_override {
+                            workspace.floating_windows_mut().push(window);
+                            self.update_focused_workspace(false, false)?;
+                        } else {
+                            match behaviour.current_behaviour {
+                                WindowContainerBehaviour::Create => {
+                                    workspace.new_container_for_window(window);
+                                    self.update_focused_workspace(false, false)?;
+                                }
+                                WindowContainerBehaviour::Append => {
+                                    workspace
+                                        .focused_container_mut()
+                                        .ok_or_else(|| anyhow!("there is no focused container"))?
+                                        .add_window(window);
+                                    self.update_focused_workspace(true, false)?;
+                                    stackbar_manager::send_notification();
+                                }
                             }
                         }
                     }
@@ -402,8 +438,8 @@ impl WindowManager {
 
                 let focused_monitor_idx = self.focused_monitor_idx();
                 let focused_workspace_idx = self.focused_workspace_idx().unwrap_or_default();
-                let window_container_behaviour =
-                    self.window_container_behaviour(focused_monitor_idx, focused_workspace_idx);
+                let window_management_behaviour =
+                    self.window_management_behaviour(focused_monitor_idx, focused_workspace_idx);
 
                 let workspace = self.focused_workspace_mut()?;
                 let focused_container_idx = workspace.focused_container_idx();
@@ -521,8 +557,11 @@ impl WindowManager {
                             }
                             // Here we handle a simple move on the same monitor which is treated as
                             // a container swap
+                        } else if window_management_behaviour.float_override {
+                            workspace.floating_windows_mut().push(window);
+                            self.update_focused_workspace(false, false)?;
                         } else {
-                            match window_container_behaviour {
+                            match window_management_behaviour.current_behaviour {
                                 WindowContainerBehaviour::Create => {
                                     match workspace.container_idx_from_current_point() {
                                         Some(target_idx) => {
@@ -636,13 +675,15 @@ impl WindowManager {
 
         serde_json::to_writer_pretty(&file, &known_hwnds)?;
 
-        let notification = Notification {
-            event: NotificationEvent::WindowManager(event),
-            state: self.as_ref().into(),
-        };
+        notify_subscribers(
+            Notification {
+                event: NotificationEvent::WindowManager(event),
+                state: self.as_ref().into(),
+            },
+            initial_state.has_been_modified(self.as_ref()),
+        )?;
 
-        notify_subscribers(&serde_json::to_string(&notification)?)?;
-        border_manager::send_notification();
+        border_manager::send_notification(Some(event.hwnd()));
         transparency_manager::send_notification();
         stackbar_manager::send_notification();
 

komorebi/src/reaper.rs

@@ -51,7 +51,7 @@ pub fn find_orphans(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result<()> {
                 let reaped_orphans = workspace.reap_orphans()?;
                 if reaped_orphans.0 > 0 || reaped_orphans.1 > 0 {
                     workspace.update(&work_area, offset, window_based_work_area_offset)?;
-                    border_manager::send_notification();
+                    border_manager::send_notification(None);
                     tracing::info!(
                         "reaped {} orphan window(s) and {} orphaned container(s) on monitor: {}, workspace: {}",
                         reaped_orphans.0,

komorebi/src/static_config.rs

@@ -35,8 +35,9 @@ use crate::DATA_DIR;
 use crate::DEFAULT_CONTAINER_PADDING;
 use crate::DEFAULT_WORKSPACE_PADDING;
 use crate::DISPLAY_INDEX_PREFERENCES;
-use crate::FLOAT_IDENTIFIERS;
+use crate::FLOATING_APPLICATIONS;
 use crate::HIDING_BEHAVIOUR;
+use crate::IGNORE_IDENTIFIERS;
 use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
 use crate::MONITOR_INDEX_PREFERENCES;
@@ -67,6 +68,7 @@ use crate::core::OperationBehaviour;
 use crate::core::Rect;
 use crate::core::SocketMessage;
 use crate::core::WindowContainerBehaviour;
+use crate::core::WindowManagementBehaviour;
 use color_eyre::Result;
 use crossbeam_channel::Receiver;
 use hotwatch::EventKind;
@@ -94,6 +96,8 @@ pub struct BorderColours {
     pub stack: Option<Colour>,
     /// Border colour when the container is in monocle mode
     pub monocle: Option<Colour>,
+    /// Border colour when the container is in floating mode
+    pub floating: Option<Colour>,
     /// Border colour when the container is unfocused
     pub unfocused: Option<Colour>,
 }
@@ -129,6 +133,13 @@ pub struct WorkspaceConfig {
     /// Apply this monitor's window-based work area offset (default: true)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub apply_window_based_work_area_offset: Option<bool>,
+    /// Determine what happens when a new window is opened (default: Create)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub window_container_behaviour: Option<WindowContainerBehaviour>,
+    /// Enable or disable float override, which makes it so every new window opens in floating mode
+    /// (default: false)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub float_override: Option<bool>,
 }
 
 impl From<&Workspace> for WorkspaceConfig {
@@ -181,6 +192,8 @@ impl From<&Workspace> for WorkspaceConfig {
             initial_workspace_rules: None,
             workspace_rules: None,
             apply_window_based_work_area_offset: Some(value.apply_window_based_work_area_offset()),
+            window_container_behaviour: *value.window_container_behaviour(),
+            float_override: *value.float_override(),
         }
     }
 }
@@ -234,6 +247,10 @@ pub struct StaticConfig {
     /// Determine what happens when a new window is opened (default: Create)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub window_container_behaviour: Option<WindowContainerBehaviour>,
+    /// Enable or disable float override, which makes it so every new window opens in floating mode
+    /// (default: false)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub float_override: Option<bool>,
     /// Determine what happens when a window is moved across a monitor boundary (default: Swap)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub cross_monitor_move_behaviour: Option<MoveBehaviour>,
@@ -304,10 +321,14 @@ pub struct StaticConfig {
     pub global_work_area_offset: Option<Rect>,
     /// Individual window floating rules
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub float_rules: Option<Vec<MatchingRule>>,
+    #[serde(alias = "float_rules")]
+    pub ignore_rules: Option<Vec<MatchingRule>>,
     /// Individual window force-manage rules
     #[serde(skip_serializing_if = "Option::is_none")]
     pub manage_rules: Option<Vec<MatchingRule>>,
+    /// Identify applications which should be managed as floating windows
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub floating_applications: Option<Vec<MatchingRule>>,
     /// Identify border overflow applications
     #[serde(skip_serializing_if = "Option::is_none")]
     pub border_overflow_applications: Option<Vec<MatchingRule>>,
@@ -341,6 +362,10 @@ pub struct StaticConfig {
     /// How long to wait when compensating for slow applications, in milliseconds (default: 20)
     #[serde(skip_serializing_if = "Option::is_none")]
     pub slow_application_compensation_time: Option<u64>,
+    /// Komorebi status bar configuration files for multiple instances on different monitors
+    #[serde(skip_serializing_if = "Option::is_none")]
+    // this option is a little special because it is only consumed by komorebic
+    pub bar_configurations: Option<Vec<PathBuf>>,
 }
 
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
@@ -367,6 +392,8 @@ pub enum KomorebiTheme {
         stack_border: Option<komorebi_themes::CatppuccinValue>,
         /// Border colour when the container is in monocle mode (default: Pink)
         monocle_border: Option<komorebi_themes::CatppuccinValue>,
+        /// Border colour when the window is floating (default: Yellow)
+        floating_border: Option<komorebi_themes::CatppuccinValue>,
         /// Border colour when the container is unfocused (default: Base)
         unfocused_border: Option<komorebi_themes::CatppuccinValue>,
         /// Stackbar focused tab text colour (default: Green)
@@ -388,6 +415,8 @@ pub enum KomorebiTheme {
         stack_border: Option<komorebi_themes::Base16Value>,
         /// Border colour when the container is in monocle mode (default: Base0F)
         monocle_border: Option<komorebi_themes::Base16Value>,
+        /// Border colour when the window is floating (default: Base09)
+        floating_border: Option<komorebi_themes::Base16Value>,
         /// Border colour when the container is unfocused (default: Base01)
         unfocused_border: Option<komorebi_themes::Base16Value>,
         /// Stackbar focused tab text colour (default: Base0B)
@@ -498,6 +527,9 @@ impl From<&WindowManager> for StaticConfig {
                 single: Option::from(Colour::from(border_manager::FOCUSED.load(Ordering::SeqCst))),
                 stack: Option::from(Colour::from(border_manager::STACK.load(Ordering::SeqCst))),
                 monocle: Option::from(Colour::from(border_manager::MONOCLE.load(Ordering::SeqCst))),
+                floating: Option::from(Colour::from(
+                    border_manager::FLOATING.load(Ordering::SeqCst),
+                )),
                 unfocused: Option::from(Colour::from(
                     border_manager::UNFOCUSED.load(Ordering::SeqCst),
                 )),
@@ -507,7 +539,10 @@ impl From<&WindowManager> for StaticConfig {
         Self {
             invisible_borders: None,
             resize_delta: Option::from(value.resize_delta),
-            window_container_behaviour: Option::from(value.window_container_behaviour),
+            window_container_behaviour: Option::from(
+                value.window_management_behaviour.current_behaviour,
+            ),
+            float_override: Option::from(value.window_management_behaviour.float_override),
             cross_monitor_move_behaviour: Option::from(value.cross_monitor_move_behaviour),
             cross_boundary_behaviour: Option::from(value.cross_boundary_behaviour),
             unmanaged_window_operation_behaviour: Option::from(
@@ -541,7 +576,8 @@ impl From<&WindowManager> for StaticConfig {
             monitors: Option::from(monitors),
             window_hiding_behaviour: Option::from(*HIDING_BEHAVIOUR.lock()),
             global_work_area_offset: value.work_area_offset,
-            float_rules: None,
+            ignore_rules: None,
+            floating_applications: None,
             manage_rules: None,
             border_overflow_applications: None,
             tray_and_multi_window_applications: None,
@@ -556,6 +592,7 @@ impl From<&WindowManager> for StaticConfig {
                 SLOW_APPLICATION_COMPENSATION_TIME.load(Ordering::SeqCst),
             ),
             slow_application_identifiers: Option::from(SLOW_APPLICATION_IDENTIFIERS.lock().clone()),
+            bar_configurations: None,
         }
     }
 }
@@ -622,6 +659,10 @@ impl StaticConfig {
                 border_manager::MONOCLE.store(u32::from(monocle), Ordering::SeqCst);
             }
 
+            if let Some(floating) = colours.floating {
+                border_manager::FLOATING.store(u32::from(floating), Ordering::SeqCst);
+            }
+
             if let Some(unfocused) = colours.unfocused {
                 border_manager::UNFOCUSED.store(u32::from(unfocused), Ordering::SeqCst);
             }
@@ -649,7 +690,7 @@ impl StaticConfig {
                 }
             }
 
-            border_manager::send_notification();
+            border_manager::send_notification(None);
         }
 
         transparency_manager::TRANSPARENCY_ENABLED
@@ -657,7 +698,7 @@ impl StaticConfig {
         transparency_manager::TRANSPARENCY_ALPHA
             .store(self.transparency_alpha.unwrap_or(200), Ordering::SeqCst);
 
-        let mut float_identifiers = FLOAT_IDENTIFIERS.lock();
+        let mut ignore_identifiers = IGNORE_IDENTIFIERS.lock();
         let mut regex_identifiers = REGEX_IDENTIFIERS.lock();
         let mut manage_identifiers = MANAGE_IDENTIFIERS.lock();
         let mut tray_and_multi_window_identifiers = TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock();
@@ -665,9 +706,14 @@ impl StaticConfig {
         let mut layered_identifiers = LAYERED_WHITELIST.lock();
         let mut transparency_blacklist = TRANSPARENCY_BLACKLIST.lock();
         let mut slow_application_identifiers = SLOW_APPLICATION_IDENTIFIERS.lock();
+        let mut floating_applications = FLOATING_APPLICATIONS.lock();
 
-        if let Some(rules) = &mut self.float_rules {
-            populate_rules(rules, &mut float_identifiers, &mut regex_identifiers)?;
+        if let Some(rules) = &mut self.ignore_rules {
+            populate_rules(rules, &mut ignore_identifiers, &mut regex_identifiers)?;
+        }
+
+        if let Some(rules) = &mut self.floating_applications {
+            populate_rules(rules, &mut floating_applications, &mut regex_identifiers)?;
         }
 
         if let Some(rules) = &mut self.manage_rules {
@@ -747,6 +793,7 @@ impl StaticConfig {
                 single_border,
                 stack_border,
                 monocle_border,
+                floating_border,
                 unfocused_border,
                 stackbar_focused_text,
                 stackbar_unfocused_text,
@@ -757,6 +804,7 @@ impl StaticConfig {
                     single_border,
                     stack_border,
                     monocle_border,
+                    floating_border,
                     unfocused_border,
                     stackbar_focused_text,
                     stackbar_unfocused_text,
@@ -775,6 +823,10 @@ impl StaticConfig {
                         .unwrap_or(komorebi_themes::CatppuccinValue::Pink)
                         .color32(name.as_theme());
 
+                    let floating_border = floating_border
+                        .unwrap_or(komorebi_themes::CatppuccinValue::Yellow)
+                        .color32(name.as_theme());
+
                     let unfocused_border = unfocused_border
                         .unwrap_or(komorebi_themes::CatppuccinValue::Base)
                         .color32(name.as_theme());
@@ -795,6 +847,7 @@ impl StaticConfig {
                         single_border,
                         stack_border,
                         monocle_border,
+                        floating_border,
                         unfocused_border,
                         stackbar_focused_text,
                         stackbar_unfocused_text,
@@ -806,6 +859,7 @@ impl StaticConfig {
                     single_border,
                     stack_border,
                     monocle_border,
+                    floating_border,
                     unfocused_border,
                     stackbar_focused_text,
                     stackbar_unfocused_text,
@@ -828,6 +882,10 @@ impl StaticConfig {
                         .unwrap_or(komorebi_themes::Base16Value::Base01)
                         .color32(*name);
 
+                    let floating_border = floating_border
+                        .unwrap_or(komorebi_themes::Base16Value::Base09)
+                        .color32(*name);
+
                     let stackbar_focused_text = stackbar_focused_text
                         .unwrap_or(komorebi_themes::Base16Value::Base0B)
                         .color32(*name);
@@ -844,6 +902,7 @@ impl StaticConfig {
                         single_border,
                         stack_border,
                         monocle_border,
+                        floating_border,
                         unfocused_border,
                         stackbar_focused_text,
                         stackbar_unfocused_text,
@@ -856,6 +915,8 @@ impl StaticConfig {
             border_manager::MONOCLE
                 .store(u32::from(Colour::from(monocle_border)), Ordering::SeqCst);
             border_manager::STACK.store(u32::from(Colour::from(stack_border)), Ordering::SeqCst);
+            border_manager::FLOATING
+                .store(u32::from(Colour::from(floating_border)), Ordering::SeqCst);
             border_manager::UNFOCUSED
                 .store(u32::from(Colour::from(unfocused_border)), Ordering::SeqCst);
 
@@ -881,8 +942,8 @@ impl StaticConfig {
             let asc = ApplicationConfigurationGenerator::load(&content)?;
 
             for mut entry in asc {
-                if let Some(rules) = &mut entry.float_identifiers {
-                    populate_rules(rules, &mut float_identifiers, &mut regex_identifiers)?;
+                if let Some(rules) = &mut entry.ignore_identifiers {
+                    populate_rules(rules, &mut ignore_identifiers, &mut regex_identifiers)?;
                 }
 
                 if let Some(ref options) = entry.options {
@@ -929,7 +990,34 @@ impl StaticConfig {
 
     pub fn read(path: &PathBuf) -> Result<Self> {
         let content = std::fs::read_to_string(path)?;
-        let value: Self = serde_json::from_str(&content)?;
+        let mut value: Self = serde_json::from_str(&content)?;
+
+        if let Some(path) = &mut value.app_specific_configuration_path {
+            *path = resolve_home_path(&*path)?;
+        }
+
+        if let Some(monitors) = &mut value.monitors {
+            for m in monitors {
+                for w in &mut m.workspaces {
+                    if let Some(path) = &mut w.custom_layout {
+                        *path = resolve_home_path(&*path)?;
+                    }
+
+                    if let Some(map) = &mut w.custom_layout_rules {
+                        for path in map.values_mut() {
+                            *path = resolve_home_path(&*path)?;
+                        }
+                    }
+                }
+            }
+        }
+
+        if let Some(bar_configurations) = &mut value.bar_configurations {
+            for path in bar_configurations {
+                *path = resolve_home_path(&*path)?;
+            }
+        }
+
         Ok(value)
     }
 
@@ -939,8 +1027,7 @@ impl StaticConfig {
         incoming: Receiver<WindowManagerEvent>,
         unix_listener: Option<UnixListener>,
     ) -> Result<WindowManager> {
-        let content = std::fs::read_to_string(path)?;
-        let mut value: Self = serde_json::from_str(&content)?;
+        let mut value = Self::read(path)?;
         value.apply_globals()?;
 
         let listener = match unix_listener {
@@ -970,9 +1057,12 @@ impl StaticConfig {
             is_paused: false,
             virtual_desktop_id: current_virtual_desktop(),
             work_area_offset: value.global_work_area_offset,
-            window_container_behaviour: value
-                .window_container_behaviour
-                .unwrap_or(WindowContainerBehaviour::Create),
+            window_management_behaviour: WindowManagementBehaviour {
+                current_behaviour: value
+                    .window_container_behaviour
+                    .unwrap_or(WindowContainerBehaviour::Create),
+                float_override: value.float_override.unwrap_or_default(),
+            },
             cross_monitor_move_behaviour: value
                 .cross_monitor_move_behaviour
                 .unwrap_or(MoveBehaviour::Swap),
@@ -1019,8 +1109,7 @@ impl StaticConfig {
     }
 
     pub fn postload(path: &PathBuf, wm: &Arc<Mutex<WindowManager>>) -> Result<()> {
-        let content = std::fs::read_to_string(path)?;
-        let value: Self = serde_json::from_str(&content)?;
+        let value = Self::read(path)?;
         let mut wm = wm.lock();
 
         if let Some(monitors) = value.monitors {
@@ -1087,8 +1176,7 @@ impl StaticConfig {
     }
 
     pub fn reload(path: &PathBuf, wm: &mut WindowManager) -> Result<()> {
-        let content = std::fs::read_to_string(path)?;
-        let mut value: Self = serde_json::from_str(&content)?;
+        let mut value = Self::read(path)?;
 
         value.apply_globals()?;
 
@@ -1149,7 +1237,11 @@ impl StaticConfig {
         }
 
         if let Some(val) = value.window_container_behaviour {
-            wm.window_container_behaviour = val;
+            wm.window_management_behaviour.current_behaviour = val;
+        }
+
+        if let Some(val) = value.float_override {
+            wm.window_management_behaviour.float_override = val;
         }
 
         if let Some(val) = value.cross_monitor_move_behaviour {

komorebi/src/window.rs

@@ -41,9 +41,9 @@ use crate::styles::WindowStyle;
 use crate::transparency_manager;
 use crate::window_manager_event::WindowManagerEvent;
 use crate::windows_api::WindowsApi;
-use crate::FLOAT_IDENTIFIERS;
 use crate::HIDDEN_HWNDS;
 use crate::HIDING_BEHAVIOUR;
+use crate::IGNORE_IDENTIFIERS;
 use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
 use crate::NO_TITLEBAR;
@@ -159,6 +159,31 @@ impl Window {
         HWND(windows_api::as_ptr!(self.hwnd))
     }
 
+    pub fn move_to_area(&mut self, current_area: &Rect, target_area: &Rect) -> Result<()> {
+        let current_rect = WindowsApi::window_rect(self.hwnd)?;
+        let x_diff = target_area.left - current_area.left;
+        let y_diff = target_area.top - current_area.top;
+        let x_ratio = f32::abs((target_area.right as f32) / (current_area.right as f32));
+        let y_ratio = f32::abs((target_area.bottom as f32) / (current_area.bottom as f32));
+        let window_relative_x = current_rect.left - current_area.left;
+        let window_relative_y = current_rect.top - current_area.top;
+        let corrected_relative_x = (window_relative_x as f32 * x_ratio) as i32;
+        let corrected_relative_y = (window_relative_y as f32 * y_ratio) as i32;
+        let window_x = current_area.left + corrected_relative_x;
+        let window_y = current_area.top + corrected_relative_y;
+
+        let new_rect = Rect {
+            left: x_diff + window_x,
+            top: y_diff + window_y,
+            right: current_rect.right,
+            bottom: current_rect.bottom,
+        };
+        //TODO: We might need to take into account the differences in DPI for the new_rect, unless
+        //we can use the xy ratios above to the right/bottom (width/height of window) as well?
+
+        self.set_position(&new_rect, true)
+    }
+
     pub fn center(&mut self, work_area: &Rect) -> Result<()> {
         let half_width = work_area.right / 2;
         let half_weight = work_area.bottom / 2;
@@ -181,7 +206,7 @@ impl Window {
         let mut animation = self.animation;
 
         border_manager::BORDER_TEMPORARILY_DISABLED.store(true, Ordering::SeqCst);
-        border_manager::send_notification();
+        border_manager::send_notification(Some(self.hwnd));
 
         stackbar_manager::STACKBAR_TEMPORARILY_DISABLED.store(true, Ordering::SeqCst);
         stackbar_manager::send_notification();
@@ -203,7 +228,7 @@ impl Window {
                         stackbar_manager::STACKBAR_TEMPORARILY_DISABLED
                             .store(false, Ordering::SeqCst);
 
-                        border_manager::send_notification();
+                        border_manager::send_notification(Some(hwnd));
                         stackbar_manager::send_notification();
                         transparency_manager::send_notification();
                     }
@@ -280,7 +305,10 @@ impl Window {
     }
 
     pub fn minimize(self) {
-        WindowsApi::minimize_window(self.hwnd);
+        let exe = self.exe().unwrap_or_default();
+        if !exe.contains("komorebi-bar") {
+            WindowsApi::minimize_window(self.hwnd);
+        }
     }
 
     pub fn close(self) -> Result<()> {
@@ -534,7 +562,7 @@ pub struct RuleDebug {
     pub class: Option<String>,
     pub path: Option<String>,
     pub matches_permaignore_class: Option<String>,
-    pub matches_float_identifier: Option<MatchingRule>,
+    pub matches_ignore_identifier: Option<MatchingRule>,
     pub matches_managed_override: Option<MatchingRule>,
     pub matches_layered_whitelist: Option<MatchingRule>,
     pub matches_wsl2_gui: Option<String>,
@@ -563,16 +591,16 @@ fn window_is_eligible(
 
     let regex_identifiers = REGEX_IDENTIFIERS.lock();
 
-    let float_identifiers = FLOAT_IDENTIFIERS.lock();
+    let ignore_identifiers = IGNORE_IDENTIFIERS.lock();
     let should_float = if let Some(rule) = should_act(
         title,
         exe_name,
         class,
         path,
-        &float_identifiers,
+        &ignore_identifiers,
         &regex_identifiers,
     ) {
-        debug.matches_float_identifier = Some(rule);
+        debug.matches_ignore_identifier = Some(rule);
         true
     } else {
         false

komorebi/src/window_manager.rs

@@ -39,6 +39,7 @@ use crate::core::Rect;
 use crate::core::Sizing;
 use crate::core::StackbarLabel;
 use crate::core::WindowContainerBehaviour;
+use crate::core::WindowManagementBehaviour;
 
 use crate::border_manager;
 use crate::border_manager::STYLE;
@@ -71,9 +72,9 @@ use crate::Rgb;
 use crate::CUSTOM_FFM;
 use crate::DATA_DIR;
 use crate::DISPLAY_INDEX_PREFERENCES;
-use crate::FLOAT_IDENTIFIERS;
 use crate::HIDING_BEHAVIOUR;
 use crate::HOME_DIR;
+use crate::IGNORE_IDENTIFIERS;
 use crate::LAYERED_WHITELIST;
 use crate::MANAGE_IDENTIFIERS;
 use crate::MONITOR_INDEX_PREFERENCES;
@@ -92,7 +93,7 @@ pub struct WindowManager {
     pub is_paused: bool,
     pub work_area_offset: Option<Rect>,
     pub resize_delta: i32,
-    pub window_container_behaviour: WindowContainerBehaviour,
+    pub window_management_behaviour: WindowManagementBehaviour,
     pub cross_monitor_move_behaviour: MoveBehaviour,
     pub cross_boundary_behaviour: CrossBoundaryBehaviour,
     pub unmanaged_window_operation_behaviour: OperationBehaviour,
@@ -112,6 +113,7 @@ pub struct State {
     pub is_paused: bool,
     pub resize_delta: i32,
     pub new_window_behaviour: WindowContainerBehaviour,
+    pub float_override: bool,
     pub cross_monitor_move_behaviour: MoveBehaviour,
     pub unmanaged_window_operation_behaviour: OperationBehaviour,
     pub work_area_offset: Option<Rect>,
@@ -120,6 +122,54 @@ pub struct State {
     pub has_pending_raise_op: bool,
 }
 
+impl State {
+    pub fn has_been_modified(&self, wm: &WindowManager) -> bool {
+        let new = Self::from(wm);
+
+        if self.monitors != new.monitors {
+            return true;
+        }
+
+        if self.is_paused != new.is_paused {
+            return true;
+        }
+
+        if self.new_window_behaviour != new.new_window_behaviour {
+            return true;
+        }
+
+        if self.float_override != new.float_override {
+            return true;
+        }
+
+        if self.cross_monitor_move_behaviour != new.cross_monitor_move_behaviour {
+            return true;
+        }
+
+        if self.unmanaged_window_operation_behaviour != new.unmanaged_window_operation_behaviour {
+            return true;
+        }
+
+        if self.work_area_offset != new.work_area_offset {
+            return true;
+        }
+
+        if self.focus_follows_mouse != new.focus_follows_mouse {
+            return true;
+        }
+
+        if self.mouse_follows_focus != new.mouse_follows_focus {
+            return true;
+        }
+
+        if self.has_pending_raise_op != new.has_pending_raise_op {
+            return true;
+        }
+
+        false
+    }
+}
+
 #[allow(clippy::struct_excessive_bools)]
 #[derive(Debug, Serialize, Deserialize, JsonSchema)]
 pub struct GlobalState {
@@ -136,7 +186,8 @@ pub struct GlobalState {
     pub stackbar_tab_width: i32,
     pub stackbar_height: i32,
     pub remove_titlebars: bool,
-    pub float_identifiers: Vec<MatchingRule>,
+    #[serde(alias = "float_identifiers")]
+    pub ignore_identifiers: Vec<MatchingRule>,
     pub manage_identifiers: Vec<MatchingRule>,
     pub layered_whitelist: Vec<MatchingRule>,
     pub tray_and_multi_window_identifiers: Vec<MatchingRule>,
@@ -164,6 +215,9 @@ impl Default for GlobalState {
                 monocle: Option::from(Colour::Rgb(Rgb::from(
                     border_manager::MONOCLE.load(Ordering::SeqCst),
                 ))),
+                floating: Option::from(Colour::Rgb(Rgb::from(
+                    border_manager::FLOATING.load(Ordering::SeqCst),
+                ))),
                 unfocused: Option::from(Colour::Rgb(Rgb::from(
                     border_manager::UNFOCUSED.load(Ordering::SeqCst),
                 ))),
@@ -185,7 +239,7 @@ impl Default for GlobalState {
             stackbar_tab_width: STACKBAR_TAB_WIDTH.load(Ordering::SeqCst),
             stackbar_height: STACKBAR_TAB_HEIGHT.load(Ordering::SeqCst),
             remove_titlebars: REMOVE_TITLEBARS.load(Ordering::SeqCst),
-            float_identifiers: FLOAT_IDENTIFIERS.lock().clone(),
+            ignore_identifiers: IGNORE_IDENTIFIERS.lock().clone(),
             manage_identifiers: MANAGE_IDENTIFIERS.lock().clone(),
             layered_whitelist: LAYERED_WHITELIST.lock().clone(),
             tray_and_multi_window_identifiers: TRAY_AND_MULTI_WINDOW_IDENTIFIERS.lock().clone(),
@@ -214,7 +268,8 @@ impl From<&WindowManager> for State {
             is_paused: wm.is_paused,
             work_area_offset: wm.work_area_offset,
             resize_delta: wm.resize_delta,
-            new_window_behaviour: wm.window_container_behaviour,
+            new_window_behaviour: wm.window_management_behaviour.current_behaviour,
+            float_override: wm.window_management_behaviour.float_override,
             cross_monitor_move_behaviour: wm.cross_monitor_move_behaviour,
             focus_follows_mouse: wm.focus_follows_mouse,
             mouse_follows_focus: wm.mouse_follows_focus,
@@ -274,7 +329,7 @@ impl WindowManager {
             is_paused: false,
             virtual_desktop_id: current_virtual_desktop(),
             work_area_offset: None,
-            window_container_behaviour: WindowContainerBehaviour::Create,
+            window_management_behaviour: WindowManagementBehaviour::default(),
             cross_monitor_move_behaviour: MoveBehaviour::Swap,
             cross_boundary_behaviour: CrossBoundaryBehaviour::Workspace,
             unmanaged_window_operation_behaviour: OperationBehaviour::Op,
@@ -307,22 +362,52 @@ impl WindowManager {
         StaticConfig::reload(pathbuf, self)
     }
 
-    pub fn window_container_behaviour(
+    pub fn window_management_behaviour(
         &self,
         monitor_idx: usize,
         workspace_idx: usize,
-    ) -> WindowContainerBehaviour {
+    ) -> WindowManagementBehaviour {
         if let Some(monitor) = self.monitors().get(monitor_idx) {
             if let Some(workspace) = monitor.workspaces().get(workspace_idx) {
-                return if workspace.containers().is_empty() {
-                    WindowContainerBehaviour::Create
+                let current_behaviour =
+                    if let Some(behaviour) = workspace.window_container_behaviour() {
+                        if workspace.containers().is_empty()
+                            && matches!(behaviour, WindowContainerBehaviour::Append)
+                        {
+                            // You can't append to an empty workspace
+                            WindowContainerBehaviour::Create
+                        } else {
+                            *behaviour
+                        }
+                    } else if workspace.containers().is_empty()
+                        && matches!(
+                            self.window_management_behaviour.current_behaviour,
+                            WindowContainerBehaviour::Append
+                        )
+                    {
+                        // You can't append to an empty workspace
+                        WindowContainerBehaviour::Create
+                    } else {
+                        self.window_management_behaviour.current_behaviour
+                    };
+
+                let float_override = if let Some(float_override) = workspace.float_override() {
+                    *float_override
                 } else {
-                    self.window_container_behaviour
+                    self.window_management_behaviour.float_override
+                };
+
+                return WindowManagementBehaviour {
+                    current_behaviour,
+                    float_override,
                 };
             }
         }
 
-        WindowContainerBehaviour::Create
+        WindowManagementBehaviour {
+            current_behaviour: WindowContainerBehaviour::Create,
+            float_override: self.window_management_behaviour.float_override,
+        }
     }
 
     #[tracing::instrument(skip(self))]
@@ -826,7 +911,7 @@ impl WindowManager {
                 }
             }
         } else {
-            if self.focused_workspace()?.containers().is_empty() {
+            if self.focused_workspace()?.is_empty() {
                 let desktop_window = Window::from(WindowsApi::desktop_window()?);
 
                 match WindowsApi::raise_and_focus_window(desktop_window.hwnd) {
@@ -845,6 +930,8 @@ impl WindowManager {
                     && self.focused_workspace()?.maximized_window().is_none()
                     // and we don't have a monocle container
                     && self.focused_workspace()?.monocle_container().is_none()
+                    // and we don't have any floating windows that should show on top
+                    && self.focused_workspace()?.floating_windows().is_empty()
                 {
                     if let Ok(window) = self.focused_window_mut() {
                         if trigger_focus {
@@ -1149,6 +1236,8 @@ impl WindowManager {
             .focused_monitor_mut()
             .ok_or_else(|| anyhow!("there is no monitor"))?;
 
+        let current_area = *monitor.work_area_size();
+
         let workspace = monitor
             .focused_workspace_mut()
             .ok_or_else(|| anyhow!("there is no workspace"))?;
@@ -1157,16 +1246,23 @@ impl WindowManager {
             bail!("cannot move native maximized window to another monitor or workspace");
         }
 
-        let container = workspace
-            .remove_focused_container()
-            .ok_or_else(|| anyhow!("there is no container"))?;
-
-        let container_hwnds = container
-            .windows()
+        let foreground_hwnd = WindowsApi::foreground_window()?;
+        let floating_window_index = workspace
+            .floating_windows()
             .iter()
-            .map(|w| w.hwnd)
-            .collect::<Vec<_>>();
+            .position(|w| w.hwnd == foreground_hwnd);
 
+        let floating_window =
+            floating_window_index.map(|idx| workspace.floating_windows_mut().remove(idx));
+        let container = if floating_window_index.is_none() {
+            Some(
+                workspace
+                    .remove_focused_container()
+                    .ok_or_else(|| anyhow!("there is no container"))?,
+            )
+        } else {
+            None
+        };
         monitor.update_focused_workspace(offset)?;
 
         let target_monitor = self
@@ -1174,18 +1270,36 @@ impl WindowManager {
             .get_mut(monitor_idx)
             .ok_or_else(|| anyhow!("there is no monitor"))?;
 
-        target_monitor.add_container(container, workspace_idx)?;
-
         if let Some(workspace_idx) = workspace_idx {
             target_monitor.focus_workspace(workspace_idx)?;
         }
+        let target_workspace = target_monitor
+            .focused_workspace_mut()
+            .ok_or_else(|| anyhow!("there is no focused workspace on target monitor"))?;
 
-        if let Some(workspace) = target_monitor.focused_workspace() {
-            if !*workspace.tile() {
-                for hwnd in container_hwnds {
-                    Window::from(hwnd).center(target_monitor.work_area_size())?;
+        if let Some(window) = floating_window {
+            target_workspace.floating_windows_mut().push(window);
+            Window::from(window.hwnd)
+                .move_to_area(&current_area, target_monitor.work_area_size())?;
+        } else if let Some(container) = container {
+            let container_hwnds = container
+                .windows()
+                .iter()
+                .map(|w| w.hwnd)
+                .collect::<Vec<_>>();
+
+            target_monitor.add_container(container, workspace_idx)?;
+
+            if let Some(workspace) = target_monitor.focused_workspace() {
+                if !*workspace.tile() {
+                    for hwnd in container_hwnds {
+                        Window::from(hwnd)
+                            .move_to_area(&current_area, target_monitor.work_area_size())?;
+                    }
                 }
             }
+        } else {
+            bail!("failed to find a window to move");
         }
 
         target_monitor.load_focused_workspace(mouse_follows_focus)?;

komorebi/src/workspace.rs

@@ -30,6 +30,7 @@ use crate::static_config::WorkspaceConfig;
 use crate::window::Window;
 use crate::window::WindowDetails;
 use crate::windows_api::WindowsApi;
+use crate::WindowContainerBehaviour;
 use crate::DEFAULT_CONTAINER_PADDING;
 use crate::DEFAULT_WORKSPACE_PADDING;
 use crate::INITIAL_CONFIGURATION_LOADED;
@@ -83,6 +84,10 @@ pub struct Workspace {
     tile: bool,
     #[getset(get_copy = "pub", set = "pub")]
     apply_window_based_work_area_offset: bool,
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
+    window_container_behaviour: Option<WindowContainerBehaviour>,
+    #[getset(get = "pub", get_mut = "pub", set = "pub")]
+    float_override: Option<bool>,
 }
 
 impl_ring_elements!(Workspace, Container);
@@ -106,6 +111,8 @@ impl Default for Workspace {
             resize_dimensions: vec![],
             tile: true,
             apply_window_based_work_area_offset: true,
+            window_container_behaviour: None,
+            float_override: None,
         }
     }
 }
@@ -162,6 +169,14 @@ impl Workspace {
             config.apply_window_based_work_area_offset.unwrap_or(true),
         );
 
+        if config.window_container_behaviour.is_some() {
+            self.set_window_container_behaviour(config.window_container_behaviour);
+        }
+
+        if config.float_override.is_some() {
+            self.set_float_override(config.float_override);
+        }
+
         Ok(())
     }
 
@@ -217,22 +232,19 @@ impl Workspace {
             container.restore();
         }
 
-        for container in self.containers_mut() {
-            container.restore();
+        if let Some(container) = self.focused_container_mut() {
+            container.focus_window(container.focused_window_idx());
         }
 
         for window in self.floating_windows() {
             window.restore();
         }
 
-        if let Some(container) = self.focused_container_mut() {
-            container.focus_window(container.focused_window_idx());
-        }
-
         // Do this here to make sure that an error doesn't stop the restoration of other windows
-        // Maximised windows should always be drawn at the top of the Z order
+        // Maximised windows and floating windows should always be drawn at the top of the Z order
+        // when switching to a workspace
         if let Some(window) = to_focus {
-            if self.maximized_window().is_none() {
+            if self.maximized_window().is_none() && self.floating_windows().is_empty() {
                 window.focus(mouse_follows_focus)?;
             }
         }
@@ -393,26 +405,6 @@ impl Workspace {
         Ok(())
     }
 
-    // focus_changed performs updates in response to the fact that a focus
-    // change event has occurred. The focus change is assumed to be valid, and
-    // should not result in a new  focus change - the intent here is to update
-    // focus-reactive elements, such as the stackbar.
-    pub fn focus_changed(&mut self, hwnd: isize) -> Result<()> {
-        if !self.tile() {
-            return Ok(());
-        }
-
-        let containers = self.containers_mut();
-
-        for container in containers.iter_mut() {
-            if let Some(idx) = container.idx_for_window(hwnd) {
-                container.focus_window(idx);
-                container.restore();
-            }
-        }
-        Ok(())
-    }
-
     pub fn reap_orphans(&mut self) -> Result<(usize, usize)> {
         let mut hwnds = vec![];
         let mut floating_hwnds = vec![];
@@ -605,6 +597,13 @@ impl Workspace {
         Ok(false)
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.containers().is_empty()
+            && self.maximized_window().is_none()
+            && self.monocle_container().is_none()
+            && self.floating_windows().is_empty()
+    }
+
     pub fn contains_window(&self, hwnd: isize) -> bool {
         for container in self.containers() {
             if container.contains_window(hwnd) {

komorebi/src/workspace_reconciliator.rs

@@ -118,7 +118,7 @@ pub fn handle_notifications(wm: Arc<Mutex<WindowManager>>) -> color_eyre::Result
                     // Unblock the border manager
                     ALT_TAB_HWND.store(None);
                     // Send a notification to the border manager to update the borders
-                    border_manager::send_notification();
+                    border_manager::send_notification(None);
                 }
             }
         }

komorebic/src/main.rs

@@ -583,7 +583,7 @@ macro_rules! gen_application_target_subcommand_args {
 }
 
 gen_application_target_subcommand_args! {
-    FloatRule,
+    IgnoreRule,
     ManageRule,
     IdentifyTrayApplication,
     IdentifyLayeredApplication,
@@ -1167,6 +1167,16 @@ enum SubCommand {
     WorkspaceName(WorkspaceName),
     /// Toggle the behaviour for new windows (stacking or dynamic tiling)
     ToggleWindowContainerBehaviour,
+    /// Enable or disable float override, which makes it so every new window opens in floating mode
+    ToggleFloatOverride,
+    /// 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.
+    ToggleWorkspaceWindowContainerBehaviour,
+    /// 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.
+    ToggleWorkspaceFloatOverride,
     /// Toggle window tiling on the focused workspace
     TogglePause,
     /// Toggle window tiling on the focused workspace
@@ -1208,9 +1218,10 @@ enum SubCommand {
     /// Set the operation behaviour when the focused window is not managed
     #[clap(arg_required_else_help = true)]
     UnmanagedWindowOperationBehaviour(UnmanagedWindowOperationBehaviour),
-    /// Add a rule to always float the specified application
+    /// Add a rule to ignore the specified application
     #[clap(arg_required_else_help = true)]
-    FloatRule(FloatRule),
+    #[clap(alias = "float-rule")]
+    IgnoreRule(IgnoreRule),
     /// Add a rule to always manage the specified application
     #[clap(arg_required_else_help = true)]
     ManageRule(ManageRule),
@@ -1517,26 +1528,15 @@ fn main() -> Result<()> {
 
                 println!("Found komorebi.json; this file can be passed to the start command with the --config flag\n");
 
-                if let Ok(config) = &parsed_config {
-                    if let Some(asc_path) = config.get("app_specific_configuration_path") {
-                        let mut normalized_asc_path = asc_path
-                            .to_string()
-                            .replace(
-                                "$Env:USERPROFILE",
-                                &dirs::home_dir().unwrap().to_string_lossy(),
-                            )
-                            .replace('"', "")
-                            .replace('\\', "/");
-
-                        if let Ok(komorebi_config_home) = std::env::var("KOMOREBI_CONFIG_HOME") {
-                            normalized_asc_path = normalized_asc_path
-                                .replace("$Env:KOMOREBI_CONFIG_HOME", &komorebi_config_home)
-                                .replace('"', "")
-                                .replace('\\', "/");
+                if let Ok(config) = StaticConfig::read(&static_config) {
+                    match config.app_specific_configuration_path {
+                        None => {
+                            println!("Application specific configuration file path has not been set. Try running 'komorebic fetch-asc'\n");
                         }
-
-                        if !Path::exists(Path::new(&normalized_asc_path)) {
-                            println!("Application specific configuration file path '{normalized_asc_path}' does not exist. Try running 'komorebic fetch-asc'\n");
+                        Some(path) => {
+                            if !Path::exists(Path::new(&path)) {
+                                println!("Application specific configuration file path '{}' does not exist. Try running 'komorebic fetch-asc'\n", path.display());
+                            }
                         }
                     }
                 }
@@ -2025,19 +2025,50 @@ if (!(Get-Process whkd -ErrorAction SilentlyContinue))
                 }
             }
 
+            let static_config = arg.config.clone().map_or_else(
+                || {
+                    let komorebi_json = HOME_DIR.join("komorebi.json");
+                    if komorebi_json.is_file() {
+                        Option::from(komorebi_json)
+                    } else {
+                        None
+                    }
+                },
+                Option::from,
+            );
+
             if arg.bar {
-                let script = r"
+                if let Some(config) = &static_config {
+                    let mut config = StaticConfig::read(config)?;
+                    if let Some(display_bar_configurations) = &mut config.bar_configurations {
+                        for config_file_path in &mut *display_bar_configurations {
+                            let script = r"Start-Process 'komorebi-bar' '--config CONFIGFILE' -WindowStyle hidden"
+                            .replace("CONFIGFILE", &config_file_path.to_string_lossy());
+
+                            match powershell_script::run(&script) {
+                                Ok(_) => {
+                                    println!("{script}");
+                                }
+                                Err(error) => {
+                                    println!("Error: {error}");
+                                }
+                            }
+                        }
+                    } else {
+                        let script = r"
 if (!(Get-Process komorebi-bar -ErrorAction SilentlyContinue))
 {
   Start-Process komorebi-bar -WindowStyle hidden
 }
                 ";
-                match powershell_script::run(script) {
-                    Ok(_) => {
-                        println!("{script}");
-                    }
-                    Err(error) => {
-                        println!("Error: {error}");
+                        match powershell_script::run(script) {
+                            Ok(_) => {
+                                println!("{script}");
+                            }
+                            Err(error) => {
+                                println!("Error: {error}");
+                            }
+                        }
                     }
                 }
             }
@@ -2050,11 +2081,11 @@ if (!(Get-Process komorebi-bar -ErrorAction SilentlyContinue))
             println!("* Join the Discord https://discord.gg/mGkn66PHkx - Chat, ask questions, share your desktops");
             println!("* Read the docs https://lgug2z.github.io/komorebi - Quickly search through all komorebic commands");
 
-            let static_config = arg.config.map_or_else(
+            let bar_config = arg.config.map_or_else(
                 || {
-                    let komorebi_json = HOME_DIR.join("komorebi.json");
-                    if komorebi_json.is_file() {
-                        Option::from(komorebi_json)
+                    let bar_json = HOME_DIR.join("komorebi.bar.json");
+                    if bar_json.is_file() {
+                        Option::from(bar_json)
                     } else {
                         None
                     }
@@ -2062,12 +2093,18 @@ if (!(Get-Process komorebi-bar -ErrorAction SilentlyContinue))
                 Option::from,
             );
 
-            if let Some(config) = static_config {
+            if let Some(config) = &static_config {
                 let path = resolve_home_path(config)?;
                 let raw = std::fs::read_to_string(path)?;
                 StaticConfig::aliases(&raw);
                 StaticConfig::deprecated(&raw);
             }
+
+            if bar_config.is_some() {
+                let output = Command::new("komorebi-bar.exe").arg("--aliases").output()?;
+                let stdout = String::from_utf8(output.stdout)?;
+                println!("{stdout}");
+            }
         }
         SubCommand::Stop(arg) => {
             if arg.whkd {
@@ -2128,8 +2165,8 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
                 }
             }
         }
-        SubCommand::FloatRule(arg) => {
-            send_message(&SocketMessage::FloatRule(arg.identifier, arg.id))?;
+        SubCommand::IgnoreRule(arg) => {
+            send_message(&SocketMessage::IgnoreRule(arg.identifier, arg.id))?;
         }
         SubCommand::ManageRule(arg) => {
             send_message(&SocketMessage::ManageRule(arg.identifier, arg.id))?;
@@ -2443,6 +2480,15 @@ Stop-Process -Name:komorebi -ErrorAction SilentlyContinue
         SubCommand::ToggleWindowContainerBehaviour => {
             send_message(&SocketMessage::ToggleWindowContainerBehaviour)?;
         }
+        SubCommand::ToggleFloatOverride => {
+            send_message(&SocketMessage::ToggleFloatOverride)?;
+        }
+        SubCommand::ToggleWorkspaceWindowContainerBehaviour => {
+            send_message(&SocketMessage::ToggleWorkspaceWindowContainerBehaviour)?;
+        }
+        SubCommand::ToggleWorkspaceFloatOverride => {
+            send_message(&SocketMessage::ToggleWorkspaceFloatOverride)?;
+        }
         SubCommand::WindowHidingBehaviour(arg) => {
             send_message(&SocketMessage::WindowHidingBehaviour(arg.hiding_behaviour))?;
         }

schema.asc.json

@@ -13,7 +13,10 @@
         "name"
       ],
       "properties": {
-        "float_identifiers": {
+        "identifier": {
+          "$ref": "#/definitions/IdWithIdentifier"
+        },
+        "ignore_identifiers": {
           "type": [
             "array",
             "null"
@@ -22,9 +25,6 @@
             "$ref": "#/definitions/MatchingRule"
           }
         },
-        "identifier": {
-          "$ref": "#/definitions/IdWithIdentifier"
-        },
         "name": {
           "type": "string"
         },

schema.bar.json

@@ -73,6 +73,99 @@
                   "enable": {
                     "description": "Enable the Battery widget",
                     "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
+                  }
+                }
+              }
+            },
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "required": [
+              "Cpu"
+            ],
+            "properties": {
+              "Cpu": {
+                "type": "object",
+                "required": [
+                  "enable"
+                ],
+                "properties": {
+                  "data_refresh_interval": {
+                    "description": "Data refresh interval (default: 10 seconds)",
+                    "type": "integer",
+                    "format": "uint64",
+                    "minimum": 0.0
+                  },
+                  "enable": {
+                    "description": "Enable the Cpu widget",
+                    "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
                   }
                 }
               }
@@ -141,6 +234,39 @@
                         "additionalProperties": false
                       }
                     ]
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
                   }
                 }
               }
@@ -276,6 +402,39 @@
                   "enable": {
                     "description": "Enable the Memory widget",
                     "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
                   }
                 }
               }
@@ -306,6 +465,39 @@
                     "description": "Enable the Network widget",
                     "type": "boolean"
                   },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
+                  },
                   "network_activity_fill_characters": {
                     "description": "Characters to reserve for network activity data",
                     "type": "integer",
@@ -346,6 +538,39 @@
                   "enable": {
                     "description": "Enable the Storage widget",
                     "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
                   }
                 }
               }
@@ -400,6 +625,39 @@
                         "additionalProperties": false
                       }
                     ]
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
                   }
                 }
               }
@@ -461,6 +719,52 @@
         }
       }
     },
+    "position": {
+      "description": "Bar positioning options",
+      "type": "object",
+      "properties": {
+        "end": {
+          "description": "The desired size of the bar from the starting position (usually monitor width x desired height)",
+          "type": "object",
+          "required": [
+            "x",
+            "y"
+          ],
+          "properties": {
+            "x": {
+              "description": "X coordinate",
+              "type": "number",
+              "format": "float"
+            },
+            "y": {
+              "description": "Y coordinate",
+              "type": "number",
+              "format": "float"
+            }
+          }
+        },
+        "start": {
+          "description": "The desired starting position of the bar (0,0 = top left of the screen)",
+          "type": "object",
+          "required": [
+            "x",
+            "y"
+          ],
+          "properties": {
+            "x": {
+              "description": "X coordinate",
+              "type": "number",
+              "format": "float"
+            },
+            "y": {
+              "description": "Y coordinate",
+              "type": "number",
+              "format": "float"
+            }
+          }
+        }
+      }
+    },
     "right_widgets": {
       "description": "Right side widgets (ordered left-to-right)",
       "type": "array",
@@ -487,6 +791,99 @@
                   "enable": {
                     "description": "Enable the Battery widget",
                     "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
+                  }
+                }
+              }
+            },
+            "additionalProperties": false
+          },
+          {
+            "type": "object",
+            "required": [
+              "Cpu"
+            ],
+            "properties": {
+              "Cpu": {
+                "type": "object",
+                "required": [
+                  "enable"
+                ],
+                "properties": {
+                  "data_refresh_interval": {
+                    "description": "Data refresh interval (default: 10 seconds)",
+                    "type": "integer",
+                    "format": "uint64",
+                    "minimum": 0.0
+                  },
+                  "enable": {
+                    "description": "Enable the Cpu widget",
+                    "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
                   }
                 }
               }
@@ -555,6 +952,39 @@
                         "additionalProperties": false
                       }
                     ]
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
                   }
                 }
               }
@@ -690,6 +1120,39 @@
                   "enable": {
                     "description": "Enable the Memory widget",
                     "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
                   }
                 }
               }
@@ -720,6 +1183,39 @@
                     "description": "Enable the Network widget",
                     "type": "boolean"
                   },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
+                  },
                   "network_activity_fill_characters": {
                     "description": "Characters to reserve for network activity data",
                     "type": "integer",
@@ -760,6 +1256,39 @@
                   "enable": {
                     "description": "Enable the Storage widget",
                     "type": "boolean"
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
                   }
                 }
               }
@@ -814,6 +1343,39 @@
                         "additionalProperties": false
                       }
                     ]
+                  },
+                  "label_prefix": {
+                    "description": "Display label prefix",
+                    "oneOf": [
+                      {
+                        "description": "Show no prefix",
+                        "type": "string",
+                        "enum": [
+                          "None"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon",
+                        "type": "string",
+                        "enum": [
+                          "Icon"
+                        ]
+                      },
+                      {
+                        "description": "Show text",
+                        "type": "string",
+                        "enum": [
+                          "Text"
+                        ]
+                      },
+                      {
+                        "description": "Show an icon and text",
+                        "type": "string",
+                        "enum": [
+                          "IconAndText"
+                        ]
+                      }
+                    ]
                   }
                 }
               }
@@ -1194,52 +1756,6 @@
           }
         }
       ]
-    },
-    "viewport": {
-      "description": "Viewport options (see: https://docs.rs/egui/latest/egui/viewport/struct.ViewportBuilder.html)",
-      "type": "object",
-      "properties": {
-        "inner_size": {
-          "description": "The desired size of the bar from the starting position (usually monitor width x desired height)",
-          "type": "object",
-          "required": [
-            "x",
-            "y"
-          ],
-          "properties": {
-            "x": {
-              "description": "X coordinate",
-              "type": "number",
-              "format": "float"
-            },
-            "y": {
-              "description": "Y coordinate",
-              "type": "number",
-              "format": "float"
-            }
-          }
-        },
-        "position": {
-          "description": "The desired starting position of the bar (0,0 = top left of the screen)",
-          "type": "object",
-          "required": [
-            "x",
-            "y"
-          ],
-          "properties": {
-            "x": {
-              "description": "X coordinate",
-              "type": "number",
-              "format": "float"
-            },
-            "y": {
-              "description": "Y coordinate",
-              "type": "number",
-              "format": "float"
-            }
-          }
-        }
-      }
     }
   }
 }

schema.json

@@ -69,6 +69,13 @@
       "description": "Path to applications.yaml from komorebi-application-specific-configurations (default: None)",
       "type": "string"
     },
+    "bar_configurations": {
+      "description": "Komorebi status bar configuration files for multiple instances on different monitors",
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
     "border": {
       "description": "Display an active window border (default: false)",
       "type": "boolean"
@@ -77,6 +84,45 @@
       "description": "Active window border colours for different container types",
       "type": "object",
       "properties": {
+        "floating": {
+          "description": "Border colour when the container is in floating mode",
+          "anyOf": [
+            {
+              "description": "Colour represented as RGB",
+              "type": "object",
+              "required": [
+                "b",
+                "g",
+                "r"
+              ],
+              "properties": {
+                "b": {
+                  "description": "Blue",
+                  "type": "integer",
+                  "format": "uint32",
+                  "minimum": 0.0
+                },
+                "g": {
+                  "description": "Green",
+                  "type": "integer",
+                  "format": "uint32",
+                  "minimum": 0.0
+                },
+                "r": {
+                  "description": "Red",
+                  "type": "integer",
+                  "format": "uint32",
+                  "minimum": 0.0
+                }
+              }
+            },
+            {
+              "description": "Colour represented as Hex",
+              "type": "string",
+              "format": "color-hex"
+            }
+          ]
+        },
         "monocle": {
           "description": "Border colour when the container is in monocle mode",
           "anyOf": [
@@ -445,8 +491,12 @@
         "type": "string"
       }
     },
-    "float_rules": {
-      "description": "Individual window floating rules",
+    "float_override": {
+      "description": "Enable or disable float override, which makes it so every new window opens in floating mode (default: false)",
+      "type": "boolean"
+    },
+    "floating_applications": {
+      "description": "Identify applications which should be managed as floating windows",
       "type": "array",
       "items": {
         "anyOf": [
@@ -579,6 +629,89 @@
         }
       }
     },
+    "ignore_rules": {
+      "description": "Individual window floating rules",
+      "type": "array",
+      "items": {
+        "anyOf": [
+          {
+            "type": "object",
+            "required": [
+              "id",
+              "kind"
+            ],
+            "properties": {
+              "id": {
+                "type": "string"
+              },
+              "kind": {
+                "type": "string",
+                "enum": [
+                  "Exe",
+                  "Class",
+                  "Title",
+                  "Path"
+                ]
+              },
+              "matching_strategy": {
+                "type": "string",
+                "enum": [
+                  "Legacy",
+                  "Equals",
+                  "StartsWith",
+                  "EndsWith",
+                  "Contains",
+                  "Regex",
+                  "DoesNotEndWith",
+                  "DoesNotStartWith",
+                  "DoesNotEqual",
+                  "DoesNotContain"
+                ]
+              }
+            }
+          },
+          {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": [
+                "id",
+                "kind"
+              ],
+              "properties": {
+                "id": {
+                  "type": "string"
+                },
+                "kind": {
+                  "type": "string",
+                  "enum": [
+                    "Exe",
+                    "Class",
+                    "Title",
+                    "Path"
+                  ]
+                },
+                "matching_strategy": {
+                  "type": "string",
+                  "enum": [
+                    "Legacy",
+                    "Equals",
+                    "StartsWith",
+                    "EndsWith",
+                    "Contains",
+                    "Regex",
+                    "DoesNotEndWith",
+                    "DoesNotStartWith",
+                    "DoesNotEqual",
+                    "DoesNotContain"
+                  ]
+                }
+              }
+            }
+          }
+        ]
+      }
+    },
     "invisible_borders": {
       "description": "DEPRECATED from v0.1.22: no longer required",
       "type": "object",
@@ -929,44 +1062,91 @@
                     "type": "string"
                   }
                 },
+                "float_override": {
+                  "description": "Enable or disable float override, which makes it so every new window opens in floating mode (default: false)",
+                  "type": "boolean"
+                },
                 "initial_workspace_rules": {
                   "description": "Initial workspace application rules",
                   "type": "array",
                   "items": {
-                    "type": "object",
-                    "required": [
-                      "id",
-                      "kind"
-                    ],
-                    "properties": {
-                      "id": {
-                        "type": "string"
+                    "anyOf": [
+                      {
+                        "type": "object",
+                        "required": [
+                          "id",
+                          "kind"
+                        ],
+                        "properties": {
+                          "id": {
+                            "type": "string"
+                          },
+                          "kind": {
+                            "type": "string",
+                            "enum": [
+                              "Exe",
+                              "Class",
+                              "Title",
+                              "Path"
+                            ]
+                          },
+                          "matching_strategy": {
+                            "type": "string",
+                            "enum": [
+                              "Legacy",
+                              "Equals",
+                              "StartsWith",
+                              "EndsWith",
+                              "Contains",
+                              "Regex",
+                              "DoesNotEndWith",
+                              "DoesNotStartWith",
+                              "DoesNotEqual",
+                              "DoesNotContain"
+                            ]
+                          }
+                        }
                       },
-                      "kind": {
-                        "type": "string",
-                        "enum": [
-                          "Exe",
-                          "Class",
-                          "Title",
-                          "Path"
-                        ]
-                      },
-                      "matching_strategy": {
-                        "type": "string",
-                        "enum": [
-                          "Legacy",
-                          "Equals",
-                          "StartsWith",
-                          "EndsWith",
-                          "Contains",
-                          "Regex",
-                          "DoesNotEndWith",
-                          "DoesNotStartWith",
-                          "DoesNotEqual",
-                          "DoesNotContain"
-                        ]
+                      {
+                        "type": "array",
+                        "items": {
+                          "type": "object",
+                          "required": [
+                            "id",
+                            "kind"
+                          ],
+                          "properties": {
+                            "id": {
+                              "type": "string"
+                            },
+                            "kind": {
+                              "type": "string",
+                              "enum": [
+                                "Exe",
+                                "Class",
+                                "Title",
+                                "Path"
+                              ]
+                            },
+                            "matching_strategy": {
+                              "type": "string",
+                              "enum": [
+                                "Legacy",
+                                "Equals",
+                                "StartsWith",
+                                "EndsWith",
+                                "Contains",
+                                "Regex",
+                                "DoesNotEndWith",
+                                "DoesNotStartWith",
+                                "DoesNotEqual",
+                                "DoesNotContain"
+                              ]
+                            }
+                          }
+                        }
                       }
-                    }
+                    ]
                   }
                 },
                 "layout": {
@@ -1004,6 +1184,25 @@
                   "description": "Name",
                   "type": "string"
                 },
+                "window_container_behaviour": {
+                  "description": "Determine what happens when a new window is opened (default: Create)",
+                  "oneOf": [
+                    {
+                      "description": "Create a new container for each new window",
+                      "type": "string",
+                      "enum": [
+                        "Create"
+                      ]
+                    },
+                    {
+                      "description": "Append new windows to the focused window container",
+                      "type": "string",
+                      "enum": [
+                        "Append"
+                      ]
+                    }
+                  ]
+                },
                 "workspace_padding": {
                   "description": "Container padding (default: global)",
                   "type": "integer",
@@ -1013,40 +1212,83 @@
                   "description": "Permanent workspace application rules",
                   "type": "array",
                   "items": {
-                    "type": "object",
-                    "required": [
-                      "id",
-                      "kind"
-                    ],
-                    "properties": {
-                      "id": {
-                        "type": "string"
+                    "anyOf": [
+                      {
+                        "type": "object",
+                        "required": [
+                          "id",
+                          "kind"
+                        ],
+                        "properties": {
+                          "id": {
+                            "type": "string"
+                          },
+                          "kind": {
+                            "type": "string",
+                            "enum": [
+                              "Exe",
+                              "Class",
+                              "Title",
+                              "Path"
+                            ]
+                          },
+                          "matching_strategy": {
+                            "type": "string",
+                            "enum": [
+                              "Legacy",
+                              "Equals",
+                              "StartsWith",
+                              "EndsWith",
+                              "Contains",
+                              "Regex",
+                              "DoesNotEndWith",
+                              "DoesNotStartWith",
+                              "DoesNotEqual",
+                              "DoesNotContain"
+                            ]
+                          }
+                        }
                       },
-                      "kind": {
-                        "type": "string",
-                        "enum": [
-                          "Exe",
-                          "Class",
-                          "Title",
-                          "Path"
-                        ]
-                      },
-                      "matching_strategy": {
-                        "type": "string",
-                        "enum": [
-                          "Legacy",
-                          "Equals",
-                          "StartsWith",
-                          "EndsWith",
-                          "Contains",
-                          "Regex",
-                          "DoesNotEndWith",
-                          "DoesNotStartWith",
-                          "DoesNotEqual",
-                          "DoesNotContain"
-                        ]
+                      {
+                        "type": "array",
+                        "items": {
+                          "type": "object",
+                          "required": [
+                            "id",
+                            "kind"
+                          ],
+                          "properties": {
+                            "id": {
+                              "type": "string"
+                            },
+                            "kind": {
+                              "type": "string",
+                              "enum": [
+                                "Exe",
+                                "Class",
+                                "Title",
+                                "Path"
+                              ]
+                            },
+                            "matching_strategy": {
+                              "type": "string",
+                              "enum": [
+                                "Legacy",
+                                "Equals",
+                                "StartsWith",
+                                "EndsWith",
+                                "Contains",
+                                "Regex",
+                                "DoesNotEndWith",
+                                "DoesNotStartWith",
+                                "DoesNotEqual",
+                                "DoesNotContain"
+                              ]
+                            }
+                          }
+                        }
                       }
-                    }
+                    ]
                   }
                 }
               }
@@ -1147,6 +1389,95 @@
       "type": "integer",
       "format": "int32"
     },
+    "slow_application_compensation_time": {
+      "description": "How long to wait when compensating for slow applications, in milliseconds (default: 20)",
+      "type": "integer",
+      "format": "uint64",
+      "minimum": 0.0
+    },
+    "slow_application_identifiers": {
+      "description": "Identify applications which are slow to send initial event notifications",
+      "type": "array",
+      "items": {
+        "anyOf": [
+          {
+            "type": "object",
+            "required": [
+              "id",
+              "kind"
+            ],
+            "properties": {
+              "id": {
+                "type": "string"
+              },
+              "kind": {
+                "type": "string",
+                "enum": [
+                  "Exe",
+                  "Class",
+                  "Title",
+                  "Path"
+                ]
+              },
+              "matching_strategy": {
+                "type": "string",
+                "enum": [
+                  "Legacy",
+                  "Equals",
+                  "StartsWith",
+                  "EndsWith",
+                  "Contains",
+                  "Regex",
+                  "DoesNotEndWith",
+                  "DoesNotStartWith",
+                  "DoesNotEqual",
+                  "DoesNotContain"
+                ]
+              }
+            }
+          },
+          {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": [
+                "id",
+                "kind"
+              ],
+              "properties": {
+                "id": {
+                  "type": "string"
+                },
+                "kind": {
+                  "type": "string",
+                  "enum": [
+                    "Exe",
+                    "Class",
+                    "Title",
+                    "Path"
+                  ]
+                },
+                "matching_strategy": {
+                  "type": "string",
+                  "enum": [
+                    "Legacy",
+                    "Equals",
+                    "StartsWith",
+                    "EndsWith",
+                    "Contains",
+                    "Regex",
+                    "DoesNotEndWith",
+                    "DoesNotStartWith",
+                    "DoesNotEqual",
+                    "DoesNotContain"
+                  ]
+                }
+              }
+            }
+          }
+        ]
+      }
+    },
     "stackbar": {
       "description": "Stackbar configuration options",
       "type": "object",
@@ -1355,6 +1686,38 @@
                 "Crust"
               ]
             },
+            "floating_border": {
+              "description": "Border colour when the window is floating (default: Yellow)",
+              "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"
+              ]
+            },
             "monocle_border": {
               "description": "Border colour when the container is in monocle mode (default: Pink)",
               "type": "string",
@@ -1627,6 +1990,28 @@
                 "Base0F"
               ]
             },
+            "floating_border": {
+              "description": "Border colour when the window is floating (default: Base09)",
+              "type": "string",
+              "enum": [
+                "Base00",
+                "Base01",
+                "Base02",
+                "Base03",
+                "Base04",
+                "Base05",
+                "Base06",
+                "Base07",
+                "Base08",
+                "Base09",
+                "Base0A",
+                "Base0B",
+                "Base0C",
+                "Base0D",
+                "Base0E",
+                "Base0F"
+              ]
+            },
             "monocle_border": {
               "description": "Border colour when the container is in monocle mode (default: Base0F)",
               "type": "string",