`c44f0c4`

initial skeleton: workspace, x11 composite, event loop, IPC

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: c44f0c46bfc9d16055d4ee78e2689641c4ec0c89
Tree: e79d9e8

15 changed files

Status	File	+
A	`.gitignore`	23
A	`Cargo.toml`	35
A	`garchomp-ipc/Cargo.toml`	10
A	`garchomp-ipc/src/lib.rs`	65
A	`garchomp/Cargo.toml`	19
A	`garchomp/src/compositor/mod.rs`	344
A	`garchomp/src/compositor/window.rs`	93
A	`garchomp/src/ipc/mod.rs`	98
A	`garchomp/src/main.rs`	165
A	`garchomp/src/x11/atoms.rs`	63
A	`garchomp/src/x11/composite.rs`	121
A	`garchomp/src/x11/connection.rs`	131
A	`garchomp/src/x11/mod.rs`	9
A	`garchompctl/Cargo.toml`	12
A	`garchompctl/src/main.rs`	98

.gitignoreadded

 +# Build artifacts
 +/target/
 +**/*.rs.bk
 +Cargo.lock
++
 +# IDE
 +.idea/
 +.vscode/
 +*.swp
 +*.swo
 +*~
++
 +# Documentation (planning files)
 +/docs/ROADMAP.md
 +/docs/sprints/
++
 +# Logs
 +*.log
 +/tmp/
++
 +# OS
 +.DS_Store
 +Thumbs.db

Cargo.tomladded

 +[workspace]
 +resolver = "2"
 +members = ["garchomp", "garchompctl", "garchomp-ipc"]
++
 +[workspace.package]
 +version = "0.1.0"
 +edition = "2024"
 +authors = ["gardesk contributors"]
 +license = "MIT"
 +repository = "https://github.com/gardesk/garchomp"
++
 +[workspace.dependencies]
 +# X11
 +x11rb = { version = "0.13", features = ["allow-unsafe-code", "randr", "composite", "damage", "xfixes", "shape", "render"] }
++
 +# Async
 +tokio = { version = "1", features = ["full", "signal"] }
++
 +# Serialization
 +serde = { version = "1", features = ["derive"] }
 +serde_json = "1"
++
 +# CLI
 +clap = { version = "4", features = ["derive"] }
++
 +# Logging
 +tracing = "0.1"
 +tracing-subscriber = { version = "0.3", features = ["env-filter"] }
++
 +# Errors
 +thiserror = "2"
 +anyhow = "1"
++
 +# Internal
 +garchomp-ipc = { path = "garchomp-ipc" }

garchomp-ipc/Cargo.tomladded

 +[package]
 +name = "garchomp-ipc"
 +description = "IPC types for garchomp compositor"
 +version.workspace = true
 +edition.workspace = true
 +license.workspace = true
++
 +[dependencies]
 +serde = { workspace = true }
 +serde_json = { workspace = true }

garchomp-ipc/src/lib.rsadded

 +//! IPC protocol types for garchomp compositor.
++
 +use serde::{Deserialize, Serialize};
++
 +/// Request sent to garchomp.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +#[serde(tag = "type", rename_all = "snake_case")]
 +pub enum Request {
 +    /// Reload configuration.
 +    Reload,
 +    /// Toggle an effect.
 +    SetEffect { effect: String, enabled: bool },
 +    /// Set blur strength (0-20).
 +    SetBlurStrength { strength: u32 },
 +    /// Get window information.
 +    GetWindowInfo { window: u32 },
 +    /// List all managed windows.
 +    ListWindows,
 +    /// Ping for health check.
 +    Ping,
 +}
++
 +/// Response from garchomp.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +#[serde(tag = "type", rename_all = "snake_case")]
 +pub enum Response {
 +    /// Success with no data.
 +    Ok,
 +    /// Error response.
 +    Error { message: String },
 +    /// Pong response to ping.
 +    Pong,
 +    /// Window information.
 +    WindowInfo(WindowInfo),
 +    /// List of windows.
 +    WindowList { windows: Vec<WindowInfo> },
 +}
++
 +/// Information about a managed window.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +pub struct WindowInfo {
 +    pub id: u32,
 +    pub x: i16,
 +    pub y: i16,
 +    pub width: u16,
 +    pub height: u16,
 +    pub mapped: bool,
 +    pub override_redirect: bool,
 +}
++
 +/// Events sent from gar WM to garchomp.
 +#[derive(Debug, Clone, Serialize, Deserialize)]
 +#[serde(tag = "type", rename_all = "snake_case")]
 +pub enum GarEvent {
 +    /// Workspace changed.
 +    WorkspaceChanged {
 +        from: usize,
 +        to: usize,
 +        direction: String,
 +    },
 +    /// Focus changed.
 +    FocusChanged { old: Option<u32>, new: Option<u32> },
 +    /// Window entered fullscreen.
 +    WindowFullscreen { window: u32, fullscreen: bool },
 +}

garchomp/Cargo.tomladded

 +[package]
 +name = "garchomp"
 +description = "X11 compositor for gar desktop environment"
 +version.workspace = true
 +edition.workspace = true
 +license.workspace = true
++
 +[dependencies]
 +garchomp-ipc = { workspace = true }
 +x11rb = { workspace = true }
 +tokio = { workspace = true }
 +serde = { workspace = true }
 +serde_json = { workspace = true }
 +clap = { workspace = true, features = ["env"] }
 +tracing = { workspace = true }
 +tracing-subscriber = { workspace = true }
 +thiserror = { workspace = true }
 +anyhow = { workspace = true }
 +ctrlc = "3"

garchomp/src/compositor/mod.rsadded

 +//! Core compositor state and event handling.
++
 +mod window;
++
 +pub use window::{TrackedWindow, WindowType};
++
 +use crate::x11::{CompositeExt, Connection};
 +use std::collections::HashMap;
 +use thiserror::Error;
 +use x11rb::connection::Connection as _;
 +use x11rb::protocol::damage::{ConnectionExt as DamageConnectionExt, ReportLevel};
 +use x11rb::protocol::xproto::{
 +    AtomEnum, ChangeWindowAttributesAux, ConfigureNotifyEvent, ConnectionExt, CreateNotifyEvent,
 +    DestroyNotifyEvent, EventMask, MapNotifyEvent, PropertyNotifyEvent,
 +    UnmapNotifyEvent, Window,
 +};
 +use x11rb::protocol::Event;
++
 +#[derive(Error, Debug)]
 +pub enum CompositorError {
 +    #[error("X11 connection error: {0}")]
 +    Connection(#[from] crate::x11::ConnectionError),
++
 +    #[error("X11 error: {0}")]
 +    X11(#[from] x11rb::errors::ConnectionError),
++
 +    #[error("X11 reply error: {0}")]
 +    Reply(#[from] x11rb::errors::ReplyError),
 +}
++
 +pub type Result<T> = std::result::Result<T, CompositorError>;
++
 +/// The main compositor state.
 +pub struct Compositor {
 +    pub conn: Connection,
 +    pub overlay: Window,
 +    pub windows: HashMap<Window, TrackedWindow>,
 +    pub running: bool,
 +}
++
 +impl Compositor {
 +    /// Create a new compositor instance.
 +    pub fn new() -> Result<Self> {
 +        let conn = Connection::new()?;
++
 +        // Redirect all windows for compositing
 +        conn.redirect_subwindows()?;
++
 +        // Get the overlay window
 +        let overlay = conn.get_overlay_window()?;
 +        conn.configure_overlay(overlay)?;
++
 +        // Subscribe to events on root window
 +        let event_mask = EventMask::SUBSTRUCTURE_NOTIFY
 +            | EventMask::STRUCTURE_NOTIFY
 +            | EventMask::PROPERTY_CHANGE;
++
 +        conn.conn.change_window_attributes(
 +            conn.root(),
 +            &ChangeWindowAttributesAux::new().event_mask(event_mask),
 +        )?;
++
 +        conn.flush()?;
++
 +        let mut compositor = Self {
 +            conn,
 +            overlay,
 +            windows: HashMap::new(),
 +            running: true,
 +        };
++
 +        // Scan existing windows
 +        compositor.scan_windows()?;
++
 +        Ok(compositor)
 +    }
++
 +    /// Scan for existing windows on startup.
 +    fn scan_windows(&mut self) -> Result<()> {
 +        let tree = self.conn.conn.query_tree(self.conn.root())?.reply()?;
++
 +        // Collect windows to track (avoid borrow issues)
 +        let mut to_track = Vec::new();
 +        for window in tree.children {
 +            if window == self.overlay {
 +                continue;
 +            }
++
 +            if let Ok(attrs) = self.conn.conn.get_window_attributes(window) {
 +                if let Ok(attrs) = attrs.reply() {
 +                    if attrs.map_state != x11rb::protocol::xproto::MapState::UNMAPPED {
 +                        to_track.push(window);
 +                    }
 +                }
 +            }
 +        }
++
 +        for window in to_track {
 +            self.track_window(window)?;
 +        }
++
 +        tracing::info!("Scanned {} existing windows", self.windows.len());
 +        Ok(())
 +    }
++
 +    /// Start tracking a window.
 +    fn track_window(&mut self, window: Window) -> Result<()> {
 +        if self.windows.contains_key(&window) || window == self.overlay {
 +            return Ok(());
 +        }
++
 +        // Get window geometry
 +        let geom = self.conn.conn.get_geometry(window)?.reply()?;
 +        let attrs = self.conn.conn.get_window_attributes(window)?.reply()?;
++
 +        // Get window pixmap for compositing
 +        let pixmap = self.conn.name_window_pixmap(window).ok();
++
 +        // Create damage tracking for this window
 +        let damage = self.conn.generate_id()?;
 +        self.conn
 +            .conn
 +            .damage_create(damage, window, ReportLevel::NON_EMPTY)?;
++
 +        // Subscribe to property changes on the window
 +        self.conn.conn.change_window_attributes(
 +            window,
 +            &ChangeWindowAttributesAux::new().event_mask(EventMask::PROPERTY_CHANGE),
 +        )?;
++
 +        let tracked = TrackedWindow {
 +            id: window,
 +            pixmap,
 +            damage,
 +            x: geom.x,
 +            y: geom.y,
 +            width: geom.width,
 +            height: geom.height,
 +            border_width: geom.border_width,
 +            mapped: true,
 +            override_redirect: attrs.override_redirect,
 +            window_type: WindowType::Normal,
 +            opacity: 1.0,
 +            damaged: true,
 +        };
++
 +        tracing::debug!(
 +            "Tracking window {:#x}: {}x{}+{}+{} override_redirect={}",
 +            window,
 +            geom.width,
 +            geom.height,
 +            geom.x,
 +            geom.y,
 +            attrs.override_redirect
 +        );
++
 +        self.windows.insert(window, tracked);
 +        Ok(())
 +    }
++
 +    /// Stop tracking a window.
 +    pub fn untrack_window(&mut self, window: Window) {
 +        if let Some(tracked) = self.windows.remove(&window) {
 +            // Destroy damage object
 +            let _ = self.conn.conn.damage_destroy(tracked.damage);
++
 +            // Free pixmap
 +            if let Some(pixmap) = tracked.pixmap {
 +                let _ = self.conn.conn.free_pixmap(pixmap);
 +            }
++
 +            tracing::debug!("Untracked window {:#x}", window);
 +        }
 +    }
++
 +    /// Run the compositor event loop.
 +    pub fn run(&mut self) -> Result<()> {
 +        tracing::info!("Starting compositor event loop");
++
 +        while self.running {
 +            let event = self.conn.conn.wait_for_event()?;
 +            self.handle_event(event)?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Handle a single X11 event.
 +    pub fn handle_event(&mut self, event: Event) -> Result<()> {
 +        match event {
 +            Event::CreateNotify(e) => self.handle_create(e)?,
 +            Event::DestroyNotify(e) => self.handle_destroy(e),
 +            Event::MapNotify(e) => self.handle_map(e)?,
 +            Event::UnmapNotify(e) => self.handle_unmap(e),
 +            Event::ConfigureNotify(e) => self.handle_configure(e)?,
 +            Event::PropertyNotify(e) => self.handle_property(e)?,
 +            Event::Error(e) => {
 +                tracing::warn!("X11 error: {:?}", e);
 +            }
 +            Event::Unknown(raw) => {
 +                // Check for damage events by response type (first byte)
 +                if !raw.is_empty() {
 +                    let response_type = raw[0] & 0x7f; // Mask out the "sent" flag
 +                    if response_type == self.conn.damage_event_base {
 +                        if raw.len() >= 8 {
 +                            let drawable = u32::from_ne_bytes([raw[4], raw[5], raw[6], raw[7]]);
 +                            if let Some(tracked) = self.windows.get_mut(&drawable) {
 +                                tracked.damaged = true;
 +                                let _ = self.conn.conn.damage_subtract(tracked.damage, 0u32, 0u32);
 +                            }
 +                        }
 +                    }
 +                }
 +            }
 +            _ => {}
 +        }
++
 +        Ok(())
 +    }
++
 +    fn handle_create(&mut self, event: CreateNotifyEvent) -> Result<()> {
 +        tracing::trace!("CreateNotify: window {:#x}", event.window);
 +        Ok(())
 +    }
++
 +    fn handle_destroy(&mut self, event: DestroyNotifyEvent) {
 +        tracing::trace!("DestroyNotify: window {:#x}", event.window);
 +        self.untrack_window(event.window);
 +    }
++
 +    fn handle_map(&mut self, event: MapNotifyEvent) -> Result<()> {
 +        tracing::trace!("MapNotify: window {:#x}", event.window);
++
 +        if let Some(tracked) = self.windows.get_mut(&event.window) {
 +            tracked.mapped = true;
 +            tracked.damaged = true;
++
 +            // Get fresh pixmap
 +            if let Some(old_pixmap) = tracked.pixmap.take() {
 +                let _ = self.conn.conn.free_pixmap(old_pixmap);
 +            }
 +            tracked.pixmap = self.conn.name_window_pixmap(event.window).ok();
 +        } else {
 +            self.track_window(event.window)?;
 +        }
++
 +        Ok(())
 +    }
++
 +    fn handle_unmap(&mut self, event: UnmapNotifyEvent) {
 +        tracing::trace!("UnmapNotify: window {:#x}", event.window);
++
 +        if let Some(tracked) = self.windows.get_mut(&event.window) {
 +            tracked.mapped = false;
 +        }
 +    }
++
 +    fn handle_configure(&mut self, event: ConfigureNotifyEvent) -> Result<()> {
 +        if let Some(tracked) = self.windows.get_mut(&event.window) {
 +            let size_changed =
 +                tracked.width != event.width || tracked.height != event.height;
++
 +            tracked.x = event.x;
 +            tracked.y = event.y;
 +            tracked.width = event.width;
 +            tracked.height = event.height;
 +            tracked.border_width = event.border_width;
 +            tracked.damaged = true;
++
 +            if size_changed {
 +                // Need new pixmap for resized window
 +                if let Some(old_pixmap) = tracked.pixmap.take() {
 +                    let _ = self.conn.conn.free_pixmap(old_pixmap);
 +                }
 +                if tracked.mapped {
 +                    tracked.pixmap = self.conn.name_window_pixmap(event.window).ok();
 +                }
 +            }
 +        }
++
 +        Ok(())
 +    }
++
 +    fn handle_property(&mut self, event: PropertyNotifyEvent) -> Result<()> {
 +        // Check for opacity changes
 +        if event.atom == self.conn.atoms._NET_WM_WINDOW_OPACITY {
 +            let opacity = self.get_window_opacity(event.window);
 +            if let Some(tracked) = self.windows.get_mut(&event.window) {
 +                tracked.opacity = opacity;
 +                tracked.damaged = true;
 +            }
 +        }
++
 +        Ok(())
 +    }
++
 +    fn get_window_opacity(&self, window: Window) -> f32 {
 +        let cookie = match self.conn.conn.get_property(
 +            false,
 +            window,
 +            self.conn.atoms._NET_WM_WINDOW_OPACITY,
 +            AtomEnum::CARDINAL,
 +            0,
 +            1,
 +        ) {
 +            Ok(c) => c,
 +            Err(_) => return 1.0,
 +        };
++
 +        match cookie.reply() {
 +            Ok(reply) => {
 +                if let Some(value) = reply.value32().and_then(|mut v| v.next()) {
 +                    value as f32 / u32::MAX as f32
 +                } else {
 +                    1.0
 +                }
 +            }
 +            Err(_) => 1.0,
 +        }
 +    }
++
 +    /// Shutdown the compositor cleanly.
 +    pub fn shutdown(&mut self) -> Result<()> {
 +        tracing::info!("Shutting down compositor");
++
 +        // Clean up tracked windows
 +        let windows: Vec<Window> = self.windows.keys().copied().collect();
 +        for window in windows {
 +            self.untrack_window(window);
 +        }
++
 +        // Release overlay
 +        self.conn.release_overlay_window()?;
 +        self.conn.flush()?;
++
 +        Ok(())
 +    }
 +}
++
 +impl Drop for Compositor {
 +    fn drop(&mut self) {
 +        let _ = self.shutdown();
 +    }
 +}

garchomp/src/compositor/window.rsadded

 +//! Window tracking types.
++
 +use x11rb::protocol::xproto::{Pixmap, Window};
++
 +/// Type of window for compositor effects.
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum WindowType {
 +    Normal,
 +    Desktop,
 +    Dock,
 +    Toolbar,
 +    Menu,
 +    Utility,
 +    Splash,
 +    Dialog,
 +    DropdownMenu,
 +    PopupMenu,
 +    Tooltip,
 +    Notification,
 +    Combo,
 +    Dnd,
 +}
++
 +impl Default for WindowType {
 +    fn default() -> Self {
 +        Self::Normal
 +    }
 +}
++
 +/// A window being tracked by the compositor.
 +#[derive(Debug)]
 +pub struct TrackedWindow {
 +    /// X11 window ID.
 +    pub id: Window,
 +    /// Pixmap containing window contents.
 +    pub pixmap: Option<Pixmap>,
 +    /// Damage object for tracking changes.
 +    pub damage: u32,
 +    /// X position.
 +    pub x: i16,
 +    /// Y position.
 +    pub y: i16,
 +    /// Width.
 +    pub width: u16,
 +    /// Height.
 +    pub height: u16,
 +    /// Border width.
 +    pub border_width: u16,
 +    /// Whether the window is mapped (visible).
 +    pub mapped: bool,
 +    /// Whether this is an override-redirect window (unmanaged).
 +    pub override_redirect: bool,
 +    /// Window type for effect decisions.
 +    pub window_type: WindowType,
 +    /// Window opacity (0.0 - 1.0).
 +    pub opacity: f32,
 +    /// Whether the window has been damaged since last render.
 +    pub damaged: bool,
 +}
++
 +impl TrackedWindow {
 +    /// Check if this window should have effects applied.
 +    pub fn should_have_effects(&self) -> bool {
 +        match self.window_type {
 +            WindowType::Desktop | WindowType::Dock => false,
 +            WindowType::Tooltip | WindowType::PopupMenu | WindowType::DropdownMenu => false,
 +            _ => true,
 +        }
 +    }
++
 +    /// Check if this window should have shadows.
 +    pub fn should_have_shadow(&self) -> bool {
 +        match self.window_type {
 +            WindowType::Desktop | WindowType::Dock => false,
 +            WindowType::Tooltip | WindowType::Menu => false,
 +            _ => !self.override_redirect,
 +        }
 +    }
++
 +    /// Check if this window should have blur behind.
 +    pub fn should_have_blur(&self) -> bool {
 +        self.should_have_effects() && self.opacity < 1.0
 +    }
++
 +    /// Check if this window should have rounded corners.
 +    pub fn should_have_corners(&self) -> bool {
 +        match self.window_type {
 +            WindowType::Desktop | WindowType::Dock => false,
 +            WindowType::Tooltip | WindowType::Menu => false,
 +            _ => true,
 +        }
 +    }
 +}

garchomp/src/ipc/mod.rsadded

 +//! IPC server for garchomp control.
++
 +use garchomp_ipc::{Request, Response};
 +use std::io::{BufRead, BufReader, Write};
 +use std::os::unix::net::{UnixListener, UnixStream};
 +use std::path::PathBuf;
 +use thiserror::Error;
++
 +#[derive(Error, Debug)]
 +pub enum IpcError {
 +    #[error("IO error: {0}")]
 +    Io(#[from] std::io::Error),
++
 +    #[error("JSON error: {0}")]
 +    Json(#[from] serde_json::Error),
 +}
++
 +pub type Result<T> = std::result::Result<T, IpcError>;
++
 +/// IPC server for compositor control.
 +pub struct IpcServer {
 +    listener: UnixListener,
 +    socket_path: PathBuf,
 +}
++
 +impl IpcServer {
 +    /// Create a new IPC server.
 +    pub fn new() -> Result<Self> {
 +        let socket_path = Self::socket_path();
++
 +        // Remove existing socket
 +        let _ = std::fs::remove_file(&socket_path);
++
 +        let listener = UnixListener::bind(&socket_path)?;
 +        listener.set_nonblocking(true)?;
++
 +        tracing::info!("IPC server listening at {:?}", socket_path);
++
 +        Ok(Self {
 +            listener,
 +            socket_path,
 +        })
 +    }
++
 +    /// Get the socket path.
 +    fn socket_path() -> PathBuf {
 +        let runtime_dir =
 +            std::env::var("XDG_RUNTIME_DIR").unwrap_or_else(|_| "/tmp".to_string());
 +        PathBuf::from(runtime_dir).join("garchomp.sock")
 +    }
++
 +    /// Poll for incoming connections (non-blocking).
 +    pub fn poll(&mut self) -> Option<ClientRequest> {
 +        match self.listener.accept() {
 +            Ok((stream, _)) => {
 +                if let Ok(request) = Self::read_request(&stream) {
 +                    Some(ClientRequest { stream, request })
 +                } else {
 +                    None
 +                }
 +            }
 +            Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => None,
 +            Err(e) => {
 +                tracing::warn!("IPC accept error: {}", e);
 +                None
 +            }
 +        }
 +    }
++
 +    fn read_request(stream: &UnixStream) -> Result<Request> {
 +        let mut reader = BufReader::new(stream);
 +        let mut line = String::new();
 +        reader.read_line(&mut line)?;
 +        Ok(serde_json::from_str(&line)?)
 +    }
 +}
++
 +impl Drop for IpcServer {
 +    fn drop(&mut self) {
 +        let _ = std::fs::remove_file(&self.socket_path);
 +    }
 +}
++
 +/// A client request with the stream for responding.
 +pub struct ClientRequest {
 +    stream: UnixStream,
 +    pub request: Request,
 +}
++
 +impl ClientRequest {
 +    /// Send a response to the client.
 +    pub fn respond(mut self, response: Response) -> Result<()> {
 +        let mut msg = serde_json::to_string(&response)?;
 +        msg.push('\n');
 +        self.stream.write_all(msg.as_bytes())?;
 +        Ok(())
 +    }
 +}

garchomp/src/main.rsadded

 +//! garchomp - X11 compositor for gar desktop environment.
++
 +mod compositor;
 +mod ipc;
 +mod x11;
++
 +use anyhow::{Context, Result};
 +use clap::Parser;
 +use garchomp_ipc::{Request, Response, WindowInfo};
 +use std::sync::atomic::{AtomicBool, Ordering};
 +use std::sync::Arc;
 +use tracing_subscriber::EnvFilter;
 +use x11rb::connection::Connection as _;
++
 +#[derive(Parser)]
 +#[command(name = "garchomp", about = "X11 compositor for gar desktop environment")]
 +struct Cli {
 +    /// X11 display to connect to.
 +    #[arg(short, long, env = "DISPLAY")]
 +    display: Option<String>,
++
 +    /// Path to configuration file.
 +    #[arg(short, long, default_value = "~/.config/gar/init.lua")]
 +    config: String,
++
 +    /// Increase logging verbosity.
 +    #[arg(short, long, action = clap::ArgAction::Count)]
 +    verbose: u8,
++
 +    /// Disable HDR support.
 +    #[arg(long)]
 +    no_hdr: bool,
 +}
++
 +fn main() -> Result<()> {
 +    let cli = Cli::parse();
++
 +    // Initialize logging
 +    init_logging(cli.verbose);
++
 +    tracing::info!("garchomp compositor starting");
++
 +    // Set up signal handling
 +    let running = Arc::new(AtomicBool::new(true));
 +    setup_signal_handlers(running.clone())?;
++
 +    // Create compositor
 +    let mut compositor =
 +        compositor::Compositor::new().context("Failed to initialize compositor")?;
++
 +    // Create IPC server
 +    let mut ipc_server = ipc::IpcServer::new().context("Failed to start IPC server")?;
++
 +    tracing::info!(
 +        "Compositor initialized, tracking {} windows",
 +        compositor.windows.len()
 +    );
++
 +    // Main event loop
 +    while running.load(Ordering::Relaxed) && compositor.running {
 +        // Handle IPC requests (non-blocking)
 +        while let Some(request) = ipc_server.poll() {
 +            handle_ipc_request(&mut compositor, request);
 +        }
++
 +        // Handle X11 events (non-blocking poll)
 +        if let Ok(Some(event)) = compositor.conn.conn.poll_for_event() {
 +            if let Err(e) = compositor.handle_event(event) {
 +                tracing::error!("Error handling event: {}", e);
 +            }
 +        }
++
 +        // Small sleep to prevent busy-waiting
 +        // TODO: Use proper event-driven approach with poll/select
 +        std::thread::sleep(std::time::Duration::from_millis(1));
 +    }
++
 +    tracing::info!("Shutting down");
 +    compositor.shutdown()?;
++
 +    Ok(())
 +}
++
 +fn init_logging(verbosity: u8) {
 +    let filter = match verbosity {
 +        0 => "garchomp=info",
 +        1 => "garchomp=debug",
 +        _ => "garchomp=trace",
 +    };
++
 +    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(filter));
++
 +    tracing_subscriber::fmt()
 +        .with_env_filter(filter)
 +        .with_target(false)
 +        .init();
 +}
++
 +fn setup_signal_handlers(running: Arc<AtomicBool>) -> Result<()> {
 +    ctrlc::set_handler(move || {
 +        tracing::info!("Received shutdown signal");
 +        running.store(false, Ordering::Relaxed);
 +    })
 +    .context("Failed to set signal handler")?;
++
 +    Ok(())
 +}
++
 +fn handle_ipc_request(compositor: &mut compositor::Compositor, request: ipc::ClientRequest) {
 +    let response = match &request.request {
 +        Request::Ping => Response::Pong,
 +        Request::Reload => {
 +            tracing::info!("Config reload requested");
 +            // TODO: Implement config reload
 +            Response::Ok
 +        }
 +        Request::SetEffect { effect, enabled } => {
 +            tracing::info!("Set effect {} = {}", effect, enabled);
 +            // TODO: Implement effect toggle
 +            Response::Ok
 +        }
 +        Request::SetBlurStrength { strength } => {
 +            tracing::info!("Set blur strength = {}", strength);
 +            // TODO: Implement blur strength
 +            Response::Ok
 +        }
 +        Request::GetWindowInfo { window } => {
 +            if let Some(tracked) = compositor.windows.get(&(*window as u32)) {
 +                Response::WindowInfo(WindowInfo {
 +                    id: tracked.id,
 +                    x: tracked.x,
 +                    y: tracked.y,
 +                    width: tracked.width,
 +                    height: tracked.height,
 +                    mapped: tracked.mapped,
 +                    override_redirect: tracked.override_redirect,
 +                })
 +            } else {
 +                Response::Error {
 +                    message: "Window not found".into(),
 +                }
 +            }
 +        }
 +        Request::ListWindows => {
 +            let windows: Vec<WindowInfo> = compositor
 +                .windows
 +                .values()
 +                .map(|w| WindowInfo {
 +                    id: w.id,
 +                    x: w.x,
 +                    y: w.y,
 +                    width: w.width,
 +                    height: w.height,
 +                    mapped: w.mapped,
 +                    override_redirect: w.override_redirect,
 +                })
 +                .collect();
 +            Response::WindowList { windows }
 +        }
 +    };
++
 +    if let Err(e) = request.respond(response) {
 +        tracing::warn!("Failed to send IPC response: {}", e);
 +    }
 +}

garchomp/src/x11/atoms.rsadded

 +//! X11 atom definitions for EWMH and compositor protocols.
++
 +use x11rb::atom_manager;
++
 +atom_manager! {
 +    /// Atoms used by garchomp.
 +    pub Atoms: AtomsCookie {
 +        // ICCCM
 +        WM_PROTOCOLS,
 +        WM_DELETE_WINDOW,
 +        WM_STATE,
 +        WM_TRANSIENT_FOR,
++
 +        // EWMH - Window types
 +        _NET_WM_WINDOW_TYPE,
 +        _NET_WM_WINDOW_TYPE_DESKTOP,
 +        _NET_WM_WINDOW_TYPE_DOCK,
 +        _NET_WM_WINDOW_TYPE_TOOLBAR,
 +        _NET_WM_WINDOW_TYPE_MENU,
 +        _NET_WM_WINDOW_TYPE_UTILITY,
 +        _NET_WM_WINDOW_TYPE_SPLASH,
 +        _NET_WM_WINDOW_TYPE_DIALOG,
 +        _NET_WM_WINDOW_TYPE_DROPDOWN_MENU,
 +        _NET_WM_WINDOW_TYPE_POPUP_MENU,
 +        _NET_WM_WINDOW_TYPE_TOOLTIP,
 +        _NET_WM_WINDOW_TYPE_NOTIFICATION,
 +        _NET_WM_WINDOW_TYPE_COMBO,
 +        _NET_WM_WINDOW_TYPE_DND,
 +        _NET_WM_WINDOW_TYPE_NORMAL,
++
 +        // EWMH - Window state
 +        _NET_WM_STATE,
 +        _NET_WM_STATE_MODAL,
 +        _NET_WM_STATE_STICKY,
 +        _NET_WM_STATE_MAXIMIZED_VERT,
 +        _NET_WM_STATE_MAXIMIZED_HORZ,
 +        _NET_WM_STATE_SHADED,
 +        _NET_WM_STATE_SKIP_TASKBAR,
 +        _NET_WM_STATE_SKIP_PAGER,
 +        _NET_WM_STATE_HIDDEN,
 +        _NET_WM_STATE_FULLSCREEN,
 +        _NET_WM_STATE_ABOVE,
 +        _NET_WM_STATE_BELOW,
 +        _NET_WM_STATE_DEMANDS_ATTENTION,
 +        _NET_WM_STATE_FOCUSED,
++
 +        // EWMH - Active window
 +        _NET_ACTIVE_WINDOW,
 +        _NET_CLIENT_LIST,
 +        _NET_CLIENT_LIST_STACKING,
++
 +        // Compositor bypass
 +        _NET_WM_BYPASS_COMPOSITOR,
++
 +        // Opacity
 +        _NET_WM_WINDOW_OPACITY,
++
 +        // Compositor-specific
 +        _GARCHOMP_COLORSPACE,
 +        _GARCHOMP_MAX_LUMINANCE,
 +        _GARCHOMP_MIN_LUMINANCE,
 +    }
 +}

garchomp/src/x11/composite.rsadded

 +//! X11 Composite extension operations.
++
 +use super::connection::{Connection, Result};
 +use x11rb::protocol::composite::{ConnectionExt as _, Redirect};
 +use x11rb::protocol::xfixes::ConnectionExt as XfixesConnectionExt;
 +use x11rb::protocol::xproto::{
 +    AtomEnum, ConfigureWindowAux, ConnectionExt as _, Pixmap, StackMode, Window,
 +};
++
 +/// Extension trait for Composite operations on Connection.
 +pub trait CompositeExt {
 +    /// Redirect all subwindows of root for compositing.
 +    fn redirect_subwindows(&self) -> Result<()>;
++
 +    /// Get the composite overlay window.
 +    fn get_overlay_window(&self) -> Result<Window>;
++
 +    /// Release the overlay window.
 +    fn release_overlay_window(&self) -> Result<()>;
++
 +    /// Get a pixmap for a window's contents.
 +    fn name_window_pixmap(&self, window: Window) -> Result<Pixmap>;
++
 +    /// Unredirect a window (for fullscreen bypass).
 +    fn unredirect_window(&self, window: Window) -> Result<()>;
++
 +    /// Re-redirect a window.
 +    fn redirect_window(&self, window: Window) -> Result<()>;
++
 +    /// Configure the overlay window to cover the screen.
 +    fn configure_overlay(&self, overlay: Window) -> Result<()>;
++
 +    /// Check if a window wants to bypass the compositor.
 +    fn wants_bypass(&self, window: Window) -> Result<bool>;
 +}
++
 +impl CompositeExt for Connection {
 +    fn redirect_subwindows(&self) -> Result<()> {
 +        self.conn
 +            .composite_redirect_subwindows(self.root(), Redirect::AUTOMATIC)?;
 +        tracing::debug!("Redirected subwindows for compositing");
 +        Ok(())
 +    }
++
 +    fn get_overlay_window(&self) -> Result<Window> {
 +        let reply = self.conn.composite_get_overlay_window(self.root())?.reply()?;
 +        tracing::debug!("Got overlay window: {:#x}", reply.overlay_win);
 +        Ok(reply.overlay_win)
 +    }
++
 +    fn release_overlay_window(&self) -> Result<()> {
 +        self.conn.composite_release_overlay_window(self.root())?;
 +        tracing::debug!("Released overlay window");
 +        Ok(())
 +    }
++
 +    fn name_window_pixmap(&self, window: Window) -> Result<Pixmap> {
 +        let pixmap = self.generate_id()?;
 +        self.conn.composite_name_window_pixmap(window, pixmap)?;
 +        Ok(pixmap)
 +    }
++
 +    fn unredirect_window(&self, window: Window) -> Result<()> {
 +        self.conn
 +            .composite_unredirect_window(window, Redirect::AUTOMATIC)?;
 +        tracing::debug!("Unredirected window {:#x}", window);
 +        Ok(())
 +    }
++
 +    fn redirect_window(&self, window: Window) -> Result<()> {
 +        self.conn
 +            .composite_redirect_window(window, Redirect::AUTOMATIC)?;
 +        tracing::debug!("Redirected window {:#x}", window);
 +        Ok(())
 +    }
++
 +    fn configure_overlay(&self, overlay: Window) -> Result<()> {
 +        let screen = self.screen();
++
 +        // Make overlay cover the entire screen
 +        let aux = ConfigureWindowAux::new()
 +            .x(0)
 +            .y(0)
 +            .width(screen.width_in_pixels as u32)
 +            .height(screen.height_in_pixels as u32)
 +            .stack_mode(StackMode::ABOVE);
++
 +        self.conn.configure_window(overlay, &aux)?;
++
 +        // Allow input to pass through to windows below
 +        let region = self.generate_id()?;
 +        self.conn.xfixes_create_region(region, &[])?;
 +        self.conn.xfixes_set_window_shape_region(overlay, x11rb::protocol::shape::SK::INPUT, 0, 0, region)?;
 +        self.conn.xfixes_destroy_region(region)?;
++
 +        tracing::debug!(
 +            "Configured overlay: {}x{}",
 +            screen.width_in_pixels,
 +            screen.height_in_pixels
 +        );
 +        Ok(())
 +    }
++
 +    fn wants_bypass(&self, window: Window) -> Result<bool> {
 +        let reply = self.conn.get_property(
 +            false,
 +            window,
 +            self.atoms._NET_WM_BYPASS_COMPOSITOR,
 +            AtomEnum::CARDINAL,
 +            0,
 +            1,
 +        )?.reply()?;
++
 +        if let Some(value) = reply.value32().and_then(|mut v| v.next()) {
 +            // 1 = bypass requested, 2 = bypass when fullscreen
 +            Ok(value >= 1)
 +        } else {
 +            Ok(false)
 +        }
 +    }
 +}

garchomp/src/x11/connection.rsadded

 +//! X11 connection wrapper with extension support.
++
 +use super::Atoms;
 +use thiserror::Error;
 +use x11rb::connection::{Connection as X11Connection, RequestConnection};
 +use x11rb::protocol::composite::ConnectionExt as CompositeConnectionExt;
 +use x11rb::protocol::damage::ConnectionExt as DamageConnectionExt;
 +use x11rb::protocol::xfixes::ConnectionExt as XfixesConnectionExt;
 +use x11rb::protocol::xproto::{Screen, Window};
 +use x11rb::rust_connection::RustConnection;
++
 +#[derive(Error, Debug)]
 +pub enum ConnectionError {
 +    #[error("failed to connect to X11 display")]
 +    Connect(#[from] x11rb::errors::ConnectError),
++
 +    #[error("X11 connection error: {0}")]
 +    Connection(#[from] x11rb::errors::ConnectionError),
++
 +    #[error("X11 reply error: {0}")]
 +    Reply(#[from] x11rb::errors::ReplyError),
++
 +    #[error("extension '{name}' not available (required version: {required})")]
 +    ExtensionMissing { name: &'static str, required: &'static str },
++
 +    #[error("failed to intern atoms")]
 +    Atoms(#[from] x11rb::errors::ReplyOrIdError),
 +}
++
 +pub type Result<T> = std::result::Result<T, ConnectionError>;
++
 +/// X11 connection with compositor extensions.
 +pub struct Connection {
 +    pub conn: RustConnection,
 +    pub screen_num: usize,
 +    pub atoms: Atoms,
 +    pub composite_opcode: u8,
 +    pub damage_opcode: u8,
 +    pub damage_event_base: u8,
 +}
++
 +impl Connection {
 +    /// Connect to the X11 display and initialize extensions.
 +    pub fn new() -> Result<Self> {
 +        let (conn, screen_num) = x11rb::connect(None)?;
++
 +        // Query Composite extension
 +        let composite = conn
 +            .composite_query_version(0, 4)?
 +            .reply()?;
 +        tracing::info!(
 +            "Composite extension: {}.{}",
 +            composite.major_version,
 +            composite.minor_version
 +        );
 +        if composite.major_version == 0 && composite.minor_version < 4 {
 +            return Err(ConnectionError::ExtensionMissing {
 +                name: "Composite",
 +                required: "0.4",
 +            });
 +        }
++
 +        // Query Damage extension
 +        let damage = conn
 +            .damage_query_version(1, 1)?
 +            .reply()?;
 +        tracing::info!(
 +            "Damage extension: {}.{}",
 +            damage.major_version,
 +            damage.minor_version
 +        );
++
 +        // Query XFixes extension
 +        let xfixes = conn
 +            .xfixes_query_version(5, 0)?
 +            .reply()?;
 +        tracing::info!(
 +            "XFixes extension: {}.{}",
 +            xfixes.major_version,
 +            xfixes.minor_version
 +        );
++
 +        // Get extension opcodes for event handling
 +        let composite_ext = conn
 +            .extension_information(x11rb::protocol::composite::X11_EXTENSION_NAME)?
 +            .ok_or(ConnectionError::ExtensionMissing {
 +                name: "Composite",
 +                required: "0.4",
 +            })?;
++
 +        let damage_ext = conn
 +            .extension_information(x11rb::protocol::damage::X11_EXTENSION_NAME)?
 +            .ok_or(ConnectionError::ExtensionMissing {
 +                name: "Damage",
 +                required: "1.1",
 +            })?;
++
 +        // Intern atoms
 +        let atoms = Atoms::new(&conn)?.reply()?;
++
 +        Ok(Self {
 +            conn,
 +            screen_num,
 +            atoms,
 +            composite_opcode: composite_ext.major_opcode,
 +            damage_opcode: damage_ext.major_opcode,
 +            damage_event_base: damage_ext.first_event,
 +        })
 +    }
++
 +    /// Get the default screen.
 +    pub fn screen(&self) -> &Screen {
 +        &self.conn.setup().roots[self.screen_num]
 +    }
++
 +    /// Get the root window.
 +    pub fn root(&self) -> Window {
 +        self.screen().root
 +    }
++
 +    /// Flush pending requests to the server.
 +    pub fn flush(&self) -> Result<()> {
 +        self.conn.flush()?;
 +        Ok(())
 +    }
++
 +    /// Generate a new X11 ID.
 +    pub fn generate_id(&self) -> Result<u32> {
 +        Ok(self.conn.generate_id()?)
 +    }
 +}

garchomp/src/x11/mod.rsadded

 +//! X11 protocol layer for garchomp compositor.
++
 +mod atoms;
 +mod composite;
 +mod connection;
++
 +pub use atoms::Atoms;
 +pub use composite::CompositeExt;
 +pub use connection::{Connection, ConnectionError};

garchompctl/Cargo.tomladded

 +[package]
 +name = "garchompctl"
 +description = "Control utility for garchomp compositor"
 +version.workspace = true
 +edition.workspace = true
 +license.workspace = true
++
 +[dependencies]
 +garchomp-ipc = { workspace = true }
 +clap = { workspace = true }
 +serde_json = { workspace = true }
 +anyhow = { workspace = true }

garchompctl/src/main.rsadded

 +//! garchompctl - Control utility for garchomp compositor.
++
 +use anyhow::{Context, Result};
 +use clap::{Parser, Subcommand};
 +use garchomp_ipc::{Request, Response};
 +use std::io::{BufRead, BufReader, Write};
 +use std::os::unix::net::UnixStream;
++
 +#[derive(Parser)]
 +#[command(name = "garchompctl", about = "Control garchomp compositor")]
 +struct Cli {
 +    #[command(subcommand)]
 +    command: Commands,
 +}
++
 +#[derive(Subcommand)]
 +enum Commands {
 +    /// Reload configuration.
 +    Reload,
 +    /// Enable an effect.
 +    Enable { effect: String },
 +    /// Disable an effect.
 +    Disable { effect: String },
 +    /// Set blur strength (0-20).
 +    Blur { strength: u32 },
 +    /// List managed windows.
 +    Windows,
 +    /// Ping the compositor.
 +    Ping,
 +}
++
 +fn main() -> Result<()> {
 +    let cli = Cli::parse();
++
 +    let request = match cli.command {
 +        Commands::Reload => Request::Reload,
 +        Commands::Enable { effect } => Request::SetEffect {
 +            effect,
 +            enabled: true,
 +        },
 +        Commands::Disable { effect } => Request::SetEffect {
 +            effect,
 +            enabled: false,
 +        },
 +        Commands::Blur { strength } => Request::SetBlurStrength { strength },
 +        Commands::Windows => Request::ListWindows,
 +        Commands::Ping => Request::Ping,
 +    };
++
 +    let response = send_request(&request)?;
++
 +    match response {
 +        Response::Ok => println!("OK"),
 +        Response::Pong => println!("pong"),
 +        Response::Error { message } => {
 +            eprintln!("Error: {}", message);
 +            std::process::exit(1);
 +        }
 +        Response::WindowInfo(info) => {
 +            println!("{}", serde_json::to_string_pretty(&info)?);
 +        }
 +        Response::WindowList { windows } => {
 +            for win in windows {
 +                println!(
 +                    "{:#010x}  {}x{}+{}+{}  {}",
 +                    win.id,
 +                    win.width,
 +                    win.height,
 +                    win.x,
 +                    win.y,
 +                    if win.mapped { "mapped" } else { "unmapped" }
 +                );
 +            }
 +        }
 +    }
++
 +    Ok(())
 +}
++
 +fn send_request(request: &Request) -> Result<Response> {
 +    let socket_path = format!(
 +        "{}/garchomp.sock",
 +        std::env::var("XDG_RUNTIME_DIR").unwrap_or_else(|_| "/tmp".into())
 +    );
++
 +    let mut stream =
 +        UnixStream::connect(&socket_path).context("Failed to connect to garchomp socket")?;
++
 +    let mut msg = serde_json::to_string(request)?;
 +    msg.push('\n');
 +    stream.write_all(msg.as_bytes())?;
++
 +    let mut reader = BufReader::new(stream);
 +    let mut line = String::new();
 +    reader.read_line(&mut line)?;
++
 +    serde_json::from_str(&line).context("Failed to parse response")
 +}