gar Public

Notifications Fork 0 Star 0

Comparing changes

Choose two branches to see what's changed or to start a new pull request.

Create pull request

Able to merge. These branches can be automatically merged.

32 commits 13 files changed 2 contributors

Commits on trunk

migrate picom config to v13 rules format, drop deprecated exclude lists and wintypes 0293b03 espadonne committed 2 months ago
fix picom rule booleans treating nil as false f08b002 espadonne committed 2 months ago
hide frame borders on fullscreen windows 3f64b12 espadonne committed 2 months ago
focus workspace on its last monitor instead of moving it to current 6c08b3a espadonne committed 2 months ago
detect cross-monitor mouse movement on empty desktops via root MotionNotify 3ab345f espadonne committed 2 months ago
track monitor focus on mouse enter to empty workspaces ae7eded espadonne committed 2 months ago
broadcast workspace event on focus-follows-mouse cross-monitor a1364c7 espadonne committed 2 months ago
clear _NET_ACTIVE_WINDOW when focusing empty monitor 7c141d5 espadonne committed 2 months ago
broadcast workspace event on all monitor focus changes 44630cf espadonne committed 2 months ago
broadcast workspace event on monitor focus/move c315c11 mfwolffe committed 2 months ago
disable screen timeout by default - X11 blanking triggers Xid 79 on NVIDIA e50c72e mfwolffe committed 2 months ago
add configurable picom backend (glx/xrender) to avoid Xid 79 GPU crashes 72af8c4 mfwolffe committed 2 months ago
replace hardware DPMS with software blanking to prevent NVIDIA Xid 79 crashes 592b9e2 mfwolffe committed 2 months ago
disable DPMS by default: causes Xid 79 GPU crashes on NVIDIA multi-monitor e38ca11 mfwolffe committed 2 months ago
default to garcard auth agent 042bedf mfwolffe committed 2 months ago
fix focus stuck after move_to_monitor: clear stale focused pointer on source workspace 124c7fe mfwolffe committed 2 months ago
remove deprecated glx-no-stencil from picom config 267851c mfwolffe committed 2 months ago
fix dual compositor: remove picom launch from session script, gar manages compositor af5be26 mfwolffe committed 2 months ago
transfer: add refresh_layout IPC command and garctl subcommand efcbf6d mfwolffe committed 2 months ago
fix compositor kill: use pkill -f for NixOS wrappers, kill garchomp on exit 8661e62 mfwolffe committed 3 months ago
fix screen size caching to handle rotation properly 772a119 mfwolffe committed 3 months ago
fix floating window stacking and add _NET_WM_STATE_ABOVE support 6c9c79b mfwolffe committed 3 months ago
fix dialog windows spawning behind tiled windows 73a9223 mfwolffe committed 3 months ago
add compositor selection and focus_follows_mouse b44d141 mfwolffe committed 3 months ago
Merge commit '242efe5' into trunk bb18f1e mfwolffe committed 3 months ago
feat(config): add garnotify auto-spawn integration 242efe5 mfwolffe committed 3 months ago
kill spawned children on exit: use process groups fe6b01b mfwolffe committed 3 months ago
prefer ~/.local/bin/gar over system paths for dev overrides bb19a9d mfwolffe committed 3 months ago
kill spawned children on exit to prevent orphaned processes 15a7748 mfwolffe committed 3 months ago
fix: use stored geometry for pointer warp to avoid X11 race 255874d mfwolffe committed 3 months ago
docs: update example config with garterm, gartray, sessions 46d12e5 mfwolffe committed 3 months ago
fix: simplify edge zone detection, remove debug logging d5bc31a mfwolffe committed 3 months ago

.gitignoremodified

  docs/
  target/
  CLAUDE.md
 +flake.lock

Cargo.lockmodified

  [[package]]
  name = "gar"
 -version = "0.2.0"
 +version = "0.3.0"
  dependencies = [
   "dirs",
   "libc",
  [[package]]
  name = "garctl"
 -version = "0.2.0"
 +version = "0.3.0"
  dependencies = [
   "clap",
   "serde",

examples/init.luamodified

  -- Clipboard manager daemon
  gar.exec_once("garclip daemon --foreground")
 +-- System tray with quick settings panel
 +gar.exec_once("gartray daemon")
++
 +-- Polkit authentication agent (needed for power actions via D-Bus)
 +gar.exec_once("garcard daemon")
++
 +-- External fallback authentication agents (optional):
 +-- gar.exec_once("/usr/libexec/kf6/polkit-kde-authentication-agent-1")
 +-- gar.exec_once("/usr/lib/polkit-gnome/polkit-gnome-authentication-agent-1")
++
  -- Uncomment the ones you want:
  -- gar.exec_once("picom")                      -- Compositor (for transparency/shadows)
  -- gar.exec_once("dunst")                      -- Notification daemon
      -- Module layout
      modules_left = { "workspaces", "window_title" },
      modules_center = {},
 -    modules_right = { "almanta", "filesystem", "memory", "cpu", "battery", "wlan", "volume", "datetime" },
 +    modules_right = { "almanta", "filesystem", "memory", "cpu", "battery", "wlan", "volume", "tray", "datetime", "quick_settings" },
      -- Module configurations
      modules = {
  -- Use "mod" for real X session, "alt" for nested testing (Xephyr)
  local mod = "mod"
 --- Terminal
 +-- Terminal (fallback)
  gar.bind(mod .. "+Return", function()
      gar.exec("alacritty || kitty || foot || xterm")
  end)
 +-- garterm with fish shell
 +gar.bind(mod .. "+shift+Return", function()
 +    gar.exec("garterm")
 +end)
++
 +-- CPR-Music dev workspace via session
 +gar.bind(mod .. "+alt+Return", function()
 +    gar.exec("garterm")
 +    gar.exec("sleep 0.3 && gartermctl load-session cpr-music")
 +end)
++
 +--------------------------------------------------------------------------------
 +-- GARTERM CONFIGURATION
 +--------------------------------------------------------------------------------
 +-- garterm reads this table for shell, font, colors, sessions, and keybinds
++
 +gar.terminal = {
 +    -- Default shell
 +    shell = "/usr/bin/fish",
++
 +    -- Font settings
 +    font = {
 +        family = "JetBrainsMono Nerd Font",
 +        size = 20.0,
 +    },
++
 +    -- Color scheme
 +    colors = {
 +        preset = "catpuccin-mocha",
 +    },
++
 +    -- Tab bar configuration
 +    tab_bar = {
 +        height = 24,                          -- Tab bar height in pixels
 +        position = "top",                     -- "top" or "bottom"
 +        show_single_tab = false,              -- Show tab bar even with one tab
 +        max_tab_width = 200,                  -- Maximum width per tab in pixels
 +        tab_padding = 16,                     -- Horizontal padding inside each tab
 +        shorten_paths = true,                 -- Shorten paths: ~/P/a/src style
++
 +        -- Colors as {R, G, B, A} with values 0.0 to 1.0
 +        background = {0.08, 0.08, 0.12, 1.0}, -- Tab bar background
 +        active_bg = {0.15, 0.15, 0.20, 1.0},  -- Active tab background
 +        inactive_bg = {0.10, 0.10, 0.14, 1.0},-- Inactive tab background
 +        active_fg = {1.0, 1.0, 1.0, 1.0},     -- Active tab text color
 +        inactive_fg = {0.7, 0.7, 0.7, 1.0},   -- Inactive tab text color
 +    },
++
 +    -- Session definitions (load with gartermctl load-session <name>)
 +    sessions = {
 +        -- CPR-Music development workspace
 +        ["cpr-music"] = {
 +            tabs = {
 +                {
 +                    title = "Frontend",
 +                    cwd = "~/GithubOrgs/espadonne/CPR-Music",
 +                    cmd = "npm run dev",
 +                },
 +                {
 +                    title = "Backend",
 +                    cwd = "~/GithubOrgs/mfwolffe/CPR-Music-Backend",
 +                    cmd = "source .venv/bin/activate.fish && python manage.py runserver",
 +                },
 +                {
 +                    title = "Editor",
 +                    cwd = "~/GithubOrgs/espadonne/CPR-Music",
 +                    cmd = "fackr",
 +                },
 +            },
 +        },
 +    },
++
 +    -- Keybinds within garterm (Lua function callbacks)
 +    keybinds = {
 +        -- Quick session loading
 +        ["alt+m"] = { action = "load_session", session = "cpr-music"},
++
 +        -- Open fackr in current pane
 +        ["alt+e"] = function()
 +            gar.terminal.send_text(nil, "fackr \n")
 +        end,
++
 +        -- Open fackr in new tab
 +        ["alt+shift+e"] = function()
 +            gar.terminal.new_tab({})
 +            gar.terminal.send_text(nil, "fackr \n")
 +        end,
 +    },
 +}
++
  -- Close window
  gar.bind(mod .. "+q", gar.close_window)

gar-session.shmodified

  # gar session wrapper - sets up environment before starting gar
  # This script is typically installed to /usr/local/share/gar/gar-session.sh
 -# Find gar binary - check common locations
 +# Find gar binary - check common locations (user local first for dev overrides)
  GAR_BIN="${GAR_BIN:-}"
  if [ -z "$GAR_BIN" ]; then
 -    for path in /usr/local/bin/gar /usr/bin/gar "$HOME/.local/bin/gar"; do
 +    for path in "$HOME/.local/bin/gar" /usr/local/bin/gar /usr/bin/gar; do
          if [ -x "$path" ]; then
              GAR_BIN="$path"
              break
  # ═══════════════════════════════════════════════════════════════════
 -# Launch compositor before WM (for proper screen repainting)
 -# gar generates picom.conf on startup and signals picom to reload
 -if command -v picom &> /dev/null; then
 -    if [[ -f ~/.config/gar/picom.conf ]]; then
 -        picom -b --config ~/.config/gar/picom.conf &
 -    else
 -        # First run: start with GLX backend, gar will generate config and signal reload
 -        picom -b --backend glx &
 -    fi
 -    sleep 0.1
 -fi
 +# Compositor is now managed by gar itself via start_compositor()
 +# based on the "compositor" setting in init.lua ("picom", "garchomp", or "none")
 +# Do NOT start picom here - it causes dual-compositor conflicts when garchomp is selected
  # Set log level
  export GAR_LOG=info

gar/config/picom.confmodified

  use-ewmh-active-win = true;
  # GLX backend optimizations
 -glx-no-stencil = true;
  glx-no-rebind-pixmap = true;
  # =============================================================================

gar/src/config/lua.rsmodified

  use std::collections::HashSet;
 +use std::os::unix::process::CommandExt;
  use std::path::PathBuf;
  use std::sync::{Arc, Mutex};
      pub callbacks: Vec<mlua::RegistryKey>,
      pub rules: Vec<WindowRule>,
      pub exec_once_cmds: HashSet<String>,
 +    /// PIDs of processes spawned via gar.exec()/gar.exec_once()
 +    pub spawned_pids: Vec<u32>,
+ }
  impl Default for LuaState {
              callbacks: Vec::new(),
              rules: Vec::new(),
              exec_once_cmds: HashSet::new(),
 +            spawned_pids: Vec::new(),
 +        }
 +    }
 +}
