monolith

public

Star0

Fork 0

Watch0

326 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `bae1138a3e88`

tarball

atagen <boss@atagen.co>2026-10-19 11:48 UTC

3 files changed+16-14

launch: put windows on homeless unless something places them

Since 1cf303f made focus at map time the last resort, any window without a rule, token, parent, spawn record or owning ancestor fell to launch_tag, which picked the first viewed tag whenever the focus was on homeless. Viewing an empty tag 1 then pulled every unattributed window onto it. launch_tag now follows the focused window's tag even when that is homeless, and unattributed windows only take the focused output.

Modified file: crates/layout/src/lib.rs+7 additions−8 deletions@@ -302,16 +302,13 @@ impl Layout {
         }
     }
 
-    /// The tag a launch from `o` belongs to. The focused window's tag, else
-    /// the first viewed tag, else homeless. Homeless is always on screen, so
-    /// focusing one of its windows does not mean the user left their tag.
+    /// The tag a launch from `o` belongs to, the focused window's tag or else
+    /// homeless.
     pub fn launch_tag(&self, o: OutputId) -> TagId {
         self.focused_on(o)
             .map(|w| &self.windows[w])
-            .filter(|w| w.scratchpad.is_none() && !w.sticky && w.tag != self.homeless)
-            .map(|w| w.tag)
-            .or_else(|| self.outputs.get(o)?.viewed.first().copied())
-            .unwrap_or(self.homeless)
+            .filter(|w| w.scratchpad.is_none() && !w.sticky)
+            .map_or(self.homeless, |w| w.tag)
     }
 
     pub fn view_everywhere(&mut self, tag: TagId) {
@@ -777,7 +774,9 @@ impl Layout {
         };
         if let Some(s) = win.scratchpad {
             let o = win.output.or(self.active);
-            let tag = o.map_or(self.homeless, |o| self.launch_tag(o));
+            let tag = o
+                .and_then(|o| self.outputs.get(o)?.viewed.first().copied())
+                .unwrap_or(self.homeless);
             self.leave_scratchpad(s, w);
             let win = &mut self.windows[w];
             win.output = o;

Modified file: crates/monolith/src/launch.rs+7 additions−4 deletions@@ -1,7 +1,8 @@
 //! Launch context. A window goes to the output and tag the user was on when
 //! its launch began. Its process and then each ancestor is matched against
 //! processes that own a mapped window and the programs monolith spawned, the
-//! nearest match deciding, and the focus at map time is the last resort.
+//! nearest match deciding. Anything unmatched goes to the homeless tag on
+//! the focused output.
 
 use crate::state::State;
 use monolith_layout::{OutputId, TagId};
@@ -48,10 +49,12 @@ impl State {
     /// Where the window of process `pid` belongs. The nearest of `pid` and
     /// its ancestors that owns a mapped window decides, so a program's later
     /// windows follow its first one wherever the user moved it. Failing that
-    /// the nearest program monolith spawned recently, then the focus now.
+    /// the nearest program monolith spawned recently, then the homeless tag
+    /// on the focused output.
     pub fn launch_of(&self, pid: Option<u32>) -> (Option<OutputId>, TagId) {
+        let unknown = || (self.wm.layout.active_output(), self.wm.layout.homeless());
         let Some(pid) = pid else {
-            return self.launch_context();
+            return unknown();
         };
         let owners: Vec<(u32, OutputId, TagId)> = self
             .wm
@@ -71,7 +74,7 @@ impl State {
                     .map(|&(_, output, tag)| (Some(output), tag))
                     .or_else(|| self.services.launches.get(p))
             })
-            .unwrap_or_else(|| self.launch_context())
+            .unwrap_or_else(unknown)
     }
 
     pub fn window_pid(&self, window: &smithay::desktop::Window) -> Option<u32> {

Modified file: design/decisions.md+2 additions−2 deletions@@ -78,9 +78,9 @@ Running log of settled decisions and open questions. Research backing lives in `
 
 - Interrupts replan, they never stack. No plan-length cap.
 - Velocity matching is best-effort, applied only where the replan continues the current axis.
-- Launch context resolves through a graceful ranking. Window rule, xdg-activation token, parent toplevel, tracked systemd scope or cgroup, PID ancestry, focus at map time. The target is where the user was when the launch command began. Windows placed on an unviewed tag mark it urgent.
+- Launch context resolves through a graceful ranking. Window rule, xdg-activation token, parent toplevel, tracked systemd scope or cgroup, PID ancestry, then the focused output with the homeless tag. The target is where the user was when the launch command began. Windows placed on an unviewed tag mark it urgent.
 - Nested sessions are a first-class, permanently supported backend.
-- A launch belongs to the focused window's tag, unless that is homeless, then to the first viewed tag. Homeless is always on screen, so focusing its windows does not mean the user left their tag.
+- A launch belongs to the focused window's tag, homeless included, and to homeless when nothing is focused. A window nothing attributes lands on homeless on the focused output, never on a viewed tag by default (reversed 2026-10-19).
 - VRR defaults to `fullscreen`, on only while a fullscreen window shows on a capable output. Under VRR frames go out as soon as there is something new, and cursor-only frames are capped at 60 Hz.
 - Layer-shell exclusive zones are insets on the layout output, so fullscreen still covers the whole output. The top layer hides under fullscreen, the overlay layer does not.
 - An activation token takes focus only if monolith made it or its requester held the keyboard, and only within 10 s. Otherwise the window is marked urgent. A token arriving before a window's first buffer may still move it to its launch context unless a rule placed it.

monolith

Commit bae1138a3e88

Commit `bae1138a3e88`