monolith

public

Star0

Fork 0

Watch0

118 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `9b87063809e1`

tarball

atagen <boss@atagen.co>2026-10-17 13:29 UTC

4 files changed+134-14

monolith: configure output rotation, position and mode per connector

Outputs were always unrotated, at their preferred mode and lined up left to right in connection order, so a portrait monitor could not be used. The settings apply when the output connects, since a new mode or rotation needs a modeset.

Modified file: crates/config/default.toml+8 additions@@ -34,6 +34,14 @@ unfocused = "#3b4252"
 # Variable refresh rate on outputs that support it, off, on, or fullscreen.
 vrr = "fullscreen"
 
+# Per connector, read when the output connects. transform is normal, 90, 180,
+# 270, flipped, flipped-90, flipped-180 or flipped-270. Outputs without a
+# position line up left to right.
+# [output.DP-1]
+# transform = "90"
+# position = [2560, 0]
+# mode = "1920x1080@60"
+
 [animation]
 enabled = true
 # orthogonal moves each window along one axis per phase, direct allows both.

Modified file: crates/config/src/lib.rs+47 additions−2 deletions@@ -78,9 +78,47 @@ impl Default for Gaps {
 }
 
 #[derive(Deserialize, Debug, Clone, PartialEq, Default)]
-#[serde(default, deny_unknown_fields)]
+#[serde(default)]
 pub struct Outputs {
     pub vrr: Vrr,
+    /// Settings for one connector, by name, like `DP-1`.
+    #[serde(flatten)]
+    pub named: std::collections::BTreeMap<String, OutputConfig>,
+}
+
+/// Applied when the output connects. Changing them needs a restart or a
+/// replug, since a new mode or rotation means a modeset.
+#[derive(Deserialize, Debug, Clone, PartialEq, Default)]
+#[serde(default, deny_unknown_fields)]
+pub struct OutputConfig {
+    pub transform: OutputTransform,
+    /// Top left corner in the global layout. Outputs without one are placed
+    /// to the right of the others.
+    pub position: Option<[i32; 2]>,
+    /// `WIDTHxHEIGHT` or `WIDTHxHEIGHT@HZ`. Without a rate the highest one
+    /// for that size wins.
+    pub mode: Option<String>,
+}
+
+/// Counterclockwise rotation, optionally after flipping horizontally.
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[serde(rename_all = "kebab-case")]
+pub enum OutputTransform {
+    #[default]
+    Normal,
+    #[serde(rename = "90")]
+    Rotate90,
+    #[serde(rename = "180")]
+    Rotate180,
+    #[serde(rename = "270")]
+    Rotate270,
+    Flipped,
+    #[serde(rename = "flipped-90")]
+    Flipped90,
+    #[serde(rename = "flipped-180")]
+    Flipped180,
+    #[serde(rename = "flipped-270")]
+    Flipped270,
 }
 
 #[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
@@ -568,6 +606,11 @@ mod tests {
             [binds]
             "Mod+Return" = "spawn beer"
             "Hyper+x" = "close"
+            [output.DP-1]
+            transform = "90"
+            position = [0, 0]
+            [output.DP-2]
+            transform = "sideways"
             [[rules]]
             app_id = "("
             [[rules]]
@@ -582,6 +625,8 @@ mod tests {
         assert_eq!(c.decoration.radius, Corners([1, 2, 3, 4]));
         assert_eq!(c.decoration.focused, Decoration::default().focused);
         assert_eq!((c.binds.len(), c.rules.len()), (1, 1));
-        assert_eq!(loaded.warnings.len(), 5, "{:#?}", loaded.warnings);
+        assert_eq!(c.output.named["DP-1"].transform, OutputTransform::Rotate90);
+        assert!(!c.output.named.contains_key("DP-2"));
+        assert_eq!(loaded.warnings.len(), 6, "{:#?}", loaded.warnings);
     }
 }

Modified file: crates/monolith/src/drm.rs+78 additions−12 deletions@@ -7,7 +7,7 @@ use crate::scene::Draw;
 use crate::state::Services;
 use crate::state::{State, now_ns};
 use crate::wm::Wm;
-use monolith_config::Vrr;
+use monolith_config::{OutputTransform, Vrr};
 use monolith_layout::{OutputId, Rect};
 use smithay::backend::allocator::Fourcc;
 use smithay::backend::allocator::gbm::{GbmAllocator, GbmBufferFlags, GbmDevice};
@@ -31,7 +31,7 @@ use smithay::output::{Mode, Output, PhysicalProperties, Scale, Subpixel};
 use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
 use smithay::reexports::calloop::{EventLoop, LoopHandle, RegistrationToken};
 use smithay::reexports::drm::Device as _;
-use smithay::reexports::drm::control::{ModeTypeFlags, connector, crtc};
+use smithay::reexports::drm::control::{self, ModeTypeFlags, connector, crtc};
 use smithay::reexports::input::Libinput;
 use smithay::reexports::rustix::fs::OFlags;
 use smithay::utils::{DeviceFd, Point, Transform};
@@ -265,15 +265,33 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
         connector.interface().as_str(),
         connector.interface_id()
     );