++
 +impl LuaState {
 +    /// Kill all processes spawned via gar.exec()/gar.exec_once()
 +    /// Called on gar shutdown to clean up child processes
 +    pub fn kill_spawned_children(&self) {
 +        tracing::info!("Killing {} spawned child processes", self.spawned_pids.len());
 +        for &pid in &self.spawned_pids {
 +            // Check if process still exists before trying to kill
 +            // SAFETY: Sending signal 0 just checks if process exists
 +            let exists = unsafe { libc::kill(pid as i32, 0) == 0 };
 +            if exists {
 +                // Kill the entire process group (negative PID) to get children too
 +                // This handles cases like "sh -c garterm" where sh spawns garterm
 +                tracing::debug!("Sending SIGTERM to process group {}", pid);
 +                unsafe { libc::kill(-(pid as i32), libc::SIGTERM); }
 +            }
+         }
+     }
+ }
          // Check if gar.bar table exists - enables garbar integration
          self.check_bar_config()?;
 +        // Check if gar.notification table exists - enables garnotify integration
 +        self.check_notification_config()?;
++
          let state = self.state.lock().unwrap();
          tracing::info!(
 -            "Config loaded: {} keybinds registered, bar_enabled={}",
 +            "Config loaded: {} keybinds registered, bar_enabled={}, notification_enabled={}",
              state.keybinds.len(),
 -            state.config.bar_enabled
 +            state.config.bar_enabled,
 +            state.config.notification_enabled
          );
          Ok(())
          Ok(())
+     }
 +    /// Check if gar.notification table is configured, enabling garnotify integration
 +    fn check_notification_config(&self) -> LuaResult<()> {
 +        let globals = self.lua.globals();
 +        let gar: Table = globals.get("gar")?;
++
 +        // Check if gar.notification exists and is a table
 +        match gar.get::<Table>("notification") {
 +            Ok(_) => {
 +                // gar.notification exists! Enable garnotify integration
 +                let mut state = self.state.lock().unwrap();
 +                state.config.notification_enabled = true;
 +                tracing::info!("garnotify integration enabled");
 +            }
 +            Err(_) => {
 +                // gar.notification not set, garnotify won't be auto-spawned
 +                tracing::debug!("gar.notification not configured, garnotify integration disabled");
 +            }
 +        }
++
 +        Ok(())
 +    }
