Rift Tiling Window Manager

Rift is a tiling window manager for macOS designed for high performance and usability. It provides several layout styles including:

• Tiling (i3/sway-like)
• Binary Space Partitioning (bspwm-like)
• Master-stack (dwm-like)
• Scrolling columns (niri-style). Note: When using multiple displays with the scrolling layout, displays must be arranged in a vertical stack to prevent windows from leaking into other displays.
• Stack (accordion)

Key features include:

• MacOS-style Mission Control for visual workspace navigation.
• Menubar icon for switching workspaces, changing layouts, and accessing controls.
• Layout Management: Save and restore layouts via the menu bar or CLI from a configurable folder.
• Mouse/Trackpad Integration: Focus follows mouse with auto-raise, window swapping via dragging, and native-style trackpad gestures for workspace switching.
• System Compatibility: Works with "Displays have separate Spaces" enabled and does not require disabling SIP.
• Hot reloadable configuration.
• Third-party Interop: Supports requests via CLI or Mach port (including a Lua client) and sends signals on startup, workspace switches, and window changes.

In Rift, workflows mutate the reactor's domain state synchronously and then return an EventOutcome. An EventOutcome describes the ordered integration work (side effects) that must occur after the mutation. This separation allows for testing policy logic without executing actual platform operations.

Key capabilities of an EventOutcome include:

• Window Management: Requesting window discoveries, frame writes, title broadcasts, or window closures.
• Space/Topology Control: Reassigning windows to different spaces, switching native spaces, or recomputing active spaces.
• Application Interaction: Activating applications, sending app-specific requests, or re-applying app rules.
• Layout & UI: Triggering layout events, arranging windows, warping the mouse, or dispatching mouse events.
• System Integration: Updating service configurations, writing to stdout, or performing Mission Control recovery.

The StackLine actor processes several types of Events to manage the lifecycle and interaction of UI indicators:

• GroupsUpdated: Triggered when window groups change. Updates indicators, handles visibility based on fullscreen state, and syncs hit-rects.
• SpaceStateUpdated: Updates the CoordinateConverter used for mapping coordinates.
• ConfigUpdated: Updates the internal Config. If the stack line is disabled, it clears all existing indicators.
• MouseDown: Processes a click at a specific CGPoint. The event tap is expected to have already confirmed the point lands on a visible indicator.
• MouseMoved: Updates the cursor state (e.g., switching to a pointingHandCursor when hovering over an indicator) and handles hover-based activation if StackLineHoverMode::Hover is enabled.

pub enum Event {
    GroupsUpdated {
        active_space_ids: Vec<SpaceId>,
        space_id: SpaceId,
        groups: Vec<GroupInfo>,
        active_workspace_for_space_has_fullscreen: bool,
    },
    SpaceStateUpdated(CoordinateConverter, ForwardedSpaceState),
    ConfigUpdated(Config),
    MouseDown(CGPoint),
    MouseMoved {
        point: CGPoint,
        hits_indicator: bool,
    },
}

Rift allows you to define AppWorkspaceRule objects to automate window management. Rules can match windows based on several criteria and dictate whether a window should be managed (assigned to a specific workspace) or floating.

Supported matching criteria:

• app_id: The bundle identifier of the application.
• app_name: The name of the application.
• title_regex: A regular expression to match against the window title.
• title_substring: A simple substring match against the window title.
• ax_role / ax_subrole: Accessibility roles and subroles.

Rules can specify a target workspace using a WorkspaceSelector:

• WorkspaceSelector::Index(usize): Selects a workspace by its position in the list.
• WorkspaceSelector::Name(String): Selects a workspace by its exact name.

Key fields in AppWorkspaceRule:

• manage: If true, Rift will attempt to assign the window to a workspace.
• floating: If true, the window will be treated as a floating window (not tied to a specific workspace).
• workspace: An optional WorkspaceSelector defining the target workspace.

// Example: Match a specific app and force it to float
AppWorkspaceRule {
    app_id: Some("com.example.test".into()),
    workspace: None,
    floating: true,
    manage: true,
    app_name: None,
    title_regex: None,
    title_substring: None,
    ax_role: None,
    ax_subrole: None,
}

// Example: Match by window title substring and assign to workspace index 1
AppWorkspaceRule {
    app_id: None,
    workspace: Some(WorkspaceSelector::Index(1)),
    floating: false,
    manage: true,
    app_name: Some("Calendar".into()),
    title_regex: None,
    title_substring: None,
    ax_role: None,
    ax_subrole: None,
}