-    let Some(&mode) = connector
-        .modes()
-        .iter()
-        .find(|m| m.mode_type().contains(ModeTypeFlags::PREFERRED))
-        .or_else(|| connector.modes().first())
-    else {
+    let config = state
+        .settings
+        .config
+        .output
+        .named
+        .get(&name)
+        .cloned()
+        .unwrap_or_default();
+    let chosen = config.mode.as_deref().and_then(|spec| {
+        let found = pick_mode(connector.modes(), spec);
+        if found.is_none() {
+            tracing::warn!(name, spec, "no such mode, using the preferred one");
+        }
+        found
+    });
+    let Some(mode) = chosen.or_else(|| {
+        connector
+            .modes()
+            .iter()
+            .find(|m| m.mode_type().contains(ModeTypeFlags::PREFERRED))
+            .or_else(|| connector.modes().first())
+            .copied()
+    }) else {
         tracing::warn!(name, "connector has no modes");
         return;
     };
+    let transform = transform(config.transform);
     let State {
         backend: Backend::Drm(drm),
         renderer,
@@ -296,14 +314,17 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
         },
     );
     let wl_mode = Mode::from(mode);
-    let x = layout
+    let right = layout
         .outputs()
         .map(|(_, o)| o.area.right())
         .fold(0.0, f64::max);
-    let position = Point::from((x as i32, 0));
+    let position = match config.position {
+        Some([x, y]) => Point::from((x, y)),
+        None => Point::from((right as i32, 0)),
+    };
     output.change_current_state(
         Some(wl_mode),
-        Some(Transform::Normal),
+        Some(transform),
         Some(Scale::Integer(1)),
         Some(position),
     );
@@ -337,13 +358,24 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
     );
     space.map_output(&output, position);
     let (w, h) = mode.size();
-    let area = Rect::new(x, 0.0, f64::from(w), f64::from(h));
+    let size = transform.transform_size(
+        smithay::utils::Size::<i32, smithay::utils::Logical>::from((i32::from(w), i32::from(h))),
+    );
+    let area = Rect::new(
+        f64::from(position.x),
+        f64::from(position.y),
+        f64::from(size.w),
+        f64::from(size.h),
+    );
     let id = layout.add_output(&name, area);
     tracing::info!(
         name,
         w,
         h,
         refresh = mode.vrefresh(),
+        ?transform,
+        x = position.x,
+        y = position.y,
         vrr_capable,
         "output connected"
     );
@@ -372,6 +404,40 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
     );
 }
 
+/// The mode matching `WIDTHxHEIGHT` or `WIDTHxHEIGHT@HZ`, the highest rate
+/// when none is given and the nearest one when it is.
+fn pick_mode(modes: &[control::Mode], spec: &str) -> Option<control::Mode> {
+    let (size, rate) = match spec.split_once('@') {
+        Some((size, rate)) => (size, Some(rate.trim().parse::<f64>().ok()?)),
+        None => (spec, None),
+    };
+    let (w, h) = size.trim().split_once('x')?;
+    let size = (w.trim().parse::<u16>().ok()?, h.trim().parse::<u16>().ok()?);
+    let fitting = modes.iter().filter(|m| m.size() == size);
+    match rate {
+        Some(r) => fitting
+            .min_by(|a, b| {
+                let off = |m: &&control::Mode| (f64::from(m.vrefresh()) - r).abs();
+                off(a).total_cmp(&off(b))
+            })
+            .copied(),
+        None => fitting.max_by_key(|m| m.vrefresh()).copied(),
+    }
+}
+
+fn transform(t: OutputTransform) -> Transform {
+    match t {
+        OutputTransform::Normal => Transform::Normal,
+        OutputTransform::Rotate90 => Transform::_90,
+        OutputTransform::Rotate180 => Transform::_180,
+        OutputTransform::Rotate270 => Transform::_270,
+        OutputTransform::Flipped => Transform::Flipped,
+        OutputTransform::Flipped90 => Transform::Flipped90,
+        OutputTransform::Flipped180 => Transform::Flipped180,
+        OutputTransform::Flipped270 => Transform::Flipped270,
+    }
+}
+
 fn disconnect(state: &mut State, crtc: crtc::Handle) {
     let Some(drm) = state.backend.drm_mut() else {
         return;

Modified file: design/test-checklist.md+1

@@ -33,6 +33,7 @@ nix develop -c sh -c 'RUST_LOG=monolith=debug target/release/monolith run --back

3333 - [ ] **vkcube black start.** Is the half second of black at launch gone?

3434

 - [ ] **Fullscreen switches.** Toggle fullscreen on vkcube a few times and look for `slow frame` lines. First-time imports now run on a worker thread.

3535

 - [ ] **Direct scanout.** Fullscreen vkcube should log `direct scanout scanout=true`, and its `frame rate` lines should show `scanned_out` close to `presented`. If it logs `scanout=false` or never switches, the `elements`, `overlay_planes` and `cursor_plane` fields on that line show what was on screen with it.

+- [ ] **Output rotation.** `[output.DP-1] transform = "90"` with a `position` puts DP-1 on its side where you placed it. The `output connected` log line shows the transform and position. The pointer should cross between outputs where their edges meet.

3637 - [ ] **CPU target.** `cpu_p99_us` on the `frame rate` lines should stay under 500, the target in decisions.md.

3738

 - [ ] **NixOS module.** Add the flake as an input, import `monolith.nixosModules.default` and set `programs.monolith.enable = true`. A `monolith` session appears in the display manager. With the default `realtime-scheduling = true`, the log should show `compositor thread runs SCHED_RR` and `queue global priority priority=Some(REALTIME)`. Programs launched from monolith should not inherit CAP_SYS_NICE, which `grep Cap /proc/(pgrep beer)/status` shows as an all-zero `CapAmb`.

monolith

Commit 9b87063809e1

Commit `9b87063809e1`