++
      /// Reload configuration (clears existing keybinds and rules)
      pub fn reload(&self) -> LuaResult<()> {
+         {
                          state.config.mouse_follows_focus = v;
+                     }
+                 }
 +                "focus_follows_mouse" => {
 +                    if let Value::Boolean(v) = value {
 +                        state.config.focus_follows_mouse = v;
 +                    }
 +                }
                  "bar_height" => {
                      if let Value::Integer(v) = value {
                          state.config.bar_height = v as u32;
+                     }
+                 }
 +                // Compositor selection: "picom", "garchomp", or "none"
 +                "compositor" => {
 +                    if let Value::String(s) = value {
 +                        if let Ok(str_val) = s.to_str() {
 +                            let comp = str_val.to_lowercase();
 +                            if comp == "picom" || comp == "garchomp" || comp == "none" {
 +                                state.config.compositor = comp;
 +                            } else {
 +                                tracing::warn!("Unknown compositor '{}', using 'picom'", str_val);
 +                            }
 +                        }
 +                    }
 +                }
 +                // Picom backend: "glx" or "xrender"
 +                "compositor_backend" | "picom_backend" => {
 +                    if let Value::String(s) = value {
 +                        if let Ok(str_val) = s.to_str() {
 +                            let backend = str_val.to_lowercase();
 +                            if backend == "glx" || backend == "xrender" {
 +                                state.config.picom_backend = backend;
 +                            } else {
 +                                tracing::warn!("Unknown compositor backend '{}', using 'glx'", str_val);
 +                            }
 +                        }
 +                    }
 +                }
                  // Compositor visual settings (picom)
                  "corner_radius" => {
                      if let Value::Integer(v) = value {
+     }
      fn register_exec(&self, gar: &Table) -> LuaResult<()> {
 -        let exec_fn = self.lua.create_function(|_, cmd: String| {
 +        // gar.exec(cmd) - spawn a command, track PID for cleanup on exit
 +        let state = Arc::clone(&self.state);
 +        let exec_fn = self.lua.create_function(move |_, cmd: String| {
              tracing::debug!("exec: {}", cmd);
 -            std::process::Command::new("sh")
 +            // process_group(0) makes the child its own process group leader
 +            // so we can kill the entire group (including grandchildren) on exit
 +            if let Ok(child) = std::process::Command::new("sh")
                  .arg("-c")
                  .arg(&cmd)
 +                .process_group(0)
                  .spawn()
 -                .ok();
 +            {
 +                let pid = child.id();
 +                tracing::debug!("exec: spawned PID {}", pid);
 +                if let Ok(mut state) = state.lock() {
 +                    state.spawned_pids.push(pid);
 +                }
 +            }
              Ok(())
          })?;
          gar.set("exec", exec_fn)?;
          // gar.exec_once(cmd) - only run if not already run this session
 -        let state = Arc::clone(&self.state);
 +        let state_once = Arc::clone(&self.state);
          let exec_once_fn = self.lua.create_function(move |_, cmd: String| {
 -            let mut state = state.lock().unwrap();
 -            if state.exec_once_cmds.contains(&cmd) {
 -                tracing::debug!("exec_once: skipping already-run command: {}", cmd);
 -                return Ok(());
 +            {
 +                let state = state_once.lock().unwrap();
 +                if state.exec_once_cmds.contains(&cmd) {
 +                    tracing::debug!("exec_once: skipping already-run command: {}", cmd);
 +                    return Ok(());
 +                }
+             }
              tracing::info!("exec_once: {}", cmd);
 -            state.exec_once_cmds.insert(cmd.clone());
 -            drop(state); // Release lock before spawning
 -            std::process::Command::new("sh")
 +            // process_group(0) makes the child its own process group leader
 +            // so we can kill the entire group (including grandchildren) on exit
 +            if let Ok(child) = std::process::Command::new("sh")
                  .arg("-c")
                  .arg(&cmd)
 +                .process_group(0)
                  .spawn()
 -                .ok();
 +            {
 +                let pid = child.id();
 +                tracing::debug!("exec_once: spawned PID {}", pid);
 +                if let Ok(mut state) = state_once.lock() {
 +                    state.exec_once_cmds.insert(cmd);
 +                    state.spawned_pids.push(pid);
 +                }
 +            }
              Ok(())
          })?;
          gar.set("exec_once", exec_once_fn)
                  rule.opacity = Some(op);
+             }
 -            // Optional: shadow
 -            if let Ok(shadow) = table.get::<bool>("shadow") {
 +            // Optional: shadow (use Option<bool> so nil doesn't become false)
 +            if let Ok(Some(shadow)) = table.get::<Option<bool>>("shadow") {
                  rule.shadow = Some(shadow);
+             }
 -            // Optional: blur_background
 -            if let Ok(blur) = table.get::<bool>("blur_background") {
 +            // Optional: blur_background (use Option<bool> so nil doesn't become false)
 +            if let Ok(Some(blur)) = table.get::<Option<bool>>("blur_background") {
                  rule.blur_background = Some(blur);
+             }

gar/src/config/mod.rsmodified

      // Behavior settings
      pub follow_window_on_move: bool,
      pub mouse_follows_focus: bool,
 +    pub focus_follows_mouse: bool,
      // Manual bar/panel reserved space (overrides struts)
      pub bar_height: u32,
      // garbar integration: spawn garbar automatically if gar.bar is configured
      pub bar_enabled: bool,
 +    // garnotify integration: spawn garnotify automatically if gar.notification is configured
 +    pub notification_enabled: bool,
      // Monitor ordering: list of monitor names in desired left-to-right order
      // If empty, monitors are sorted by X position (default)
      pub monitor_order: Vec<String>,
      // Screen timeout/DPMS settings
      pub screen_timeout_enabled: bool,
      pub screen_timeout_seconds: u32,
 +    // Compositor selection: "picom" (default), "garchomp", or "none"
 +    pub compositor: String,
 +    // Picom backend: "glx" (GPU) or "xrender" (CPU, safer on NVIDIA)
 +    pub picom_backend: String,
      // Compositor visual settings (picom)
      // These are stored for reference and potential dynamic picom config generation
      pub corner_radius: u32,
      /// Generate picom.conf content from current config settings.
      pub fn generate_picom_config(&self) -> String {
          let blur_section = if self.blur_enabled {
 +            // dual_kawase requires GLX backend; fall back to kernel blur on xrender
 +            let (blur_method, blur_strength) = if self.picom_backend == "xrender"
 +                && self.blur_method == "dual_kawase"
 +            {
 +                tracing::info!(
 +                    "Switching blur from dual_kawase to kernel (xrender backend doesn't support dual_kawase)"
 +                );
 +                ("kernel".to_string(), self.blur_strength)
 +            } else {
 +                (self.blur_method.clone(), self.blur_strength)
 +            };
++
              format!(
                  r#"# Blur
  blur-method = "{}";
  blur-strength = {};
  blur-background = true;
  blur-background-frame = false;
 -blur-kern = "3x3box";
+-
 -blur-background-exclude = [
 -    "window_type = 'dock'",
 -    "window_type = 'desktop'",
 -    "window_type = 'menu'",
 -    "window_type = 'dropdown_menu'",
 -    "window_type = 'popup_menu'",
 -    "_NET_WM_BYPASS_COMPOSITOR = 1"
 -];"#,
 -                self.blur_method, self.blur_strength
 +blur-kern = "3x3box";"#,
 +                blur_method, blur_strength
+             )
          } else {
              "# Blur disabled".to_string()
  shadow-radius = {};
  shadow-opacity = {:.2};
  shadow-offset-x = {};
 -shadow-offset-y = {};
+-
 -shadow-exclude = [
 -    "window_type = 'dock'",
 -    "window_type = 'desktop'",
 -    "window_type = 'menu'",
 -    "window_type = 'dropdown_menu'",
 -    "window_type = 'popup_menu'",
 -    "window_type = 'tooltip'",
 -    "_NET_WM_STATE *= '_NET_WM_STATE_FULLSCREEN'",
 -    "_NET_WM_BYPASS_COMPOSITOR = 1"
 -];"#,
 +shadow-offset-y = {};"#,
                  self.shadow_radius,
                  self.shadow_opacity,
                  self.shadow_offset_x,
  fade-out-step = 0.03;
  fade-delta = {};
 -no-fading-destroyed-argb = true;
+-
 -fade-exclude = [
 -    "window_type = 'menu'",
 -    "window_type = 'dropdown_menu'",
 -    "window_type = 'popup_menu'"
 -];"#,
 +no-fading-destroyed-argb = true;"#,
                  self.fade_delta
+             )
          } else {
              "# No custom shader".to_string()
          };
 -        // Per-window rules section
 -        let rules_section = if !self.picom_rules.is_empty() {
 -            let mut rules = String::from("# Per-window Rules\nrules = (\n");
 -            for rule in &self.picom_rules {
 -                rules.push_str(&format!("    {{\n        match = \"{}\";\n", rule.match_expr));
 -                if let Some(cr) = rule.corner_radius {
 -                    rules.push_str(&format!("        corner-radius = {};\n", cr));
 -                }
 -                if let Some(opacity) = rule.opacity {
 -                    rules.push_str(&format!("        opacity = {:.2};\n", opacity));
 -                }
 -                if let Some(shadow) = rule.shadow {
 -                    rules.push_str(&format!("        shadow = {};\n", shadow));
 -                }
 -                if let Some(blur) = rule.blur_background {
 -                    rules.push_str(&format!("        blur-background = {};\n", blur));
 -                }
 -                if let Some(ref shader) = rule.shader {
 -                    let expanded = if shader.starts_with("~/") {
 -                        if let Some(home) = dirs::home_dir() {
 -                            home.join(&shader[2..]).to_string_lossy().to_string()
 -                        } else {
 -                            shader.clone()
 -                        }
 +        // Unified rules section (picom v13 format)
 +        // Replaces deprecated: shadow-exclude, fade-exclude, blur-background-exclude,
 +        // rounded-corners-exclude, and wintypes blocks
 +        let mut rules = String::from("# Rules (picom v13 format)\nrules = (\n");
++
 +        // Built-in window type rules
 +        rules.push_str(r#"    {
 +        match = "window_type = 'dock'";
 +        shadow = false;
 +        corner-radius = 0;
 +        blur-background = false;
 +        clip-shadow-above = true;
 +    },
 +    {
 +        match = "window_type = 'desktop'";
 +        shadow = false;
 +        corner-radius = 0;
 +        blur-background = false;
 +    },
 +    {
 +        match = "window_type = 'tooltip'";
 +        shadow = false;
 +        corner-radius = 0;
 +        blur-background = false;
 +        fade = true;
 +        opacity = 0.95;
 +        focus = true;
 +    },
 +    {
 +        match = "window_type = 'menu'";
 +        shadow = false;
 +        corner-radius = 0;
 +        blur-background = false;
 +        fade = false;
 +    },
 +    {
 +        match = "window_type = 'dropdown_menu'";
 +        shadow = false;
 +        corner-radius = 0;
 +        blur-background = false;
 +        fade = false;
 +        opacity = 0.95;
 +    },
 +    {
 +        match = "window_type = 'popup_menu'";
 +        shadow = false;
 +        corner-radius = 0;
 +        blur-background = false;
 +        fade = false;
 +        opacity = 0.95;
 +    },
 +    {
 +        match = "window_type = 'dnd'";
 +        shadow = false;
 +    },
 +    {
 +        match = "_NET_WM_STATE *= '_NET_WM_STATE_FULLSCREEN'";
 +        corner-radius = 0;
 +        shadow = false;
 +    },
 +    {
 +        match = "_NET_WM_BYPASS_COMPOSITOR = 1";
 +        shadow = false;
 +        blur-background = false;
 +    },
 +"#);
++
 +        // User custom picom rules
 +        for rule in &self.picom_rules {
 +            rules.push_str(&format!("    {{\n        match = \"{}\";\n", rule.match_expr));
 +            if let Some(cr) = rule.corner_radius {
 +                rules.push_str(&format!("        corner-radius = {};\n", cr));
 +            }
 +            if let Some(opacity) = rule.opacity {
 +                rules.push_str(&format!("        opacity = {:.2};\n", opacity));
 +            }
 +            if let Some(shadow) = rule.shadow {
 +                rules.push_str(&format!("        shadow = {};\n", shadow));
 +            }
 +            if let Some(blur) = rule.blur_background {
 +                rules.push_str(&format!("        blur-background = {};\n", blur));
 +            }
 +            if let Some(ref shader) = rule.shader {
 +                let expanded = if shader.starts_with("~/") {
 +                    if let Some(home) = dirs::home_dir() {
 +                        home.join(&shader[2..]).to_string_lossy().to_string()
                      } else {
                          shader.clone()
 -                    };
 -                    rules.push_str(&format!("        shader = \"{}\";\n", expanded));
 -                }
 -                rules.push_str("    },\n");
 +                    }
 +                } else {
 +                    shader.clone()
 +                };
 +                rules.push_str(&format!("        shader = \"{}\";\n", expanded));
+             }
 -            rules.push_str(");");
 -            rules
 -        } else {
 -            "# No per-window rules".to_string()
 -        };
 +            rules.push_str("    },\n");
 +        }
++
 +        rules.push_str(");");
 +        let rules_section = rules;
          format!(
              r#"# picom.conf - Auto-generated by gar window manager
  # Edit ~/.config/gar/init.lua instead and reload with Mod+Shift+R
  # Backend Configuration
 -backend = "glx";
 +backend = "{}";
  vsync = true;
  use-ewmh-active-win = true;
 -glx-no-stencil = true;
  # Rounded Corners
  corner-radius = {};
 -rounded-corners-exclude = [
 -    "window_type = 'dock'",
 -    "window_type = 'desktop'",
 -    "window_type = 'tooltip'",
 -    "window_type = 'menu'",
 -    "window_type = 'dropdown_menu'",
 -    "window_type = 'popup_menu'",
 -    "_NET_WM_STATE *= '_NET_WM_STATE_FULLSCREEN'"
 -];
+-
  {}
  {}
  {}
  {}
+-
 -# Window Type Settings
 -wintypes:
 -{{
 -    tooltip = {{
 -        fade = true;
 -        shadow = false;
 -        opacity = 0.95;
 -        focus = true;
 -        blur-background = false;
 -    }};
 -    dock = {{
 -        shadow = false;
 -        clip-shadow-above = true;
 -    }};
 -    dnd = {{
 -        shadow = false;
 -    }};
 -    popup_menu = {{
 -        opacity = 0.95;
 -        shadow = false;
 -    }};
 -    dropdown_menu = {{
 -        opacity = 0.95;
 -        shadow = false;
 -    }};
 -}};
  "#,
 +            self.picom_backend,
              self.corner_radius,
              blur_section,
              shadow_section,
+         )
+     }
 -    /// Write picom config to ~/.config/gar/picom.conf and signal picom to reload.
 +    /// Write picom config to ~/.config/gar/picom.conf and optionally restart picom.
 +    /// Only writes/restarts if compositor is set to "picom".
      pub fn write_picom_config(&self) -> std::io::Result<()> {
 +        // Only generate picom config if using picom
 +        if self.compositor != "picom" {
 +            tracing::debug!("Skipping picom config (compositor={})", self.compositor);
 +            return Ok(());
 +        }
++
          let config_dir = dirs::config_dir()
              .ok_or_else(|| std::io::Error::new(
                  std::io::ErrorKind::NotFound,
          Ok(())
+     }
 -    /// Apply screen timeout/DPMS settings using xset
 -    pub fn apply_screen_timeout(&self) {
 +    /// Start the configured compositor.
 +    /// Called on gar startup to launch the appropriate compositor.
 +    pub fn start_compositor(&self) {
          use std::process::Command;
 -        if self.screen_timeout_enabled {
 -            // Enable DPMS and set timeout
 -            let timeout = self.screen_timeout_seconds.to_string();
 -            match Command::new("xset")
 -                .args(["dpms", &timeout, &timeout, &timeout])
 -                .status()
 -            {
 -                Ok(status) if status.success() => {
 -                    tracing::info!("Set DPMS timeout to {} seconds", self.screen_timeout_seconds);
 +        match self.compositor.as_str() {
 +            "picom" => {
 +                // Generate picom config first
 +                if let Err(e) = self.write_picom_config() {
 +                    tracing::warn!("Failed to write picom config: {}", e);
 +                }
 +                // picom will be started by write_picom_config -> reload_picom
 +            }
 +            "garchomp" => {
 +                // Kill any existing compositor first (use -f for NixOS wrappers)
 +                let _ = Command::new("pkill").args(["-f", "picom"]).status();
 +                let _ = Command::new("pkill").args(["-f", "garchomp"]).status();
++
 +                std::thread::sleep(std::time::Duration::from_millis(100));
++
 +                // Start garchomp
 +                match Command::new("garchomp").spawn() {
 +                    Ok(_) => {
 +                        tracing::info!("Started garchomp compositor");
 +                    }
 +                    Err(e) => {
 +                        tracing::error!("Failed to start garchomp: {}", e);
 +                        // Fall back to picom
 +                        tracing::info!("Falling back to picom");
 +                        Self::reload_picom();
 +                    }
 +                }
 +            }
 +            "none" => {
 +                tracing::info!("Compositor disabled (compositor=none)");
 +                // Kill any running compositor (use -f for NixOS wrappers)
 +                let _ = Command::new("pkill").args(["-f", "picom"]).status();
 +                let _ = Command::new("pkill").args(["-f", "garchomp"]).status();
 +            }
 +            _ => {
 +                tracing::warn!("Unknown compositor '{}', defaulting to picom", self.compositor);
 +                if let Err(e) = self.write_picom_config() {
 +                    tracing::warn!("Failed to write picom config: {}", e);
+                 }
 -                Ok(_) => tracing::warn!("xset dpms command failed"),
 -                Err(e) => tracing::warn!("Failed to run xset: {}", e),
+             }
 +        }
 +    }
++
 +    /// Stop any running compositor.
 +    pub fn stop_compositor() {
 +        use std::process::Command;
 +        // Use -f to match full command line (needed for NixOS wrappers)
 +        let _ = Command::new("pkill").args(["-f", "picom"]).status();
 +        let _ = Command::new("pkill").args(["-f", "garchomp"]).status();
 +    }
++
 +    /// Apply screen timeout settings using xset.
 +    ///
 +    /// Always disables hardware DPMS (causes Xid 79 GPU crashes on NVIDIA with
 +    /// multi-monitor HDMI setups). Uses the X11 screen saver extension for software
 +    /// blanking instead, which draws black without hardware power state changes.
 +    pub fn apply_screen_timeout(&self) {
 +        use std::process::Command;
++
 +        // Always disable hardware DPMS - it sends power state changes to monitors
 +        // via the NVIDIA driver, which can crash the GPU (Xid 79) when HDMI displays
 +        // have unreliable EDID links
 +        match Command::new("xset").args(["dpms", "0", "0", "0"]).status() {
 +            Ok(status) if status.success() => {
 +                tracing::debug!("Disabled hardware DPMS timeouts");
 +            }
 +            Ok(_) => tracing::warn!("xset dpms 0 command failed"),
 +            Err(e) => tracing::warn!("Failed to run xset: {}", e),
 +        }
 +        match Command::new("xset").args(["-dpms"]).status() {
 +            Ok(_) => {}
 +            Err(e) => tracing::warn!("Failed to disable DPMS: {}", e),
 +        }
 -            // Enable screen saver with same timeout
 +        if self.screen_timeout_enabled {
 +            // Use X11 screen saver for software blanking (safe, no hardware power changes)
 +            let timeout = self.screen_timeout_seconds.to_string();
              match Command::new("xset")
                  .args(["s", &timeout, &timeout])
                  .status()
+             {
                  Ok(status) if status.success() => {
 -                    tracing::debug!("Set screen saver timeout to {} seconds", self.screen_timeout_seconds);
 +                    tracing::info!(
 +                        "Screen blanking enabled via X11 screen saver ({} seconds)",
 +                        self.screen_timeout_seconds
 +                    );
+                 }
                  Ok(_) => tracing::warn!("xset s command failed"),
                  Err(e) => tracing::warn!("Failed to run xset: {}", e),
+             }
+-
 -            // Make sure DPMS is enabled
 -            match Command::new("xset").args(["+dpms"]).status() {
 -                Ok(_) => {}
 -                Err(e) => tracing::warn!("Failed to enable DPMS: {}", e),
 -            }
          } else {
 -            // Disable DPMS and screen saver
 -            match Command::new("xset").args(["dpms", "0", "0", "0"]).status() {
 -                Ok(status) if status.success() => {
 -                    tracing::info!("Disabled DPMS timeout");
 -                }
 -                Ok(_) => tracing::warn!("xset dpms 0 command failed"),
 -                Err(e) => tracing::warn!("Failed to run xset: {}", e),
 -            }
+-
 +            // Disable screen saver blanking too
              match Command::new("xset").args(["s", "off"]).status() {
                  Ok(status) if status.success() => {
 -                    tracing::debug!("Disabled screen saver");
 +                    tracing::info!("Screen blanking disabled");
+                 }
                  Ok(_) => tracing::warn!("xset s off command failed"),
                  Err(e) => tracing::warn!("Failed to run xset: {}", e),
+             }
+-
 -            match Command::new("xset").args(["-dpms"]).status() {
 -                Ok(_) => {}
 -                Err(e) => tracing::warn!("Failed to disable DPMS: {}", e),
 -            }
+         }
+     }
              follow_window_on_move: false,
              // Behavior: warp mouse pointer to center of focused window
              mouse_follows_focus: false,
 +            // Behavior: focus window when mouse enters it
 +            focus_follows_mouse: true,
              // Manual bar height (0 = use struts from dock windows)
              bar_height: 0,
              // garbar not enabled by default (enabled when gar.bar table is set)
              bar_enabled: false,
 +            // garnotify not enabled by default (enabled when gar.notification table is set)
 +            notification_enabled: false,
              // Monitor order: empty = sort by X position
              monitor_order: Vec::new(),
 -            // Screen timeout: enabled by default with 10 minute timeout
 -            screen_timeout_enabled: true,
 +            // Screen timeout: disabled by default - X11 screen saver blanking triggers
 +            // Xid 79 GPU crashes on NVIDIA with multi-monitor HDMI setups
 +            screen_timeout_enabled: false,
              screen_timeout_seconds: 600,
 +            // Compositor selection: "picom" (default), "garchomp", or "none"
 +            compositor: "picom".to_string(),
 +            // Picom backend: "glx" (GPU) or "xrender" (CPU, safer on NVIDIA)
 +            picom_backend: "glx".to_string(),
              // Compositor settings (picom) - matching picom.conf defaults
              corner_radius: 12,
              blur_enabled: true,

gar/src/core/mod.rsmodified

      pub tiled_edge_cursor: Option<(XWindow, XWindow, Direction)>,
      /// garbar child process (managed automatically when gar.bar is configured)
      pub garbar_process: Option<std::process::Child>,
 +    /// garnotify child process (managed automatically when gar.notification is configured)
 +    pub garnotify_process: Option<std::process::Child>,
      /// Directional focus memory: (source_window, direction) -> last_target_window
      /// Used to remember which window was focused when navigating in a direction
      pub directional_focus_memory: HashMap<(XWindow, Direction), XWindow>,
  impl WindowManager {
      pub fn new(conn: Connection) -> Result<Self> {
 -        let workspaces: Vec<Workspace> = (1..=10)
 +        let mut workspaces: Vec<Workspace> = (1..=10)
              .map(|i| Workspace::new(i, i.to_string()))
              .collect();
          // Get config values from Lua state
          let config = lua_state.lock().unwrap().config.clone();
 -        // Generate picom config from settings
 -        if let Err(e) = config.write_picom_config() {
 -            tracing::warn!("Failed to generate picom config: {}", e);
 -        }
 +        // Start the configured compositor (picom, garchomp, or none)
 +        config.start_compositor();
          // Apply screen timeout/DPMS settings
          config.apply_screen_timeout();
          for (i, monitor) in monitors.iter_mut().enumerate() {
              monitor.workspaces = vec![i]; // Just track initial workspace
              monitor.active_workspace = i; // Monitor 0 shows ws 0, monitor 1 shows ws 1, etc.
 +            if i < workspaces.len() {
 +                workspaces[i].last_monitor = Some(i);
 +            }
              tracing::debug!("Monitor '{}' starts with workspace {}", monitor.name, i + 1);
+         }
              current_edge_cursor: None,
              tiled_edge_cursor: None,
              garbar_process: None,
 +            garnotify_process: None,
              directional_focus_memory: HashMap::new(),
          })
+     }
      pub fn refresh_monitors(&mut self) -> Result<()> {
          tracing::info!("Refreshing monitor configuration");
 +        // Update cached screen dimensions (may have changed due to rotation)
 +        self.conn.update_screen_size();
++
          let mut new_monitors = self.conn.detect_monitors().unwrap_or_else(|e| {
              tracing::warn!("Failed to detect monitors: {}, keeping current", e);
              return self.monitors.clone();
                  monitor.workspaces = vec![first_free];
                  used_workspaces.insert(first_free);
+             }
 +            if monitor.active_workspace < self.workspaces.len() {
 +                self.workspaces[monitor.active_workspace].last_monitor = Some(i);
 +            }
              tracing::info!("Monitor '{}' showing workspace {}", monitor.name, monitor.active_workspace + 1);
+         }
          // Warp pointer to center of focused window (mouse follows focus)
          if warp_pointer {
 -            if let Err(e) = self.conn.warp_pointer_to_window(window) {
 -                tracing::warn!("Failed to warp pointer: {}", e);
 +            // Use stored geometry instead of querying X11 (avoids race with ConfigureWindow)
 +            if let Some(win) = self.windows.get(&window) {
 +                let g = &win.current_geometry;
 +                let center_x = g.x + (g.width as i16 / 2);
 +                let center_y = g.y + (g.height as i16 / 2);
 +                if let Err(e) = self.conn.warp_pointer(center_x, center_y) {
 +                    tracing::warn!("Failed to warp pointer: {}", e);
 +                }
 +            } else {
 +                // Fallback to querying X11 if window not in our map
 +                if let Err(e) = self.conn.warp_pointer_to_window(window) {
 +                    tracing::warn!("Failed to warp pointer: {}", e);
 +                }
+             }
 -            // Record warp time to suppress EnterNotify feedback loop
              self.last_warp = std::time::Instant::now();
 +            self.conn.flush()?;
+         }
          Ok(())
          // Update borders for all windows on visible workspaces
          for ws_idx in visible_ws {
              for window in self.workspaces[ws_idx].all_windows() {
 +                // Fullscreen windows have no borders
 +                if self.windows.get(&window).map(|w| w.fullscreen).unwrap_or(false) {
 +                    continue;
 +                }
++
                  // Check if window is urgent (and not focused - focused clears urgency)
                  let is_urgent = self.windows.get(&window)
                      .map(|w| w.urgent && Some(window) != focused)
                      fs_window, screen
                  );
 -                // Configure fullscreen window to cover entire monitor (no gaps, no borders)
 -                self.conn.configure_window(
 -                    fs_window,
 -                    screen.x,
 -                    screen.y,
 -                    screen.width,
 -                    screen.height,
 -                    0, // No border for fullscreen
 -                )?;
 +                if let Some(frame) = self.frames.frame_for_client(fs_window) {
 +                    // Window has a frame — position frame at monitor origin with no border,
 +                    // and configure client to fill the entire frame.
 +                    let frame_aux = ConfigureWindowAux::new()
 +                        .x(screen.x as i32)
 +                        .y(screen.y as i32)
 +                        .width(screen.width as u32)
 +                        .height(screen.height as u32)
 +                        .border_width(0);
 +                    self.conn.conn.configure_window(frame, &frame_aux)?;
++
 +                    let client_aux = ConfigureWindowAux::new()
 +                        .x(0)
 +                        .y(0)
 +                        .width(screen.width as u32)
 +                        .height(screen.height as u32)
 +                        .border_width(0);
 +                    self.conn.conn.configure_window(fs_window, &client_aux)?;
++
 +                    // Raise frame above everything
 +                    let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 +                    self.conn.conn.configure_window(frame, &aux)?;
 +                } else {
 +                    // No frame — configure client directly
 +                    self.conn.configure_window(
 +                        fs_window,
 +                        screen.x,
 +                        screen.y,
 +                        screen.width,
 +                        screen.height,
 +                        0,
 +                    )?;
 -                // Raise fullscreen window above everything
 -                let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 -                self.conn.conn.configure_window(fs_window, &aux)?;
 +                    let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 +                    self.conn.conn.configure_window(fs_window, &aux)?;
 +                }
                  // Skip normal layout for this workspace - fullscreen window covers everything
                  continue;
                          border_width as u16,
                      )?;
 +                    // Ensure tiled frame is below floating windows by stacking at bottom
 +                    if let Some(frame) = self.frames.frame_for_client(*window) {
 +                        let aux = ConfigureWindowAux::new().stack_mode(StackMode::BELOW);
 +                        self.conn.conn.configure_window(frame, &aux)?;
 +                    }
++
                      tracing::debug!(
                          "apply_layout: TILED+FRAME window={} at ({}, {}) size {}x{} (titlebar: {})",
                          window, gapped_x, gapped_y, final_width.max(1), final_height.max(1), titlebar_height
                          final_height.max(1),
                          border_width,
                      )?;
++
 +                    // Ensure tiled window is below floating windows
 +                    let aux = ConfigureWindowAux::new().stack_mode(StackMode::BELOW);
 +                    self.conn.conn.configure_window(*window, &aux)?;
 +                }
++
 +                // Store the actual geometry for pointer warping
 +                if let Some(win) = self.windows.get_mut(window) {
 +                    win.current_geometry = Rect::new(gapped_x, gapped_y, final_width.max(1), final_height.max(1));
+                 }
+             }
              for window_id in floating_ids {
                  // Get the window's floating geometry from our state
 -                if let Some(win) = self.windows.get(&window_id) {
 -                    let geom = win.floating_geometry;
 -                    let adjusted_width = geom.width.saturating_sub(2 * border_width as u16);
 -                    let adjusted_height = geom.height.saturating_sub(2 * border_width as u16);
+-
 -                    let has_frame = win.frame.is_some();
+-
 -                    if has_frame && titlebar_enabled {
 -                        // Configure frame for floating window
 -                        let client_height = adjusted_height.saturating_sub(titlebar_height);
 -                        self.frames.configure_frame(
 -                            &self.conn.conn,
 -                            window_id,
 -                            geom.x,
 -                            geom.y,
 -                            adjusted_width.max(1),
 -                            client_height.max(1),
 -                            titlebar_height,
 -                            border_width as u16,
 -                        )?;
+-
 -                        // Raise frame to top of stack
 -                        if let Some(frame) = self.frames.frame_for_client(window_id) {
 -                            let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 -                            self.conn.conn.configure_window(frame, &aux)?;
 -                        }
+-
 -                        tracing::debug!(
 -                            "apply_layout: FLOATING+FRAME window={} at ({}, {}) size {}x{} (raising)",
 -                            window_id, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)
 +                let (geom, has_frame) = match self.windows.get(&window_id) {
 +                    Some(win) => (win.floating_geometry, win.frame.is_some()),
 +                    None => {
 +                        tracing::warn!("apply_layout: floating window {} not in windows map!", window_id);
 +                        continue;
 +                    }
 +                };
++
 +                let adjusted_width = geom.width.saturating_sub(2 * border_width as u16);
 +                let adjusted_height = geom.height.saturating_sub(2 * border_width as u16);
++
 +                if has_frame && titlebar_enabled {
 +                    // Configure frame for floating window
 +                    let client_height = adjusted_height.saturating_sub(titlebar_height);
 +                    self.frames.configure_frame(
 +                        &self.conn.conn,
 +                        window_id,
 +                        geom.x,
 +                        geom.y,
 +                        adjusted_width.max(1),
 +                        client_height.max(1),
 +                        titlebar_height,
 +                        border_width as u16,
 +                    )?;
++
 +                    // Raise frame to top of stack
 +                    if let Some(frame) = self.frames.frame_for_client(window_id) {
 +                        let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 +                        self.conn.conn.configure_window(frame, &aux)?;
 +                        tracing::info!(
 +                            "apply_layout: FLOATING+FRAME window={} frame={} raised ABOVE (at ({}, {}) size {}x{})",
 +                            window_id, frame, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)
                          );
                      } else {
 -                        tracing::debug!(
 -                            "apply_layout: FLOATING window={} at ({}, {}) size {}x{} (raising)",
 -                            window_id, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)
 +                        tracing::warn!(
 +                            "apply_layout: FLOATING window={} has_frame=true but no frame found!",
 +                            window_id
                          );
+-
 -                        // Configure geometry
 -                        self.conn.configure_window(
 -                            window_id,
 -                            geom.x,
 -                            geom.y,
 -                            adjusted_width.max(1),
 -                            adjusted_height.max(1),
 -                            border_width,
 -                        )?;
+-
 -                        // Raise to top of stack (each subsequent window goes above the previous)
 -                        let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 -                        self.conn.conn.configure_window(window_id, &aux)?;
+                     }
                  } else {
 -                    tracing::warn!("apply_layout: floating window {} not in windows map!", window_id);
 +                    // Configure geometry
 +                    self.conn.configure_window(
 +                        window_id,
 +                        geom.x,
 +                        geom.y,
 +                        adjusted_width.max(1),
 +                        adjusted_height.max(1),
 +                        border_width,
 +                    )?;
++
 +                    // Raise to top of stack (each subsequent window goes above the previous)
 +                    let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 +                    self.conn.conn.configure_window(window_id, &aux)?;
++
 +                    tracing::info!(
 +                        "apply_layout: FLOATING window={} raised ABOVE (at ({}, {}) size {}x{})",
 +                        window_id, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)
 +                    );
 +                }
++
 +                // Store the actual geometry for pointer warping
 +                if let Some(win) = self.windows.get_mut(&window_id) {
 +                    win.current_geometry = Rect::new(geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1));
+                 }
+             }
+         }

gar/src/core/window.rsmodified

      pub id: XWindow,
      /// Geometry for floating mode (position and size when floating)
      pub floating_geometry: Rect,
 +    /// Current actual geometry (updated by apply_layout, used for pointer warping)
 +    pub current_geometry: Rect,
      pub mapped: bool,
      pub focused: bool,
      pub floating: bool,
          Self {
              id,
              floating_geometry: Rect::new(0, 0, 640, 480),
 +            current_geometry: Rect::new(0, 0, 640, 480),
              mapped: false,
              focused: false,
              floating: false,

gar/src/core/workspace.rsmodified


     pub floating: Vec<XWindow>,
     pub focused: Option<XWindow>,
     pub visible: bool,
+    /// Last monitor this workspace was displayed on (for focus-back behavior)
+    pub last_monitor: Option<usize>,
 }
 
 impl Workspace {

             floating: Vec::new(),
             focused: None,
             visible: id == 1,
+            last_monitor: None,
         }
     }
 

gar/src/x11/connection.rsmodified

      pub net_wm_state: Atom,
      pub net_wm_state_modal: Atom,
      pub net_wm_state_fullscreen: Atom,
 +    pub net_wm_state_above: Atom,
      // EWMH atoms for workspaces
      pub net_supported: Atom,
      pub net_supporting_wm_check: Atom,
          let net_wm_state = conn.intern_atom(false, b"_NET_WM_STATE")?.reply()?.atom;
          let net_wm_state_modal = conn.intern_atom(false, b"_NET_WM_STATE_MODAL")?.reply()?.atom;
          let net_wm_state_fullscreen = conn.intern_atom(false, b"_NET_WM_STATE_FULLSCREEN")?.reply()?.atom;
 +        let net_wm_state_above = conn.intern_atom(false, b"_NET_WM_STATE_ABOVE")?.reply()?.atom;
          // Intern EWMH atoms for workspaces and WM identification
          let net_supported = conn.intern_atom(false, b"_NET_SUPPORTED")?.reply()?.atom;
              net_wm_state,
              net_wm_state_modal,
              net_wm_state_fullscreen,
 +            net_wm_state_above,
              net_supported,
              net_supporting_wm_check,
              net_client_list,
                  EventMask::SUBSTRUCTURE_REDIRECT
                      | EventMask::SUBSTRUCTURE_NOTIFY
                      | EventMask::STRUCTURE_NOTIFY
 -                    | EventMask::PROPERTY_CHANGE,
 +                    | EventMask::PROPERTY_CHANGE
 +                    | EventMask::ENTER_WINDOW
 +                    | EventMask::POINTER_MOTION,
+             )
              .background_pixel(self.screen().black_pixel)
              .cursor(self.cursor_normal);
          let center_x = (geom.width / 2) as i16;
          let center_y = (geom.height / 2) as i16;
 +        tracing::debug!(
 +            "Warping pointer to window {}: geom={}x{}+{}+{}, center=({},{})",
 +            window, geom.width, geom.height, geom.x, geom.y, center_x, center_y
 +        );
++
          self.conn.warp_pointer(
              x11rb::NONE,  // src_window (none = don't check source)
              window,       // dst_window
+             }
+         }
 -        // 3. Check _NET_WM_STATE for modal windows
 +        // 3. Check _NET_WM_STATE for modal or above windows
          if let Ok(cookie) = self.conn.get_property(
              false,
              window,
                              tracing::debug!("Window {} is modal, should float", window);
                              return true;
+                         }
 +                        if atom == self.net_wm_state_above {
 +                            tracing::debug!("Window {} has ABOVE state, should float", window);
 +                            return true;
 +                        }
+                     }
+                 }
+             }
              self.net_close_window,
              self.net_wm_state,
              self.net_wm_state_fullscreen,
 +            self.net_wm_state_modal,
 +            self.net_wm_state_above,
              self.net_wm_name,
          ];
          self.conn.change_property32(
          )?;
          Ok(())
+     }
++
 +    /// Update cached screen dimensions using RandR query.
 +    /// Called after RandR events when we don't have the new size from the event.
 +    pub fn update_screen_size(&mut self) {
 +        use x11rb::protocol::randr::ConnectionExt as RandrExt;
++
 +        // Query current screen size from RandR
 +        if let Ok(reply) = self.conn.randr_get_screen_info(self.root) {
 +            if let Ok(info) = reply.reply() {
 +                // Get the size from the current rotation/size index
 +                if let Some(size) = info.sizes.get(info.size_id as usize) {
 +                    let (new_w, new_h) = if info.rotation.contains(x11rb::protocol::randr::Rotation::ROTATE90)
 +                        || info.rotation.contains(x11rb::protocol::randr::Rotation::ROTATE270)
 +                    {
 +                        // Rotated 90 or 270 - swap dimensions
 +                        (size.height, size.width)
 +                    } else {
 +                        (size.width, size.height)
 +                    };
++
 +                    if new_w != self.screen_width || new_h != self.screen_height {
 +                        tracing::info!(
 +                            "Screen size updated: {}x{} -> {}x{}",
 +                            self.screen_width, self.screen_height, new_w, new_h
 +                        );
 +                        self.screen_width = new_w;
 +                        self.screen_height = new_h;
 +                    }
 +                }
 +            }
 +        }
 +    }
+ }
  impl std::ops::Deref for Connection {

gar/src/x11/events.rsmodified

          libc::kill(child.id() as i32, libc::SIGHUP);
+     }
+ }
++
 +// ============================================================================
 +// garnotify integration - auto-spawn notification daemon
 +// ============================================================================
++
 +/// Get garnotify socket path
 +fn garnotify_socket_path() -> String {
 +    std::env::var("XDG_RUNTIME_DIR")
 +        .map(|dir| format!("{}/garnotify.sock", dir))
 +        .unwrap_or_else(|_| "/tmp/garnotify.sock".to_string())
 +}
++
 +/// Check if garnotify is healthy (socket exists)
 +fn is_garnotify_healthy() -> bool {
 +    std::path::Path::new(&garnotify_socket_path()).exists()
 +}
++
 +/// Spawn garnotify notification daemon
 +fn spawn_garnotify() -> Option<std::process::Child> {
 +    tracing::info!("Spawning garnotify...");
++
 +    // Try to find garnotify in PATH or common locations
 +    let garnotify_cmd = which_garnotify().unwrap_or_else(|| "garnotify".to_string());
++
 +    // Inherit DISPLAY from current environment
 +    let x_display = std::env::var("DISPLAY").unwrap_or_else(|_| ":0".to_string());
++
 +    match Command::new(&garnotify_cmd)
 +        .arg("daemon")
 +        .env("DISPLAY", &x_display)
 +        .spawn()
 +    {
 +        Ok(child) => {
 +            tracing::info!("garnotify started (PID {}), DISPLAY={}", child.id(), x_display);
++
 +            // Wait briefly and verify garnotify becomes healthy
 +            for attempt in 1..=10 {
 +                std::thread::sleep(std::time::Duration::from_millis(200));
 +                if is_garnotify_healthy() {
 +                    tracing::info!("garnotify socket ready after {}ms", attempt * 200);
 +                    return Some(child);
 +                }
 +            }
++
 +            // Socket never appeared - might still be starting up
 +            tracing::warn!("garnotify socket not ready after 2s, may still be starting");
 +            Some(child)
 +        }
 +        Err(e) => {
 +            tracing::error!("Failed to spawn garnotify: {}", e);
 +            tracing::info!("Hint: Ensure garnotify is installed and in PATH");
 +            None
 +        }
 +    }
 +}
++
 +/// Find garnotify executable
 +fn which_garnotify() -> Option<String> {
 +    // Check if garnotify is in PATH
 +    if Command::new("which")
 +        .arg("garnotify")
 +        .output()
 +        .map(|o| o.status.success())
 +        .unwrap_or(false)
 +    {
 +        return Some("garnotify".to_string());
 +    }
++
 +    // Check common cargo install location
 +    if let Ok(home) = std::env::var("HOME") {
 +        let cargo_bin = format!("{}/.cargo/bin/garnotify", home);
 +        if std::path::Path::new(&cargo_bin).exists() {
 +            return Some(cargo_bin);
 +        }
 +    }
++
 +    // Check /usr/local/bin
 +    if std::path::Path::new("/usr/local/bin/garnotify").exists() {
 +        return Some("/usr/local/bin/garnotify".to_string());
 +    }
++
 +    None
 +}
++
 +/// Stop garnotify gracefully by sending SIGTERM.
 +fn stop_garnotify(child: &mut std::process::Child) {
 +    tracing::info!("Stopping garnotify (PID {})...", child.id());
++
 +    // Send SIGTERM for graceful shutdown
 +    unsafe {
 +        libc::kill(child.id() as i32, libc::SIGTERM);
 +    }
++
 +    // Wait briefly for it to exit
 +    match child.try_wait() {
 +        Ok(Some(status)) => {
 +            tracing::info!("garnotify exited with status: {}", status);
 +        }
 +        Ok(None) => {
 +            std::thread::sleep(std::time::Duration::from_millis(100));
 +            match child.try_wait() {
 +                Ok(Some(status)) => {
 +                    tracing::info!("garnotify exited with status: {}", status);
 +                }
 +                Ok(None) => {
 +                    tracing::warn!("garnotify did not exit gracefully, sending SIGKILL");
 +                    let _ = child.kill();
 +                }
 +                Err(e) => {
 +                    tracing::warn!("Error waiting for garnotify: {}", e);
 +                }
 +            }
 +        }
 +        Err(e) => {
 +            tracing::warn!("Error checking garnotify status: {}", e);
 +        }
 +    }
 +}
++
  use x11rb::protocol::xproto::{
      ButtonPressEvent, ButtonReleaseEvent, ClientMessageEvent, ConfigureRequestEvent,
      ConfigureWindowAux, ConnectionExt, DestroyNotifyEvent, EnterNotifyEvent, EventMask,
              Event::EnterNotify(e) => {
                  self.handle_enter_notify(e)?;
+             }
 -            Event::RandrScreenChangeNotify(_) => {
 -                tracing::info!("RandR screen change detected, refreshing monitors");
 +            Event::RandrScreenChangeNotify(e) => {
 +                tracing::info!(
 +                    "RandR screen change: {}x{} -> {}x{}",
 +                    self.conn.screen_width, self.conn.screen_height,
 +                    e.width, e.height
 +                );
 +                // Update cached screen dimensions from the event
 +                self.conn.screen_width = e.width;
 +                self.conn.screen_height = e.height;
                  self.refresh_monitors()?;
                  self.broadcast_i3_output_event();
+             }
          // Apply layout to all windows
          self.apply_layout()?;
 +        // Flush to ensure ConfigureWindow requests are processed before we query geometry
 +        self.conn.flush()?;
 -        // Focus the new window if on a visible workspace
 +        // Focus and raise the new window if on a visible workspace
          if target_visible {
              self.set_focus(window, true)?;
 +            self.raise_window(window)?;
+         }
          Ok(())
                  self.conn.flush()?;
                  return Ok(());
+             }
 -            // Not on edge - if this is a focused floating window, replay the click
 +            // Not on edge - if this is a focused floating window, raise it and replay the click
 +            // This ensures clicking on a floating window that somehow ended up behind
 +            // other windows will bring it to the front
              if self.focused_window == Some(window) {
 +                self.raise_window(window)?;
                  self.conn.conn.allow_events(
                      x11rb::protocol::xproto::Allow::REPLAY_POINTER,
                      x11rb::CURRENT_TIME,
                      // Check for tiled edge hover (for cursor feedback)
                      self.update_tiled_edge_cursor(window, event.root_x, event.root_y)?;
+                 }
 -            } else if self.tiled_edge_cursor.is_some() {
 -                // Moving to unmanaged window or root - clear tiled edge cursor
 -                let (old_w1, old_w2, _) = self.tiled_edge_cursor.unwrap();
 -                self.conn.clear_window_cursor(old_w1)?;
 -                self.conn.clear_window_cursor(old_w2)?;
 -                self.conn.flush()?;
 -                self.tiled_edge_cursor = None;
 +            } else {
 +                if self.tiled_edge_cursor.is_some() {
 +                    // Moving to unmanaged window or root - clear tiled edge cursor
 +                    let (old_w1, old_w2, _) = self.tiled_edge_cursor.unwrap();
 +                    self.conn.clear_window_cursor(old_w1)?;
 +                    self.conn.clear_window_cursor(old_w2)?;
 +                    self.conn.flush()?;
 +                    self.tiled_edge_cursor = None;
 +                }
 +                // Pointer is on root/empty desktop — check for cross-monitor movement
 +                let monitor_idx = self.monitor_idx_at_point(event.root_x, event.root_y);
 +                if monitor_idx != self.focused_monitor {
 +                    let old_workspace_idx = self.focused_workspace;
 +                    self.focused_monitor = monitor_idx;
 +                    let workspace_idx = self.monitors[monitor_idx].active_workspace;
 +                    self.focused_workspace = workspace_idx;
 +                    self.focused_window = None;
 +                    self.conn.set_active_window(None)?;
 +                    self.conn.set_current_desktop(workspace_idx as u32)?;
 +                    if workspace_idx != old_workspace_idx {
 +                        self.broadcast_i3_workspace_event("focus", workspace_idx, Some(old_workspace_idx));
 +                    }
 +                    self.conn.flush()?;
 +                }
+             }
              return Ok(());
+         }
          y: i16,
          geometries: &[(u32, Rect)],
      ) -> Option<(u32, u32, Direction)> {
 -        const EDGE_ZONE: i16 = 32; // Detection zone from window edge (increased for easier grabbing)
 +        // Edge zone for resize detection - wide enough to cover gap + some margin
 +        // This makes it easy to grab edges: click near the boundary between windows
          let gap = self.config.gap_inner as i16;
 +        let edge_zone = gap + 8; // Gap width plus comfortable margin
          let left = rect.x;
          let right = rect.x + rect.width as i16;
          let top = rect.y;
          let bottom = rect.y + rect.height as i16;
 -        // Calculate distances from each edge
 -        let dist_from_left = x - left;
 -        let dist_from_right = right - x;
 -        let dist_from_top = y - top;
 -        let dist_from_bottom = bottom - y;
+-
 -        debug_log(&format!("EDGE DIST: x={}, y={}, left={}, right={}, top={}, bottom={}", x, y, left, right, top, bottom));
 -        debug_log(&format!("EDGE DIST: from_left={}, from_right={}, from_top={}, from_bottom={}, zone={}",
 -            dist_from_left, dist_from_right, dist_from_top, dist_from_bottom, EDGE_ZONE));
+-
 -        // Check each edge
 -        let near_left = x >= left && x < left + EDGE_ZONE;
 -        let near_right = x > right - EDGE_ZONE && x <= right;
 -        let near_top = y >= top && y < top + EDGE_ZONE;
 -        let near_bottom = y > bottom - EDGE_ZONE && y <= bottom;
+-
 -        debug_log(&format!("NEAR EDGES: left={}, right={}, top={}, bottom={}", near_left, near_right, near_top, near_bottom));
 +        // Check each edge - trigger if within edge_zone of the window boundary
 +        let near_left = x >= left && x < left + edge_zone;
 +        let near_right = x > right - edge_zone && x <= right;
 +        let near_top = y >= top && y < top + edge_zone;
 +        let near_bottom = y > bottom - edge_zone && y <= bottom;
          // For each edge we're near, look for an adjacent window
          if near_left {
          geometries: &[(u32, Rect)],
      ) -> Option<(u32, u32, Direction)> {
          let gap = self.config.gap_inner as i16;
 -        let tolerance = gap + 8; // Gap width plus some tolerance
++
 +        // Log all geometries for debugging
 +        for (w, r) in geometries {
 +            debug_log(&format!("GAP CHECK GEOM: w={}, x={}, y={}, w={}, h={}, right={}, bottom={}",
 +                w, r.x, r.y, r.width, r.height, r.x + r.width as i16, r.y + r.height as i16));
 +        }
          // Check all pairs of windows for horizontal adjacency (vertical split line)
          for (w1, r1) in geometries {
                  if w1 == w2 {
                      continue;
+                 }
 -                // Check if w2 is to the right of w1 (within gap distance)
 +                // Check if w2 is to the right of w1
                  let horizontal_gap = r2.x - r1_right;
 -                if horizontal_gap >= 0 && horizontal_gap <= tolerance {
 -                    // Check if click is in the gap horizontally
 -                    if x >= r1_right && x <= r2.x {
 +                debug_log(&format!("GAP H CHECK: w1={} right={}, w2={} left={}, gap={}, click_x={}",
 +                    w1, r1_right, w2, r2.x, horizontal_gap, x));
++
 +                // Allow detection if click is anywhere near the gap area
 +                // Gap region is from r1_right to r2.x, but expand by a few pixels for tolerance
 +                let gap_left = r1_right - 4;
 +                let gap_right = r2.x + 4;
++
 +                if horizontal_gap >= 0 && horizontal_gap <= gap + 16 {
 +                    if x >= gap_left && x <= gap_right {
                          // Check vertical overlap at click position
                          let v_overlap_top = r1.y.max(r2.y);
                          let v_overlap_bottom = (r1.y + r1.height as i16).min(r2.y + r2.height as i16);
 +                        debug_log(&format!("GAP H Y CHECK: y={}, v_top={}, v_bottom={}", y, v_overlap_top, v_overlap_bottom));
                          if y >= v_overlap_top && y < v_overlap_bottom {
                              debug_log(&format!("GAP EDGE FOUND H: w1={}, w2={}, gap_x=[{},{}], y_range=[{},{}]",
                                  w1, w2, r1_right, r2.x, v_overlap_top, v_overlap_bottom));
                  if w1 == w2 {
                      continue;
+                 }
 -                // Check if w2 is below w1 (within gap distance)
 +                // Check if w2 is below w1
                  let vertical_gap = r2.y - r1_bottom;
 -                if vertical_gap >= 0 && vertical_gap <= tolerance {
 -                    // Check if click is in the gap vertically
 -                    if y >= r1_bottom && y <= r2.y {
++
 +                // Allow detection if click is anywhere near the gap area
 +                let gap_top = r1_bottom - 4;
 +                let gap_bottom = r2.y + 4;
++
 +                if vertical_gap >= 0 && vertical_gap <= gap + 16 {
 +                    if y >= gap_top && y <= gap_bottom {
                          // Check horizontal overlap at click position
                          let h_overlap_left = r1.x.max(r2.x);
                          let h_overlap_right = (r1.x + r1.width as i16).min(r2.x + r2.width as i16);
              return Ok(());
+         }
 -        // Only focus windows we manage
 +        // For unmanaged windows (root window / empty desktop areas),
 +        // check if the pointer crossed to a different monitor and update
 +        // focused workspace accordingly so garbar underline tracks correctly.
          if !self.windows.contains_key(&window) {
 +            let monitor_idx = self.monitor_idx_at_point(event.root_x, event.root_y);
 +            if monitor_idx != self.focused_monitor {
 +                let old_workspace_idx = self.focused_workspace;
 +                self.focused_monitor = monitor_idx;
 +                let workspace_idx = self.monitors[monitor_idx].active_workspace;
 +                self.focused_workspace = workspace_idx;
 +                self.focused_window = None;
 +                self.conn.set_active_window(None)?;
 +                self.conn.set_current_desktop(workspace_idx as u32)?;
 +                if workspace_idx != old_workspace_idx {
 +                    self.broadcast_i3_workspace_event("focus", workspace_idx, Some(old_workspace_idx));
 +                }
 +                self.conn.flush()?;
 +            }
              return Ok(());
+         }
          tracing::debug!("Focus follows mouse: focusing window {}", window);
 +        let old_workspace_idx = self.focused_workspace;
++
          // Focus the new window (no warp - mouse enter)
          // set_focus handles grab/ungrab for old and new windows
          self.set_focus(window, false)?;
 +        // If workspace changed (cross-monitor mouse move), update EWMH and notify garbar
 +        if self.focused_workspace != old_workspace_idx {
 +            self.conn.set_current_desktop(self.focused_workspace as u32)?;
 +            self.broadcast_i3_workspace_event("focus", self.focused_workspace, Some(old_workspace_idx));
 +        }
++
          // Raise floating windows on focus
          if self.is_floating(window) {
              self.raise_window(window)?;
                      _ => {}
+                 }
+             }
 +            // Handle ABOVE state changes - raise window when requested
 +            else if property == self.conn.net_wm_state_above {
 +                match action {
 +                    1 | 2 => {
 +                        // Add or toggle ABOVE - raise the window
 +                        tracing::info!("Window {} requesting ABOVE state, raising", window);
 +                        if self.windows.contains_key(&window) {
 +                            self.raise_window(window)?;
 +                        }
 +                    }
 +                    _ => {}
 +                }
 +            }
          } else {
              tracing::trace!("Unhandled ClientMessage type: {}", msg_type);
+         }
              // Check if memory was used (preferred matched target) or default algorithm was used
              let used_memory = preferred == Some(target);
 +            tracing::info!("NAV: {:?} from {} to {}, preferred={:?}, used_memory={}",
 +                direction, focused, target, preferred, used_memory);
++
              // Store the directional focus memory for next time
              self.directional_focus_memory.insert((focused, direction), target);
 +            tracing::info!("NAV: stored ({}, {:?}) -> {}", focused, direction, target);
++
 +            // Always store reverse direction if windows are aligned (same row/column)
 +            // This ensures "go back" always returns to the window we came from
 +            if let (Some((_, from_rect)), Some((_, to_rect))) = (
 +                geometries.iter().find(|(w, _)| *w == focused),
 +                geometries.iter().find(|(w, _)| *w == target),
 +            ) {
 +                let overlaps = match direction {
 +                    // For Left/Right: store reverse if windows share vertical space (same row)
 +                    Direction::Left | Direction::Right => {
 +                        let overlap_start = from_rect.y.max(to_rect.y);
 +                        let overlap_end = (from_rect.y + from_rect.height as i16)
 +                            .min(to_rect.y + to_rect.height as i16);
 +                        tracing::info!("NAV: L/R overlap check: from_y={},{} to_y={},{} overlap=[{},{}]",
 +                            from_rect.y, from_rect.height, to_rect.y, to_rect.height, overlap_start, overlap_end);
 +                        overlap_start < overlap_end
 +                    }
 +                    // For Up/Down: store reverse if windows share horizontal space (same column)
 +                    Direction::Up | Direction::Down => {
 +                        let overlap_start = from_rect.x.max(to_rect.x);
 +                        let overlap_end = (from_rect.x + from_rect.width as i16)
 +                            .min(to_rect.x + to_rect.width as i16);
 +                        tracing::info!("NAV: U/D overlap check: from_x={},{} to_x={},{} overlap=[{},{}]",
 +                            from_rect.x, from_rect.width, to_rect.x, to_rect.width, overlap_start, overlap_end);
 +                        overlap_start < overlap_end
 +                    }
 +                };
 -            // Store reverse direction only if:
 -            // 1. Default algorithm was used (not memory-assisted jump that skipped windows)
 -            // 2. Windows are aligned (same row/column)
 -            if !used_memory {
 -                if let (Some((_, from_rect)), Some((_, to_rect))) = (
 -                    geometries.iter().find(|(w, _)| *w == focused),
 -                    geometries.iter().find(|(w, _)| *w == target),
 -                ) {
 -                    let dominated = match direction {
 -                        // For Left/Right: store reverse if windows share vertical space (same row)
 -                        Direction::Left | Direction::Right => {
 -                            let overlap_start = from_rect.y.max(to_rect.y);
 -                            let overlap_end = (from_rect.y + from_rect.height as i16)
 -                                .min(to_rect.y + to_rect.height as i16);
 -                            overlap_start < overlap_end
 -                        }
 -                        // For Up/Down: store reverse if windows share horizontal space (same column)
 -                        Direction::Up | Direction::Down => {
 -                            let overlap_start = from_rect.x.max(to_rect.x);
 -                            let overlap_end = (from_rect.x + from_rect.width as i16)
 -                                .min(to_rect.x + to_rect.width as i16);
 -                            overlap_start < overlap_end
 -                        }
 +                tracing::info!("NAV: overlaps={}", overlaps);
 +                if overlaps {
 +                    let opposite = match direction {
 +                        Direction::Left => Direction::Right,
 +                        Direction::Right => Direction::Left,
 +                        Direction::Up => Direction::Down,
 +                        Direction::Down => Direction::Up,
                      };
+-
 -                    if dominated {
 -                        let opposite = match direction {
 -                            Direction::Left => Direction::Right,
 -                            Direction::Right => Direction::Left,
 -                            Direction::Up => Direction::Down,
 -                            Direction::Down => Direction::Up,
 -                        };
 -                        self.directional_focus_memory.insert((target, opposite), focused);
 -                    }
 +                    self.directional_focus_memory.insert((target, opposite), focused);
 +                    tracing::info!("NAV: stored reverse ({}, {:?}) -> {}", target, opposite, focused);
+                 }
+             }
          };
          tracing::info!("Moving focus from monitor {} to {}", self.focused_monitor, target_idx);
 +        let old_workspace_idx = self.focused_workspace;
          self.focused_monitor = target_idx;
          // Focus the active workspace on that monitor
          let workspace_idx = self.monitors[target_idx].active_workspace;
          self.focused_workspace = workspace_idx;
 +        // Update EWMH
 +        self.conn.set_current_desktop(workspace_idx as u32)?;
++
          // Focus a window on that workspace if any, or just warp to monitor center
          if let Some(window) = self.workspaces[workspace_idx].focused
              .or_else(|| self.workspaces[workspace_idx].floating.last().copied())
          } else {
              // No windows on target monitor - clear focus and warp to monitor center
              self.focused_window = None;
 +            self.conn.set_active_window(None)?;
              self.warp_to_monitor(target_idx)?;
              tracing::debug!("No windows on monitor {}, warped to center", target_idx);
+         }
 +        // Broadcast i3 workspace event so garbar updates
 +        if workspace_idx != old_workspace_idx {
 +            self.broadcast_i3_workspace_event("focus", workspace_idx, Some(old_workspace_idx));
 +        }
++
          self.conn.flush()?;
          Ok(())
+     }
          Ok(())
+     }
 +    /// Force refresh layout - just re-apply layout.
 +    /// Note: GTK apps may not fully re-render at new scale without restart.
 +    fn force_refresh_layout(&mut self) -> Result<()> {
 +        self.apply_layout()?;
 +        tracing::info!("Layout refreshed");
 +        Ok(())
 +    }
++
      /// Execute an i3-compatible command (from IPC RUN_COMMAND).
      /// Returns true if the command was executed successfully.
      fn execute_i3_command(&mut self, cmd: &str) -> bool {
              // Focus the monitor that has this workspace
              self.focused_monitor = monitor_idx;
              self.focused_workspace = idx;
 +            self.workspaces[idx].last_monitor = Some(monitor_idx);
              // Update EWMH
              self.conn.set_current_desktop(idx as u32)?;
                  self.conn.set_active_window(None)?;
+             }
          } else {
 -            // Workspace not visible - show it on current monitor (i3 behavior)
 -            let current_monitor = self.focused_monitor;
 -            let old_ws = self.monitors[current_monitor].active_workspace;
 +            // Workspace not visible — show it on the monitor it was last on,
 +            // falling back to the current monitor if it was never shown.
 +            let target_monitor = self.workspaces[idx].last_monitor
 +                .filter(|&m| m < self.monitors.len())
 +                .unwrap_or(self.focused_monitor);
 +            let old_ws = self.monitors[target_monitor].active_workspace;
              tracing::info!(
                  "Switching monitor {} from workspace {} to {}",
 -                current_monitor, old_ws + 1, idx + 1
 +                target_monitor, old_ws + 1, idx + 1
              );
              // Hide windows on old workspace
+             }
              // Update monitor's active workspace
 -            self.monitors[current_monitor].active_workspace = idx;
 +            self.monitors[target_monitor].active_workspace = idx;
 +            self.workspaces[idx].last_monitor = Some(target_monitor);
 +            self.focused_monitor = target_monitor;
              self.focused_workspace = idx;
              // Update EWMH
                  self.focused_window = None;
                  self.conn.set_active_window(None)?;
                  if warp_pointer {
 -                    let monitor_geom = self.monitors[current_monitor].geometry;
 +                    let monitor_geom = self.monitors[target_monitor].geometry;
                      let center_x = monitor_geom.x + (monitor_geom.width as i16 / 2);
                      let center_y = monitor_geom.y + (monitor_geom.height as i16 / 2);
                      self.conn.warp_pointer(center_x, center_y)?;
              self.garbar_process = spawn_garbar();
+         }
 +        // Spawn garnotify if gar.notification is configured
 +        if self.config.notification_enabled {
 +            self.garnotify_process = spawn_garnotify();
 +        }
++
          while self.running {
              // Handle X11 events (non-blocking poll)
              while let Some(event) = self.conn.conn.poll_for_event()? {
          let _ = self.conn.sync();
          tracing::info!("Windows unmapped and synced");
 +        // Kill all processes spawned via gar.exec()/gar.exec_once()
 +        if let Ok(state) = self.lua_state.lock() {
 +            state.kill_spawned_children();
 +        }
++
          // Stop garbar if it was spawned
          if let Some(ref mut child) = self.garbar_process {
              stop_garbar(child);
+         }
          self.garbar_process = None;
 -        // Kill picom to prevent compositor effects from bleeding into the greeter
 -        tracing::info!("Killing picom...");
 +        // Stop garnotify if it was spawned
 +        if let Some(ref mut child) = self.garnotify_process {
 +            stop_garnotify(child);
 +        }
 +        self.garnotify_process = None;
++
 +        // Kill compositor to prevent overlay from bleeding into the greeter
 +        tracing::info!("Killing compositor...");
 +        // Use -f to match against full command line (needed for NixOS wrappers)
          let _ = std::process::Command::new("pkill")
 -            .arg("-x")
 -            .arg("picom")
 +            .args(["-f", "garchomp"])
 +            .status();
 +        let _ = std::process::Command::new("pkill")
 +            .args(["-f", "picom"])
              .status();
          // Signal systemd that graphical session has ended
                      Err(e) => Response::error(e.to_string()),
+                 }
+             }
 +            "refresh_layout" => {
 +                // Re-apply layout to all windows without changing ratios.
 +                // Useful after display scaling changes when GTK apps resize internally.
 +                // Two-step approach: first shrink windows, then expand - forces GTK to re-layout.
 +                match self.force_refresh_layout() {
 +                    Ok(_) => {
 +                        tracing::info!("Layout force-refreshed");
 +                        Response::success(None)
 +                    }
 +                    Err(e) => Response::error(e.to_string()),
 +                }
 +            }
              "reload" => {
                  match self.reload_config() {
                      Ok(_) => Response::success(None),
          // Update stacking order in workspace's floating list
          self.current_workspace_mut().raise_floating(window);
 -        // Raise in X11
 +        // Raise in X11 - if window has a frame, raise the frame instead
          let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 -        self.conn.conn.configure_window(window, &aux)?;
 +        if let Some(frame) = self.frames.frame_for_client(window) {
 +            tracing::info!("raise_window: window={} -> raising frame={}", window, frame);
 +            self.conn.conn.configure_window(frame, &aux)?;
 +        } else {
 +            tracing::info!("raise_window: window={} (no frame)", window);
 +            self.conn.conn.configure_window(window, &aux)?;
 +        }
          self.conn.flush()?;
          Ok(())
+     }
+         }
          tracing::info!("Focusing monitor {}: '{}'", target_idx, self.monitors[target_idx].name);
 +        let old_workspace_idx = self.focused_workspace;
          self.focused_monitor = target_idx;
          // Focus the active workspace on that monitor
          let workspace_idx = self.monitors[target_idx].active_workspace;
          self.focused_workspace = workspace_idx;
 +        // Update EWMH
 +        self.conn.set_current_desktop(workspace_idx as u32)?;
++
          // Focus a window on that workspace if any, or warp to monitor center
          if let Some(window) = self.workspaces[workspace_idx].focused
              .or_else(|| self.workspaces[workspace_idx].floating.last().copied())
              // set_focus handles grab/ungrab for old and new windows
              self.set_focus(window, true)?;
          } else {
 -            // No windows - warp to monitor center
 +            // No windows - clear EWMH active window and warp to monitor center
              self.focused_window = None;
 +            self.conn.set_active_window(None)?;
              self.warp_to_monitor(target_idx)?;
+         }
 +        // Broadcast i3 workspace event so garbar updates
 +        if workspace_idx != old_workspace_idx {
 +            self.broadcast_i3_workspace_event("focus", workspace_idx, Some(old_workspace_idx));
 +        }
++
          self.conn.flush()?;
          Ok(())
+     }
              window, target_idx, self.monitors[target_idx].name, target_workspace + 1);
          // Remove from current workspace
 +        let source_ws = self.focused_workspace;
          if is_floating {
              self.current_workspace_mut().remove_floating(window);
          } else {
              self.current_workspace_mut().tree.remove(window);
+         }
 +        // Update focus on source workspace so it doesn't point to the moved window
 +        let new_focus_on_source = self.workspaces[source_ws].tree.first_window()
 +            .or_else(|| self.workspaces[source_ws].floating.last().copied());
 +        self.workspaces[source_ws].focused = new_focus_on_source;
++
          // Update window's workspace
          if let Some(win) = self.windows.get_mut(&window) {
              win.workspace = target_workspace;
          self.conn.set_window_desktop(window, target_workspace as u32)?;
          // Focus follows window to new monitor
 +        let old_workspace_idx = self.focused_workspace;
          self.focused_monitor = target_idx;
          self.focused_workspace = target_workspace;
          self.workspaces[target_workspace].focused = Some(window);
 +        // Update EWMH
 +        self.conn.set_current_desktop(target_workspace as u32)?;
++
          // Apply layouts on both monitors
          self.apply_layout()?;
          // Set X11 focus on the moved window (updates focused_window, button grabs, EWMH)
          self.set_focus(window, true)?;
 +        // Broadcast i3 workspace event so garbar updates
 +        if target_workspace != old_workspace_idx {
 +            self.broadcast_i3_workspace_event("focus", target_workspace, Some(old_workspace_idx));
 +        }
++
          self.conn.flush()?;
          Ok(())
+     }

garctl/src/main.rsmodified

      ToggleFloating,
      /// Equalize split ratios
      Equalize,
 +    /// Refresh window layout (re-apply without changing ratios)
 +    RefreshLayout,
      /// Reload configuration
      Reload,
      /// Exit gar
          Command::Equalize => {
              json!({ "command": "equalize", "args": {} })
+         }
 +        Command::RefreshLayout => {
 +            json!({ "command": "refresh_layout", "args": {} })
 +        }
          Command::Reload => {
              json!({ "command": "reload", "args": {} })
+         }

`@@ -11,6 +11,8 @@` pub struct Workspace {
11	11	pub floating: Vec<XWindow>,
12	12	pub focused: Option<XWindow>,
13	13	pub visible: bool,
	14	+ /// Last monitor this workspace was displayed on (for focus-back behavior)
	15	+ pub last_monitor: Option<usize>,
14	16	}
15	17
16	18	impl Workspace {
`@@ -22,6 +24,7 @@` impl Workspace {
22	24	floating: Vec::new(),
23	25	focused: None,
24	26	visible: id == 1,
	27	+ last_monitor: None,
25	28	}
26	29	}
27	30