Initial Commit

13 files changed, 3833 insertions, 0 deletions

diff --git a/src/platform/linux_platform.h b/src/platform/linux_platform.h
new file mode 100644
index 0000000..1237c85
--- /dev/null
+++ b/src/platform/linux_platform.h
@@ -0,0 +1,105 @@
+#ifndef SRDWM_LINUX_PLATFORM_H
+#define SRDWM_LINUX_PLATFORM_H
+
+#include "platform.h"
+#include <memory>
+#include <string>
+
+// Forward declarations for X11
+#ifdef __linux__
+struct _XDisplay;
+typedef struct _XDisplay Display;
+typedef unsigned long SRDWindow;
+typedef unsigned long Atom;
+
+// Forward declarations for Wayland
+struct wl_display;
+struct wl_registry;
+struct wl_compositor;
+struct wl_shell;
+struct wl_seat;
+struct wl_keyboard;
+struct wl_pointer;
+#endif
+
+class LinuxPlatform : public Platform {
+public:
+    enum class Backend {
+        Auto,
+        X11,
+        Wayland
+    };
+
+    explicit LinuxPlatform(Backend backend = Backend::Auto);
+    ~LinuxPlatform() override;
+
+    // Platform interface implementation
+    bool initialize() override;
+    void shutdown() override;
+    
+    bool poll_events(std::vector<Event>& events) override;
+    void process_event(const Event& event) override;
+    
+    std::unique_ptr<SRDWindow> create_window(const std::string& title, int x, int y, int width, int height) override;
+    void destroy_window(SRDWindow* window) override;
+    void set_window_position(SRDWindow* window, int x, int y) override;
+    void set_window_size(SRDWindow* window, int width, int height) override;
+    void set_window_title(SRDWindow* window, const std::string& title) override;
+    void focus_window(SRDWindow* window) override;
+    void minimize_window(SRDWindow* window) override;
+    void maximize_window(SRDWindow* window) override;
+    void close_window(SRDWindow* window) override;
+    
+    std::vector<Monitor> get_monitors() override;
+    Monitor get_primary_monitor() override;
+    
+    void grab_keyboard() override;
+    void ungrab_keyboard() override;
+    void grab_pointer() override;
+    void ungrab_pointer() override;
+    
+    std::string get_platform_name() const override;
+    bool is_wayland() const override;
+    bool is_x11() const override;
+    bool is_windows() const override;
+    bool is_macos() const override;
+
+private:
+    Backend backend_;
+    bool initialized_;
+    
+    // X11 specific members
+    Display* x11_display_;
+    SRDWindow x11_root_;
+    Atom x11_wm_delete_window_;
+    Atom x11_wm_protocols_;
+    
+    // Wayland specific members
+    wl_display* wayland_display_;
+    wl_registry* wayland_registry_;
+    wl_compositor* wayland_compositor_;
+    wl_shell* wayland_shell_;
+    wl_seat* wayland_seat_;
+    wl_keyboard* wayland_keyboard_;
+    wl_pointer* wayland_pointer_;
+    
+    // Common members
+    std::vector<Monitor> monitors_;
+    
+    // Private methods
+    bool initialize_x11();
+    bool initialize_wayland();
+    void shutdown_x11();
+    void shutdown_wayland();
+    
+    bool detect_backend();
+    void setup_x11_atoms();
+    void setup_wayland_registry();
+    
+    // Event processing
+    void process_x11_event(XEvent& event, std::vector<Event>& events);
+    void process_wayland_event(wl_display* display, std::vector<Event>& events);
+};
+
+#endif // SRDWM_LINUX_PLATFORM_H
+
diff --git a/src/platform/macos_platform.cc b/src/platform/macos_platform.cc
new file mode 100644
index 0000000..d489cb7
--- /dev/null
+++ b/src/platform/macos_platform.cc
@@ -0,0 +1,480 @@
+#include "macos_platform.h"
+#include <iostream>
+#include <CoreGraphics/CoreGraphics.h>
+#include <ApplicationServices/ApplicationServices.h>
+#include <Carbon/Carbon.h>
+
+// Static member initialization
+MacOSPlatform* MacOSPlatform::instance_ = nullptr;
+
+MacOSPlatform::MacOSPlatform()
+    : event_tap_(nullptr) {
+    
+    instance_ = this;
+}
+
+MacOSPlatform::~MacOSPlatform() {
+    shutdown();
+    if (instance_ == this) {
+        instance_ = nullptr;
+    }
+}
+
+bool MacOSPlatform::initialize() {
+    std::cout << "Initializing macOS platform..." << std::endl;
+    
+    // Request accessibility permissions
+    if (!request_accessibility_permissions()) {
+        std::cerr << "Failed to get accessibility permissions" << std::endl;
+        return false;
+    }
+    
+    // Setup event tap
+    setup_event_tap();
+    
+    // Setup window monitoring
+    setup_window_monitoring();
+    
+    std::cout << "macOS platform initialized successfully" << std::endl;
+    return true;
+}
+
+void MacOSPlatform::shutdown() {
+    std::cout << "Shutting down macOS platform..." << std::endl;
+    
+    // Clean up event tap
+    if (event_tap_) {
+        CGEventTapEnable(event_tap_, false);
+        CFRelease(event_tap_);
+        event_tap_ = nullptr;
+    }
+    
+    // Clean up windows
+    for (auto& pair : window_map_) {
+        if (pair.second) {
+            delete pair.second;
+        }
+    }
+    window_map_.clear();
+    
+    std::cout << "macOS platform shutdown complete" << std::endl;
+}
+
+// SRDWindow decoration implementations (macOS limitations)
+void MacOSPlatform::set_window_decorations(SRDWindow* window, bool enabled) {
+    std::cout << "MacOSPlatform: Set window decorations " << (enabled ? "enabled" : "disabled") << std::endl;
+    
+    if (!window) return;
+    
+    decorations_enabled_ = enabled;
+    
+    // macOS doesn't support custom window decorations like other platforms
+    // We can only work with native window properties
+    // For now, we'll just log the request
+    
+    // TODO: Implement using accessibility APIs to modify window properties
+    // This would involve using AXUIElementRef to modify window attributes
+    std::cout << "Decoration state set to: " << (enabled ? "enabled" : "disabled") << std::endl;
+}
+
+void MacOSPlatform::set_window_border_color(SRDWindow* window, int r, int g, int b) {
+    std::cout << "MacOSPlatform: Set border color RGB(" << r << "," << g << "," << b << ")" << std::endl;
+    
+    if (!window) return;
+    
+    // macOS doesn't support custom border colors through public APIs
+    // This would require private APIs or overlay windows
+    // For now, we'll just log the request
+    
+    // TODO: Implement using private APIs or overlay windows
+    // This could involve:
+    // 1. Creating transparent overlay windows around the target window
+    // 2. Using private Core Graphics APIs (not recommended for production)
+    // 3. Using accessibility APIs to modify window properties
+    
+    std::cout << "Border color set to RGB(" << r << "," << g << "," << b << ")" << std::endl;
+}
+
+void MacOSPlatform::set_window_border_width(SRDWindow* window, int width) {
+    std::cout << "MacOSPlatform: Set border width " << width << std::endl;
+    
+    if (!window) return;
+    
+    // macOS doesn't support custom border widths through public APIs
+    // This would require private APIs or overlay windows
+    // For now, we'll just log the request
+    
+    // TODO: Implement using private APIs or overlay windows
+    // This could involve:
+    // 1. Creating transparent overlay windows around the target window
+    // 2. Using private Core Graphics APIs (not recommended for production)
+    // 3. Using accessibility APIs to modify window properties
+    
+    std::cout << "Border width set to " << width << std::endl;
+}
+
+bool MacOSPlatform::get_window_decorations(SRDWindow* window) const {
+    if (!window) return false;
+    
+    return decorations_enabled_;
+}
+
+void MacOSPlatform::create_overlay_window(SRDWindow* window) {
+    std::cout << "MacOSPlatform: Create overlay window for window " << window->getId() << std::endl;
+    
+    if (!window) return;
+    
+    // TODO: Implement overlay window creation for custom decorations
+    // This would involve:
+    // 1. Creating a transparent window using Core Graphics
+    // 2. Positioning it over the target window
+    // 3. Drawing custom borders/titlebar on it
+    // 4. Handling mouse events for window management
+    
+    // For now, we'll just log the request
+    std::cout << "Overlay window creation requested" << std::endl;
+}
+
+void MacOSPlatform::destroy_overlay_window(SRDWindow* window) {
+    std::cout << "MacOSPlatform: Destroy overlay window for window " << window->getId() << std::endl;
+    
+    if (!window) return;
+    
+    // TODO: Implement overlay window destruction
+    // This would involve:
+    // 1. Finding the overlay window for this window
+    // 2. Destroying the overlay window
+    // 3. Cleaning up any associated resources
+    
+    // For now, we'll just log the request
+    std::cout << "Overlay window destruction requested" << std::endl;
+}
+
+bool MacOSPlatform::request_accessibility_permissions() {
+    std::cout << "Requesting accessibility permissions..." << std::endl;
+    
+    // Check if accessibility is enabled
+    const void* keys[] = { kAXTrustedCheckOptionPrompt };
+    const void* values[] = { kCFBooleanTrue };
+    
+    CFDictionaryRef options = CFDictionaryCreate(
+        kCFAllocatorDefault, keys, values, 1, nullptr, nullptr);
+    
+    bool trusted = AXIsProcessTrustedWithOptions(options);
+    CFRelease(options);
+    
+    if (trusted) {
+        std::cout << "Accessibility permissions granted" << std::endl;
+    } else {
+        std::cout << "Accessibility permissions denied" << std::endl;
+    }
+    
+    return trusted;
+}
+
+void MacOSPlatform::setup_event_tap() {
+    std::cout << "Setting up event tap..." << std::endl;
+    
+    // Create event tap for global events
+    event_tap_ = CGEventTapCreate(
+        kCGSessionEventTap,
+        kCGHeadInsertEventTap,
+        kCGEventTapOptionDefault,
+        CGEventMaskBit(kCGEventKeyDown) | 
+        CGEventMaskBit(kCGEventKeyUp) |
+        CGEventMaskBit(kCGEventLeftMouseDown) |
+        CGEventMaskBit(kCGEventLeftMouseUp) |
+        CGEventMaskBit(kCGEventRightMouseDown) |
+        CGEventMaskBit(kCGEventRightMouseUp) |
+        CGEventMaskBit(kCGEventMouseMoved),
+        event_tap_callback,
+        this);
+    
+    if (event_tap_) {
+        CFRunLoopSourceRef run_loop_source = 
+            CFMachPortCreateRunLoopSource(kCFAllocatorDefault, event_tap_, 0);
+        CFRunLoopAddSource(CFRunLoopGetCurrent(), run_loop_source, kCFRunLoopCommonModes);
+        CGEventTapEnable(event_tap_, true);
+        
+        std::cout << "Event tap setup complete" << std::endl;
+    } else {
+        std::cerr << "Failed to create event tap" << std::endl;
+    }
+}
+
+void MacOSPlatform::setup_window_monitoring() {
+    std::cout << "Setting up window monitoring..." << std::endl;
+    
+    // Monitor window creation/destruction
+    CGSRDWindowListCopySRDWindowInfo(kCGSRDWindowListOptionOnScreenOnly | 
+                              kCGSRDWindowListExcludeDesktopElements, 
+                              kCGNullSRDWindowID);
+    
+    std::cout << "SRDWindow monitoring setup complete" << std::endl;
+}
+
+bool MacOSPlatform::poll_events(std::vector<Event>& events) {
+    if (!initialized_ || !event_tap_) return false;
+    
+    events.clear();
+    
+    // macOS events are handled through the event tap callback
+    // The event tap callback handles event conversion
+    // For now, we'll just return any pending events
+    
+    // TODO: Implement proper event queue processing
+    // This would involve processing events from the event tap callback
+    
+    return false;
+}
+
+void MacOSPlatform::process_event(const Event& event) {
+    // TODO: Implement event processing
+}
+
+std::unique_ptr<SRDWindow> MacOSPlatform::create_window(const std::string& title, int x, int y, int width, int height) {
+    std::cout << "Creating macOS window: " << title << std::endl;
+    
+    // TODO: Implement actual window creation using Core Graphics/AppKit
+    // For now, create a placeholder window object
+    
+    auto window = std::make_unique<SRDWindow>();
+    // TODO: Set window properties
+    
+    std::cout << "macOS window creation requested" << std::endl;
+    return window;
+}
+
+void MacOSPlatform::destroy_window(SRDWindow* window) {
+    std::cout << "Destroying macOS window" << std::endl;
+    
+    // TODO: Implement window destruction
+}
+
+void MacOSPlatform::set_window_position(SRDWindow* window, int x, int y) {
+    // TODO: Implement window positioning using accessibility APIs
+}
+
+void MacOSPlatform::set_window_size(SRDWindow* window, int width, int height) {
+    // TODO: Implement window resizing using accessibility APIs
+}
+
+void MacOSPlatform::set_window_title(SRDWindow* window, const std::string& title) {
+    // TODO: Implement title setting
+}
+
+void MacOSPlatform::focus_window(SRDWindow* window) {
+    // TODO: Implement window focusing
+}
+
+void MacOSPlatform::minimize_window(SRDWindow* window) {
+    // TODO: Implement window minimization
+}
+
+void MacOSPlatform::maximize_window(SRDWindow* window) {
+    // TODO: Implement window maximization
+}
+
+void MacOSPlatform::close_window(SRDWindow* window) {
+    // TODO: Implement window closing
+}
+
+std::vector<Monitor> MacOSPlatform::get_monitors() {
+    std::vector<Monitor> monitors;
+    
+    // Get display information using Core Graphics
+    uint32_t display_count = 0;
+    CGGetActiveDisplayList(0, nullptr, &display_count);
+    
+    if (display_count > 0) {
+        std::vector<CGDirectDisplayID> display_ids(display_count);
+        CGGetActiveDisplayList(display_count, display_ids.data(), &display_count);
+        
+        for (uint32_t i = 0; i < display_count; ++i) {
+            CGDirectDisplayID display_id = display_ids[i];
+            
+            Monitor monitor;
+            monitor.id = static_cast<int>(display_id);
+            monitor.name = "Display " + std::to_string(i + 1);
+            
+            // Get display bounds
+            CGRect bounds = CGDisplayBounds(display_id);
+            monitor.x = static_cast<int>(bounds.origin.x);
+            monitor.y = static_cast<int>(bounds.origin.y);
+            monitor.width = static_cast<int>(bounds.size.width);
+            monitor.height = static_cast<int>(bounds.size.height);
+            
+            // Get refresh rate
+            CGDisplayModeRef mode = CGDisplayCopyDisplayMode(display_id);
+            if (mode) {
+                monitor.refresh_rate = static_cast<int>(CGDisplayModeGetRefreshRate(mode));
+                CGDisplayModeRelease(mode);
+            } else {
+                monitor.refresh_rate = 60; // Default
+            }
+            
+            monitors.push_back(monitor);
+            
+            std::cout << "Monitor " << i << ": " << monitor.width << "x" << monitor.height 
+                      << " @ " << monitor.refresh_rate << "Hz" << std::endl;
+        }
+    }
+    
+    return monitors;
+}
+
+Monitor MacOSPlatform::get_primary_monitor() {
+    auto monitors = get_monitors();
+    if (!monitors.empty()) {
+        return monitors[0];
+    }
+    
+    // Fallback to main display
+    CGDirectDisplayID main_display = CGMainDisplayID();
+    CGRect bounds = CGDisplayBounds(main_display);
+    
+    Monitor monitor;
+    monitor.id = static_cast<int>(main_display);
+    monitor.name = "Main Display";
+    monitor.x = static_cast<int>(bounds.origin.x);
+    monitor.y = static_cast<int>(bounds.origin.y);
+    monitor.width = static_cast<int>(bounds.size.width);
+    monitor.height = static_cast<int>(bounds.size.height);
+    monitor.refresh_rate = 60; // Default
+    
+    return monitor;
+}
+
+void MacOSPlatform::grab_keyboard() {
+    // TODO: Implement keyboard grabbing
+    std::cout << "Keyboard grabbing setup" << std::endl;
+}
+
+void MacOSPlatform::ungrab_keyboard() {
+    // TODO: Implement keyboard ungrab
+    std::cout << "Keyboard ungrab" << std::endl;
+}
+
+void MacOSPlatform::grab_pointer() {
+    // TODO: Implement pointer grabbing
+    std::cout << "Pointer grabbing setup" << std::endl;
+}
+
+void MacOSPlatform::ungrab_pointer() {
+    // TODO: Implement pointer ungrab
+    std::cout << "Pointer ungrab" << std::endl;
+}
+
+// Static callback functions
+CGEventRef MacOSPlatform::event_tap_callback(CGEventTapProxy proxy, CGEventType type, 
+                                            CGEventRef event, void* user_info) {
+    MacOSPlatform* platform = static_cast<MacOSPlatform*>(user_info);
+    return platform->handle_event_tap(proxy, type, event);
+}
+
+CGEventRef MacOSPlatform::handle_event_tap(CGEventTapProxy proxy, CGEventType type, CGEventRef event) {
+    switch (type) {
+        case kCGEventKeyDown:
+            handle_key_event(event, true);
+            break;
+            
+        case kCGEventKeyUp:
+            handle_key_event(event, false);
+            break;
+            
+        case kCGEventLeftMouseDown:
+            handle_mouse_event(event, true, 1);
+            break;
+            
+        case kCGEventLeftMouseUp:
+            handle_mouse_event(event, false, 1);
+            break;
+            
+        case kCGEventRightMouseDown:
+            handle_mouse_event(event, true, 2);
+            break;
+            
+        case kCGEventRightMouseUp:
+            handle_mouse_event(event, false, 2);
+            break;
+            
+        case kCGEventMouseMoved:
+            handle_mouse_motion(event);
+            break;
+    }
+    
+    return event;
+}
+
+void MacOSPlatform::handle_key_event(CGEventRef event, bool pressed) {
+    // Get key code
+    CGKeyCode key_code = static_cast<CGKeyCode>(CGEventGetIntegerValueField(event, kCGKeyboardEventKeycode));
+    
+    std::cout << "Key " << (pressed ? "press" : "release") << ": " << key_code << std::endl;
+    
+    // TODO: Convert to SRDWM key event
+}
+
+void MacOSPlatform::handle_mouse_event(CGEventRef event, bool pressed, int button) {
+    // Get mouse position
+    CGPoint location = CGEventGetLocation(event);
+    
+    std::cout << "Mouse button " << button << " " << (pressed ? "down" : "up") 
+              << " at (" << location.x << ", " << location.y << ")" << std::endl;
+    
+    // TODO: Convert to SRDWM button event
+}
+
+void MacOSPlatform::handle_mouse_motion(CGEventRef event) {
+    // Get mouse position
+    CGPoint location = CGEventGetLocation(event);
+    
+    // TODO: Convert to SRDWM motion event
+}
+
+// Utility methods
+CGSRDWindowID MacOSPlatform::get_macos_window_id(SRDWindow* window) {
+    // TODO: Implement window ID retrieval
+    return 0;
+}
+
+pid_t MacOSPlatform::get_macos_pid(SRDWindow* window) {
+    // TODO: Implement PID retrieval
+    return 0;
+}
+
+void MacOSPlatform::update_window_monitoring() {
+    // TODO: Implement window monitoring update
+}
+
+void MacOSPlatform::handle_window_created(CGSRDWindowID window_id) {
+    std::cout << "SRDWindow created: " << window_id << std::endl;
+    
+    // TODO: Create SRDWM window object and manage it
+}
+
+void MacOSPlatform::handle_window_destroyed(CGSRDWindowID window_id) {
+    std::cout << "SRDWindow destroyed: " << window_id << std::endl;
+    
+    // TODO: Clean up SRDWM window object
+}
+
+void MacOSPlatform::handle_window_focused(CGSRDWindowID window_id) {
+    std::cout << "SRDWindow focused: " << window_id << std::endl;
+    
+    // TODO: Handle window focus
+}
+
+void MacOSPlatform::handle_window_moved(CGSRDWindowID window_id, int x, int y) {
+    std::cout << "SRDWindow " << window_id << " moved to (" << x << ", " << y << ")" << std::endl;
+    
+    // TODO: Handle window movement
+}
+
+void MacOSPlatform::handle_window_resized(CGSRDWindowID window_id, int width, int height) {
+    std::cout << "SRDWindow " << window_id << " resized to " << width << "x" << height << std::endl;
+    
+    // TODO: Handle window resizing
+}
+
+
diff --git a/src/platform/macos_platform.h b/src/platform/macos_platform.h
new file mode 100644
index 0000000..39dc3db
--- /dev/null
+++ b/src/platform/macos_platform.h
@@ -0,0 +1,118 @@
+#ifndef SRDWM_MACOS_PLATFORM_H
+#define SRDWM_MACOS_PLATFORM_H
+
+#include "platform.h"
+#include <memory>
+#include <string>
+#include <map>
+
+// Forward declarations for macOS
+#ifdef __APPLE__
+typedef struct CGSRDWindow* CGSRDWindowRef;
+typedef struct CGEvent* CGEventRef;
+typedef struct CGDisplay* CGDirectDisplayID;
+typedef struct CGMenu* CGMenuRef;
+typedef struct CGMenuBar* CGMenuBarRef;
+#endif
+
+class MacOSPlatform : public Platform {
+public:
+    MacOSPlatform();
+    ~MacOSPlatform() override;
+
+    // Platform interface implementation
+    bool initialize() override;
+    void shutdown() override;
+    
+    bool poll_events(std::vector<Event>& events) override;
+    void process_event(const Event& event) override;
+    
+    std::unique_ptr<SRDWindow> create_window(const std::string& title, int x, int y, int width, int height) override;
+    void destroy_window(SRDWindow* window) override;
+    void set_window_position(SRDWindow* window, int x, int y) override;
+    void set_window_size(SRDWindow* window, int width, int height) override;
+    void set_window_title(SRDWindow* window, const std::string& title) override;
+    void focus_window(SRDWindow* window) override;
+    void minimize_window(SRDWindow* window) override;
+    void maximize_window(SRDWindow* window) override;
+    void close_window(SRDWindow* window) override;
+    
+    std::vector<Monitor> get_monitors() override;
+    Monitor get_primary_monitor() override;
+    
+    void grab_keyboard() override;
+    void ungrab_keyboard() override;
+    void grab_pointer() override;
+    void ungrab_pointer() override;
+    
+    // SRDWindow decorations (macOS implementation)
+    void set_window_decorations(SRDWindow* window, bool enabled) override;
+    void set_window_border_color(SRDWindow* window, int r, int g, int b) override;
+    void set_window_border_width(SRDWindow* window, int width) override;
+    bool get_window_decorations(SRDWindow* window) const override;
+
+    // macOS-specific features
+    void setup_global_menu();
+    void update_global_menu(const std::string& app_name);
+    void set_menu_bar_visible(bool visible);
+    void set_dock_visible(bool visible);
+    void set_spaces_enabled(bool enabled);
+    void switch_to_space(int space_id);
+    int get_current_space() const;
+    std::vector<int> get_available_spaces() const;
+    
+    // Mission Control and Spaces
+    void show_mission_control();
+    void show_app_expose();
+    void show_desktop();
+    
+    // Window management enhancements
+    void set_window_level(SRDWindow* window, int level);
+    void set_window_shadow(SRDWindow* window, bool enabled);
+    void set_window_blur(SRDWindow* window, bool enabled);
+    void set_window_alpha(SRDWindow* window, float alpha);
+
+    std::string get_platform_name() const override;
+    bool is_wayland() const override;
+    bool is_x11() const override;
+    bool is_windows() const override;
+    bool is_macos() const override;
+
+private:
+    bool initialized_;
+    std::map<CGSRDWindowRef, SRDWindow*> window_map_;
+    std::vector<Monitor> monitors_;
+    
+    // Decoration state (macOS limitations)
+    bool decorations_enabled_;
+    std::map<CGSRDWindowRef, CGSRDWindowRef> overlay_window_map_; // window -> overlay
+    
+    // macOS-specific state
+    bool global_menu_enabled_;
+    bool dock_visible_;
+    bool spaces_enabled_;
+    CGMenuBarRef menu_bar_;
+    std::map<std::string, CGMenuRef> app_menus_;
+    
+    // Event handling
+    void setup_event_tap();
+    void remove_event_tap();
+    
+    // Monitor management
+    void update_monitors();
+    
+    // Utility methods
+    SRDWindow* find_window_by_cgwindow(CGSRDWindowRef cgwindow);
+    
+    // Decoration methods (macOS limitations)
+    void create_overlay_window(SRDWindow* window);
+    void destroy_overlay_window(SRDWindow* window);
+    
+    // Global menu methods
+    void create_app_menu(const std::string& app_name);
+    void update_menu_bar();
+    void handle_menu_event(CGEventRef event);
+};
+
+#endif // SRDWM_MACOS_PLATFORM_H
+
diff --git a/src/platform/platform.h b/src/platform/platform.h
new file mode 100644
index 0000000..41cc6bf
--- /dev/null
+++ b/src/platform/platform.h
@@ -0,0 +1,91 @@
+#ifndef SRDWM_PLATFORM_H
+#define SRDWM_PLATFORM_H
+
+#include <memory>
+#include <vector>
+#include <string>
+#include <functional>
+
+// Forward declarations
+class SRDWindow;
+
+// Include Monitor struct definition from layouts
+#include "../layouts/layout.h"
+
+// Platform-independent event types
+enum class EventType {
+    WindowCreated,
+    WindowDestroyed,
+    WindowMoved,
+    WindowResized,
+    WindowFocused,
+    WindowUnfocused,
+    KeyPress,
+    KeyRelease,
+    MouseButtonPress,
+    MouseButtonRelease,
+    MouseMotion,
+    MonitorAdded,
+    MonitorRemoved
+};
+
+// Event structure
+struct Event {
+    EventType type;
+    void* data;
+    size_t data_size;
+};
+
+// Platform abstraction interface
+class Platform {
+public:
+    virtual ~Platform() = default;
+    
+    // Initialization and cleanup
+    virtual bool initialize() = 0;
+    virtual void shutdown() = 0;
+    
+    // Event handling
+    virtual bool poll_events(std::vector<Event>& events) = 0;
+    virtual void process_event(const Event& event) = 0;
+    
+    // Window management
+    virtual std::unique_ptr<SRDWindow> create_window(const std::string& title, int x, int y, int width, int height) = 0;
+    virtual void destroy_window(SRDWindow* window) = 0;
+    virtual void set_window_position(SRDWindow* window, int x, int y) = 0;
+    virtual void set_window_size(SRDWindow* window, int width, int height) = 0;
+    virtual void set_window_title(SRDWindow* window, const std::string& title) = 0;
+    virtual void focus_window(SRDWindow* window) = 0;
+    virtual void minimize_window(SRDWindow* window) = 0;
+    virtual void maximize_window(SRDWindow* window) = 0;
+    virtual void close_window(SRDWindow* window) = 0;
+    
+    // Window decorations (cross-platform)
+    virtual void set_window_decorations(SRDWindow* window, bool enabled) = 0;
+    virtual void set_window_border_color(SRDWindow* window, int r, int g, int b) = 0;
+    virtual void set_window_border_width(SRDWindow* window, int width) = 0;
+    virtual bool get_window_decorations(SRDWindow* window) const = 0;
+    
+    // Monitor management
+    virtual std::vector<Monitor> get_monitors() = 0;
+    virtual Monitor get_primary_monitor() = 0;
+    
+    // Input handling
+    virtual void grab_keyboard() = 0;
+    virtual void ungrab_keyboard() = 0;
+    virtual void grab_pointer() = 0;
+    virtual void ungrab_pointer() = 0;
+    
+    // Utility
+    virtual std::string get_platform_name() const = 0;
+    virtual bool is_wayland() const = 0;
+    virtual bool is_x11() const = 0;
+    virtual bool is_windows() const = 0;
+    virtual bool is_macos() const = 0;
+};
+
+// Forward declaration
+class PlatformFactory;
+
+#endif // SRDWM_PLATFORM_H
+
diff --git a/src/platform/platform_factory.cc b/src/platform/platform_factory.cc
new file mode 100644
index 0000000..ef1981a
--- /dev/null
+++ b/src/platform/platform_factory.cc
@@ -0,0 +1,214 @@
+#include "platform_factory.h"
+#include <iostream>
+#include <cstring>
+#include <cstdlib>
+#include <algorithm>
+
+// Platform-specific includes
+#ifdef LINUX_PLATFORM
+    #include "x11_platform.h"
+    #ifdef WAYLAND_ENABLED
+        #include "wayland_platform.h"
+    #endif
+#elif defined(WIN32_PLATFORM)
+    #include "windows_platform.h"
+#elif defined(MACOS_PLATFORM)
+    #include "macos_platform.h"
+#endif
+
+std::unique_ptr<Platform> PlatformFactory::create_platform() {
+    #ifdef _WIN32
+        std::cout << "Creating SRDWindows platform..." << std::endl;
+        return std::make_unique<SRDWindowsPlatform>();
+        
+    #elif defined(__APPLE__)
+        std::cout << "Creating macOS platform..." << std::endl;
+        return std::make_unique<MacOSPlatform>();
+        
+    #else
+        // Linux: detect X11 vs Wayland
+        return detect_linux_platform();
+    #endif
+}
+
+std::unique_ptr<Platform> PlatformFactory::create_platform(const std::string& platform_name) {
+    std::cout << "Creating platform: " << platform_name << std::endl;
+    
+    if (platform_name == "x11" || platform_name == "X11") {
+        #ifdef LINUX_PLATFORM
+            return std::make_unique<X11Platform>();
+        #else
+            std::cerr << "X11 platform not available on this system" << std::endl;
+            return nullptr;
+        #endif
+        
+    } else if (platform_name == "wayland" || platform_name == "Wayland") {
+        #ifdef WAYLAND_ENABLED
+            return std::make_unique<WaylandPlatform>();
+        #else
+            std::cerr << "Wayland platform not available on this system" << std::endl;
+            return nullptr;
+        #endif
+        
+    } else if (platform_name == "windows" || platform_name == "SRDWindows") {
+        #ifdef WIN32_PLATFORM
+            return std::make_unique<SRDWindowsPlatform>();
+        #else
+            std::cerr << "SRDWindows platform not available on this system" << std::endl;
+            return nullptr;
+        #endif
+        
+    } else if (platform_name == "macos" || platform_name == "macOS") {
+        #ifdef MACOS_PLATFORM
+            return std::make_unique<MacOSPlatform>();
+        #else
+            std::cerr << "macOS platform not available on this system" << std::endl;
+            return nullptr;
+        #endif
+        
+    } else {
+        std::cerr << "Unknown platform: " << platform_name << std::endl;
+        std::cerr << "Available platforms: x11, wayland, windows, macos" << std::endl;
+        return nullptr;
+    }
+}
+
+std::unique_ptr<Platform> PlatformFactory::detect_linux_platform() {
+    std::cout << "Detecting Linux platform..." << std::endl;
+    
+    // Check environment variables for Wayland
+    const char* wayland_display = std::getenv("WAYLAND_DISPLAY");
+    const char* xdg_session_type = std::getenv("XDG_SESSION_TYPE");
+    const char* display = std::getenv("DISPLAY");
+    
+    std::cout << "Environment variables:" << std::endl;
+    std::cout << "  WAYLAND_DISPLAY: " << (wayland_display ? wayland_display : "not set") << std::endl;
+    std::cout << "  XDG_SESSION_TYPE: " << (xdg_session_type ? xdg_session_type : "not set") << std::endl;
+    std::cout << "  DISPLAY: " << (display ? display : "not set") << std::endl;
+    
+    // Try Wayland first if environment suggests it
+    if (wayland_display || (xdg_session_type && strcmp(xdg_session_type, "wayland") == 0)) {
+        std::cout << "Wayland environment detected, attempting Wayland initialization..." << std::endl;
+        
+        #ifdef WAYLAND_ENABLED
+            auto wayland_platform = std::make_unique<WaylandPlatform>();
+            if (wayland_platform->initialize()) {
+                std::cout << "✓ Wayland platform initialized successfully" << std::endl;
+                return wayland_platform;
+            } else {
+                std::cout << "✗ Wayland initialization failed, falling back to X11" << std::endl;
+            }
+        #else
+            std::cout << "Wayland support not compiled in, falling back to X11" << std::endl;
+        #endif
+    }
+    
+    // Fall back to X11
+    std::cout << "Attempting X11 initialization..." << std::endl;
+    
+    #ifdef LINUX_PLATFORM
+        auto x11_platform = std::make_unique<X11Platform>();
+        if (x11_platform->initialize()) {
+            std::cout << "✓ X11 platform initialized successfully" << std::endl;
+            return x11_platform;
+        } else {
+            std::cout << "✗ X11 initialization failed" << std::endl;
+        }
+    #else
+        std::cout << "X11 support not compiled in" << std::endl;
+    #endif
+    
+    std::cerr << "Failed to initialize any platform backend" << std::endl;
+    return nullptr;
+}
+
+std::vector<std::string> PlatformFactory::get_available_platforms() {
+    std::vector<std::string> platforms;
+    
+    #ifdef LINUX_PLATFORM
+        platforms.push_back("x11");
+        #ifdef WAYLAND_ENABLED
+            platforms.push_back("wayland");
+        #endif
+    #endif
+    
+    #ifdef WIN32_PLATFORM
+        platforms.push_back("windows");
+    #endif
+    
+    #ifdef MACOS_PLATFORM
+        platforms.push_back("macos");
+    #endif
+    
+    return platforms;
+}
+
+std::string PlatformFactory::get_current_platform() {
+    #ifdef _WIN32
+        return "windows";
+    #elif defined(__APPLE__)
+        return "macos";
+    #else
+        // Check if we're running on Wayland
+        const char* wayland_display = std::getenv("WAYLAND_DISPLAY");
+        const char* xdg_session_type = std::getenv("XDG_SESSION_TYPE");
+        
+        if (wayland_display || (xdg_session_type && strcmp(xdg_session_type, "wayland") == 0)) {
+            return "wayland";
+        } else {
+            return "x11";
+        }
+    #endif
+}
+
+bool PlatformFactory::is_platform_available(const std::string& platform_name) {
+    auto available = get_available_platforms();
+    return std::find(available.begin(), available.end(), platform_name) != available.end();
+}
+
+void PlatformFactory::print_platform_info() {
+    std::cout << "\n=== Platform Information ===" << std::endl;
+    std::cout << "Current platform: " << get_current_platform() << std::endl;
+    
+    auto available = get_available_platforms();
+    std::cout << "Available platforms: ";
+    for (size_t i = 0; i < available.size(); ++i) {
+        if (i > 0) std::cout << ", ";
+        std::cout << available[i];
+    }
+    std::cout << std::endl;
+    
+    std::cout << "Environment variables:" << std::endl;
+    const char* wayland_display = std::getenv("WAYLAND_DISPLAY");
+    const char* xdg_session_type = std::getenv("XDG_SESSION_TYPE");
+    const char* display = std::getenv("DISPLAY");
+    
+    std::cout << "  WAYLAND_DISPLAY: " << (wayland_display ? wayland_display : "not set") << std::endl;
+    std::cout << "  XDG_SESSION_TYPE: " << (xdg_session_type ? xdg_session_type : "not set") << std::endl;
+    std::cout << "  DISPLAY: " << (display ? display : "not set") << std::endl;
+    
+    #ifdef LINUX_PLATFORM
+        std::cout << "Linux platform support: Enabled" << std::endl;
+        #ifdef WAYLAND_ENABLED
+            std::cout << "Wayland support: Enabled" << std::endl;
+        #else
+            std::cout << "Wayland support: Disabled" << std::endl;
+        #endif
+    #else
+        std::cout << "Linux platform support: Disabled" << std::endl;
+    #endif
+    
+    #ifdef WIN32_PLATFORM
+        std::cout << "SRDWindows platform support: Enabled" << std::endl;
+    #else
+        std::cout << "SRDWindows platform support: Disabled" << std::endl;
+    #endif
+    
+    #ifdef MACOS_PLATFORM
+        std::cout << "macOS platform support: Enabled" << std::endl;
+    #else
+        std::cout << "macOS platform support: Disabled" << std::endl;
+    #endif
+    
+    std::cout << "=============================" << std::endl;
+}
diff --git a/src/platform/platform_factory.h b/src/platform/platform_factory.h
new file mode 100644
index 0000000..24f7586
--- /dev/null
+++ b/src/platform/platform_factory.h
@@ -0,0 +1,37 @@
+#ifndef SRDWM_PLATFORM_FACTORY_H
+#define SRDWM_PLATFORM_FACTORY_H
+
+#include "platform.h"
+#include <memory>
+#include <string>
+#include <vector>
+
+// Platform factory for creating platform-specific implementations
+class PlatformFactory {
+public:
+    // Create platform with automatic detection
+    static std::unique_ptr<Platform> create_platform();
+    
+    // Create specific platform by name
+    static std::unique_ptr<Platform> create_platform(const std::string& platform_name);
+    
+    // Get list of available platforms
+    static std::vector<std::string> get_available_platforms();
+    
+    // Get current platform name
+    static std::string get_current_platform();
+    
+    // Check if platform is available
+    static bool is_platform_available(const std::string& platform_name);
+    
+    // Print platform information
+    static void print_platform_info();
+
+private:
+    // Linux platform detection
+    static std::unique_ptr<Platform> detect_linux_platform();
+};
+
+#endif // SRDWM_PLATFORM_FACTORY_H
+
+
diff --git a/src/platform/wayland_platform.cc b/src/platform/wayland_platform.cc
new file mode 100644
index 0000000..2e4a591
--- /dev/null
+++ b/src/platform/wayland_platform.cc
@@ -0,0 +1,507 @@
+#include "wayland_platform.h"
+#include <iostream>
+#include <cstring>
+#include <cstdint>
+
+#ifndef USE_WAYLAND_STUB
+#include <wayland-server-core.h>
+extern "C" {
+  // Minimal wlroots declarations to avoid pulling C99-only headers into C++
+  struct wlr_backend;
+  struct wlr_renderer;
+  struct wlr_compositor;
+  struct wlr_seat;
+  struct wlr_xdg_shell;
+
+  // Logging
+  int wlr_log_init(int verbosity, void* callback);
+
+  // Backend
+  struct wlr_backend* wlr_backend_autocreate(struct wl_display* display, void* session);
+  bool wlr_backend_start(struct wlr_backend* backend);
+  void wlr_backend_destroy(struct wlr_backend* backend);
+  struct wlr_renderer* wlr_backend_get_renderer(struct wlr_backend* backend);
+
+  // Compositor and seat
+  struct wlr_compositor* wlr_compositor_create(struct wl_display* display, uint32_t version, struct wlr_renderer* renderer);
+  struct wlr_seat* wlr_seat_create(struct wl_display* display, const char* name);
+
+  // xdg-shell
+  struct wlr_xdg_shell* wlr_xdg_shell_create(struct wl_display* display, uint32_t version);
+  struct wlr_renderer* wlr_renderer_autocreate(struct wlr_backend* backend);
+  void wlr_renderer_init_wl_display(struct wlr_renderer* renderer, struct wl_display* display);
+
+  // Wayland display helpers (for C++ compilation)
+  struct wl_display* wl_display_create(void);
+  void wl_display_destroy(struct wl_display* display);
+  int wl_display_dispatch_pending(struct wl_display* display);
+  void wl_display_flush_clients(struct wl_display* display);
+}
+#endif
+
+// Static member initialization
+WaylandPlatform* WaylandPlatform::instance_ = nullptr;
+
+WaylandPlatform::WaylandPlatform()
+    : display_(nullptr)
+    , registry_(nullptr)
+    , compositor_(nullptr)
+    , shm_(nullptr)
+    , seat_(nullptr)
+    , output_(nullptr)
+    , shell_(nullptr)
+    , backend_(nullptr)
+    , renderer_(nullptr)
+    , wlr_compositor_(nullptr)
+    , output_layout_(nullptr)
+    , cursor_(nullptr)
+    , xcursor_manager_(nullptr)
+    , wlr_seat_(nullptr)
+    , xdg_shell_(nullptr)
+    // , layer_shell_(nullptr)
+    , event_loop_running_(false) {
+    
+    instance_ = this;
+}
+
+WaylandPlatform::~WaylandPlatform() {
+    shutdown();
+    if (instance_ == this) {
+        instance_ = nullptr;
+    }
+}
+
+bool WaylandPlatform::initialize() {
+#ifndef USE_WAYLAND_STUB
+    std::cout << "Initializing Wayland platform (wlroots real backend)..." << std::endl;
+    // Create Wayland display
+    display_ = wl_display_create();
+    if (!display_) {
+        std::cerr << "Failed to create wl_display" << std::endl;
+        return false;
+    }
+
+    // Initialize wlroots logging (optional) - 2 corresponds to INFO
+    wlr_log_init(2, nullptr);
+
+    // Create backend (auto-detect e.g., DRM, Wayland, X11)
+    backend_ = wlr_backend_autocreate(display_, nullptr);
+    if (!backend_) {
+        std::cerr << "Failed to create wlr_backend" << std::endl;
+        return false;
+    }
+
+    // Create renderer and hook to display
+    renderer_ = wlr_renderer_autocreate(backend_);
+    if (!renderer_) {
+        std::cerr << "Failed to create wlr_renderer" << std::endl;
+        return false;
+    }
+    wlr_renderer_init_wl_display(renderer_, display_);
+
+    // Create compositor (wlroots 0.17 requires protocol version). Use version 6.
+    wlr_compositor_ = wlr_compositor_create(display_, 6, renderer_);
+    if (!wlr_compositor_) {
+        std::cerr << "Failed to create wlr_compositor" << std::endl;
+        return false;
+    }
+
+    // Create seat (input)
+    wlr_seat_ = wlr_seat_create(display_, "seat0");
+    if (!wlr_seat_) {
+        std::cerr << "Failed to create wlr_seat" << std::endl;
+        return false;
+    }
+
+    // Create xdg-shell (requires protocol version)
+    xdg_shell_ = wlr_xdg_shell_create(display_, 6);
+    if (!xdg_shell_) {
+        std::cerr << "Failed to create wlr_xdg_shell" << std::endl;
+        return false;
+    }
+
+    // Minimal bring-up: listeners will be wired in a follow-up
+
+    // Start backend
+    if (!wlr_backend_start(backend_)) {
+        std::cerr << "Failed to start wlr_backend" << std::endl;
+        return false;
+    }
+
+    decorations_enabled_ = true;
+    std::cout << "Wayland (wlroots) backend started." << std::endl;
+    return true;
+#else
+    // Minimal Wayland backend initialization (no wlroots API calls).
+    std::cout << "Initializing Wayland platform (minimal stub)..." << std::endl;
+    decorations_enabled_ = true;
+    std::cout << "Wayland platform initialized (stub)." << std::endl;
+    return true;
+#endif
+}
+
+void WaylandPlatform::shutdown() {
+#ifndef USE_WAYLAND_STUB
+    std::cout << "Shutting down Wayland platform (wlroots)..." << std::endl;
+    if (xdg_shell_) { xdg_shell_ = nullptr; }
+    // Seat is tied to display lifecycle; skip explicit destroy to avoid ABI issues
+    wlr_seat_ = nullptr;
+    if (wlr_compositor_) { /* wlr_compositor is owned by display, no explicit destroy */ wlr_compositor_ = nullptr; }
+    // Renderer is owned by backend in this path; no explicit destroy
+    renderer_ = nullptr;
+    if (backend_) { wlr_backend_destroy(backend_); backend_ = nullptr; }
+    if (display_) { wl_display_destroy(display_); display_ = nullptr; }
+#else
+    std::cout << "Shutting down Wayland platform (stub)..." << std::endl;
+#endif
+}
+
+bool WaylandPlatform::setup_wlroots_backend() { std::cout << "wlroots backend (stub)" << std::endl; return true; }
+
+bool WaylandPlatform::setup_compositor() { std::cout << "compositor (stub)" << std::endl; return true; }
+
+// (removed unused stub-only setup_output/setup_input in real backend path)
+
+bool WaylandPlatform::setup_shell_protocols() { std::cout << "shell protocols (stub)" << std::endl; return true; }
+
+// bool WaylandPlatform::setup_xwayland() { return true; }
+
+bool WaylandPlatform::poll_events(std::vector<Event>& events) {
+#ifndef USE_WAYLAND_STUB
+    if (!display_ || !backend_) return false;
+    events.clear();
+    // Dispatch Wayland events; non-blocking to integrate with app loop
+    wl_display_dispatch_pending(display_);
+    wl_display_flush_clients(display_);
+    return true;
+#else
+    events.clear();
+    return true;
+#endif
+}
+
+void WaylandPlatform::process_event(const Event& event) {
+    // TODO: Implement event processing
+}
+
+std::unique_ptr<SRDWindow> WaylandPlatform::create_window(const std::string& title, int x, int y, int width, int height) {
+    // TODO: Implement window creation
+    std::cout << "Creating Wayland window: " << title << std::endl;
+    return nullptr;
+}
+
+void WaylandPlatform::destroy_window(SRDWindow* window) {
+    // TODO: Implement window destruction
+    std::cout << "Destroying Wayland window" << std::endl;
+}
+
+void WaylandPlatform::set_window_position(SRDWindow* window, int x, int y) {
+    // TODO: Implement window positioning
+}
+
+void WaylandPlatform::set_window_size(SRDWindow* window, int width, int height) {
+    // TODO: Implement window resizing
+}
+
+void WaylandPlatform::set_window_title(SRDWindow* window, const std::string& title) {
+    // TODO: Implement title setting
+}
+
+void WaylandPlatform::focus_window(SRDWindow* window) {
+    // TODO: Implement window focusing
+}
+
+void WaylandPlatform::minimize_window(SRDWindow* window) {
+    // TODO: Implement window minimization
+}
+
+void WaylandPlatform::maximize_window(SRDWindow* window) {
+    // TODO: Implement window maximization
+}
+
+void WaylandPlatform::close_window(SRDWindow* window) {
+    // TODO: Implement window closing
+}
+
+std::vector<Monitor> WaylandPlatform::get_monitors() {
+    // TODO: Implement monitor detection
+    return {};
+}
+
+Monitor WaylandPlatform::get_primary_monitor() {
+    // TODO: Implement primary monitor detection
+    return Monitor{};
+}
+
+void WaylandPlatform::grab_keyboard() {
+    // TODO: Implement keyboard grabbing
+}
+
+void WaylandPlatform::ungrab_keyboard() {
+    // TODO: Implement keyboard ungrab
+}
+
+void WaylandPlatform::grab_pointer() {
+    // TODO: Implement pointer grabbing
+}
+
+void WaylandPlatform::ungrab_pointer() {
+    // TODO: Implement pointer ungrab
+}
+
+// Static callback functions
+void WaylandPlatform::registry_global_handler(void* data, struct wl_registry* registry,
+                                             uint32_t name, const char* interface, uint32_t version) {
+    (void)registry; (void)name; (void)interface; (void)version;
+    WaylandPlatform* platform = static_cast<WaylandPlatform*>(data);
+    platform->handle_registry_global(nullptr, 0, interface ? interface : "", 0);
+}
+
+void WaylandPlatform::registry_global_remove_handler(void* data, struct wl_registry* registry, uint32_t name) {
+    (void)registry; (void)name;
+    WaylandPlatform* platform = static_cast<WaylandPlatform*>(data);
+    platform->handle_registry_global_remove(nullptr, 0);
+}
+
+void WaylandPlatform::xdg_surface_new_handler(struct wl_listener* listener, void* data) {
+    (void)listener;
+    if (WaylandPlatform::instance_) {
+        WaylandPlatform::instance_->handle_xdg_surface_new(static_cast<struct wlr_xdg_surface*>(data));
+    }
+}
+
+void WaylandPlatform::xdg_surface_destroy_handler(struct wl_listener* listener, void* data) {
+    (void)listener;
+    if (WaylandPlatform::instance_) {
+        WaylandPlatform::instance_->handle_xdg_surface_destroy(static_cast<struct wlr_xdg_surface*>(data));
+    }
+}
+
+void WaylandPlatform::xdg_toplevel_new_handler(struct wl_listener* listener, void* data) {
+    (void)listener;
+    if (WaylandPlatform::instance_) {
+        WaylandPlatform::instance_->handle_xdg_toplevel_new(static_cast<struct wlr_xdg_toplevel*>(data));
+    }
+}
+
+void WaylandPlatform::xdg_toplevel_destroy_handler(struct wl_listener* listener, void* data) {
+    (void)listener;
+    if (WaylandPlatform::instance_) {
+        WaylandPlatform::instance_->handle_xdg_toplevel_destroy(static_cast<struct wlr_xdg_toplevel*>(data));
+    }
+}
+
+// (removed xwayland handlers; not declared while XWayland is disabled)
+
+void WaylandPlatform::output_new_handler(struct wl_listener* listener, void* data) {
+    (void)listener;
+    if (WaylandPlatform::instance_) {
+        WaylandPlatform::instance_->handle_output_new(static_cast<struct wlr_output*>(data));
+    }
+}
+
+void WaylandPlatform::output_destroy_handler(struct wl_listener* listener, void* data) {
+    (void)listener;
+    if (WaylandPlatform::instance_) {
+        WaylandPlatform::instance_->handle_output_destroy(static_cast<struct wlr_output*>(data));
+    }
+}
+
+void WaylandPlatform::output_frame_handler(struct wl_listener* listener, void* data) {
+    (void)listener;
+    if (WaylandPlatform::instance_) {
+        WaylandPlatform::instance_->handle_output_frame(static_cast<struct wlr_output*>(data));
+    }
+}
+
+void WaylandPlatform::pointer_motion_handler(struct wl_listener* listener, void* data) {
+    (void)listener;
+    if (WaylandPlatform::instance_) {
+        WaylandPlatform::instance_->handle_pointer_motion(static_cast<struct wlr_pointer_motion_event*>(data));
+    }
+}
+
+void WaylandPlatform::pointer_button_handler(struct wl_listener* listener, void* data) {
+    (void)listener;
+    if (WaylandPlatform::instance_) {
+        WaylandPlatform::instance_->handle_pointer_button(static_cast<struct wlr_pointer_button_event*>(data));
+    }
+}
+
+void WaylandPlatform::pointer_axis_handler(struct wl_listener* listener, void* data) {
+    (void)listener;
+    if (WaylandPlatform::instance_) {
+        WaylandPlatform::instance_->handle_pointer_axis(static_cast<struct wlr_pointer_axis_event*>(data));
+    }
+}
+
+void WaylandPlatform::keyboard_key_handler(struct wl_listener* listener, void* data) {
+    (void)listener;
+    if (WaylandPlatform::instance_) {
+        WaylandPlatform::instance_->handle_keyboard_key(static_cast<struct wlr_keyboard_key_event*>(data));
+    }
+}
+
+// Event handling methods
+void WaylandPlatform::handle_registry_global(struct wl_registry* registry, uint32_t name, 
+                                            const char* interface, uint32_t version) {
+    (void)registry; (void)name; (void)version;
+    std::cout << "Registry global (stub): " << (interface ? interface : "?") << std::endl;
+}
+
+void WaylandPlatform::handle_registry_global_remove(struct wl_registry* registry, uint32_t name) {
+    (void)registry; (void)name;
+}
+
+void WaylandPlatform::handle_xdg_surface_new(struct wlr_xdg_surface* surface) {
+    std::cout << "New XDG surface" << std::endl;
+    manage_xdg_window(surface);
+}
+
+void WaylandPlatform::handle_xdg_surface_destroy(struct wlr_xdg_surface* surface) {
+    std::cout << "XDG surface destroyed" << std::endl;
+}
+
+void WaylandPlatform::handle_xdg_toplevel_new(struct wlr_xdg_toplevel* toplevel) {
+    std::cout << "New XDG toplevel" << std::endl;
+}
+
+void WaylandPlatform::handle_xdg_toplevel_destroy(struct wlr_xdg_toplevel* toplevel) {
+    std::cout << "XDG toplevel destroyed" << std::endl;
+}
+
+// void WaylandPlatform::handle_xwayland_surface_new(struct wlr_xwayland_surface* surface) {}
+
+// void WaylandPlatform::handle_xwayland_surface_destroy(struct wlr_xwayland_surface* surface) {}
+
+void WaylandPlatform::handle_output_new(struct wlr_output* output) {
+    std::cout << "New output" << std::endl;
+    handle_output_mode(output);
+}
+
+void WaylandPlatform::handle_output_destroy(struct wlr_output* output) {
+    std::cout << "Output destroyed" << std::endl;
+}
+
+void WaylandPlatform::handle_output_frame(struct wlr_output* output) {
+    // Handle output frame event
+}
+
+void WaylandPlatform::handle_pointer_motion(struct wlr_pointer_motion_event* event) {
+    // Handle pointer motion
+}
+
+void WaylandPlatform::handle_pointer_button(struct wlr_pointer_button_event* event) {
+    // Handle pointer button
+}
+
+void WaylandPlatform::handle_pointer_axis(struct wlr_pointer_axis_event* event) {
+    // Handle pointer axis
+}
+
+void WaylandPlatform::handle_keyboard_key(struct wlr_keyboard_key_event* event) {
+    // Handle keyboard key
+}
+
+void WaylandPlatform::manage_xdg_window(struct wlr_xdg_surface* surface) {
+    // TODO: Implement XDG window management
+}
+
+// void WaylandPlatform::manage_xwayland_window(struct wlr_xwayland_surface* surface) {}
+
+void WaylandPlatform::unmanage_window(SRDWindow* window) {
+    // TODO: Implement window unmanagement
+}
+
+void WaylandPlatform::handle_output_mode(struct wlr_output* output) {
+    // TODO: Implement output mode handling
+}
+
+void WaylandPlatform::handle_output_scale(struct wlr_output* output) {
+    // TODO: Implement output scale handling
+}
+
+void WaylandPlatform::handle_key_event(uint32_t key, bool pressed) {
+    // TODO: Implement key event handling
+}
+
+void WaylandPlatform::handle_button_event(uint32_t button, bool pressed) {
+    // TODO: Implement button event handling
+}
+
+void WaylandPlatform::create_surface_window(struct wlr_surface* surface) {
+    // TODO: Implement surface window creation
+}
+
+void WaylandPlatform::destroy_surface_window(struct wlr_surface* surface) {
+    // TODO: Implement surface window destruction
+}
+
+void WaylandPlatform::update_surface_window(struct wlr_surface* surface) {
+    // TODO: Implement surface window update
+}
+
+void WaylandPlatform::convert_wlroots_event_to_srdwm_event(void* event_data, EventType type) {
+    // TODO: Implement event conversion
+}
+
+void WaylandPlatform::handle_wlroots_error(const std::string& error) {
+    std::cerr << "wlroots error: " << error << std::endl;
+}
+
+// SRDWindow decoration implementations
+void WaylandPlatform::set_window_decorations(SRDWindow* window, bool enabled) {
+    // Temporary stub: wlroots xdg-decoration v1 helpers differ across versions.
+    // Keep internal state and log, skip calling decoration APIs.
+    std::cout << "WaylandPlatform: Set window decorations " << (enabled ? "enabled" : "disabled") << std::endl;
+    (void)window; // unused for now
+    decorations_enabled_ = enabled;
+}
+
+void WaylandPlatform::set_window_border_color(SRDWindow* window, int r, int g, int b) {
+    std::cout << "WaylandPlatform: Set border color RGB(" << r << "," << g << "," << b << ")" << std::endl;
+    
+    if (!window || !renderer_) return;
+    
+    // Store border color for this window
+    // In a full implementation, this would be stored in a window-specific data structure
+    // and applied during rendering
+    
+    // For now, we'll just log the request
+    // TODO: Implement custom border rendering via wlroots rendering pipeline
+    std::cout << "Border color set for window " << window->getId() 
+              << ": RGB(" << r << "," << g << "," << b << ")" << std::endl;
+}
+
+void WaylandPlatform::set_window_border_width(SRDWindow* window, int width) {
+    std::cout << "WaylandPlatform: Set border width " << width << std::endl;
+    
+    if (!window) return;
+    
+    // TODO: Implement when wlroots rendering is set up
+    // This would involve drawing custom borders on surfaces
+}
+
+bool WaylandPlatform::get_window_decorations(SRDWindow* window) const {
+    if (!window) return false;
+    
+    return decorations_enabled_;
+}
+
+void WaylandPlatform::setup_decoration_manager() {
+    // Temporary stub: skip creating xdg-decoration manager to avoid 
+    // wlroots API/ABI differences across distro versions.
+    std::cout << "Decoration manager (stub) initialized" << std::endl;
+}
+
+void WaylandPlatform::handle_decoration_request(struct wlr_xdg_surface* surface, uint32_t mode) {
+    std::cout << "Handling decoration request, mode: " << mode << std::endl;
+    
+    // TODO: Implement when zxdg-decoration protocol is available
+    // This would involve:
+    // 1. Checking if server-side decorations are enabled
+    // 2. Setting the decoration mode for the surface
+    // 3. Drawing decorations if needed
+}
+
+
diff --git a/src/platform/wayland_platform.h b/src/platform/wayland_platform.h
new file mode 100644
index 0000000..3df5867
--- /dev/null
+++ b/src/platform/wayland_platform.h
@@ -0,0 +1,227 @@
+#ifndef SRDWM_WAYLAND_PLATFORM_H
+#define SRDWM_WAYLAND_PLATFORM_H
+
+#include "platform.h"
+#ifndef USE_WAYLAND_STUB
+#include <wayland-server-core.h>
+#endif
+// Forward-declare Wayland and wlroots types to avoid version-specific headers.
+struct wl_display; struct wl_registry; struct wl_compositor; struct wl_shm; struct wl_seat; struct wl_output; struct wl_shell; struct wl_listener; struct wl_surface;
+struct wlr_backend; struct wlr_renderer; struct wlr_compositor; struct wlr_output_layout; struct wlr_cursor; struct wlr_xcursor_manager; struct wlr_seat;
+struct wlr_xdg_shell; struct wlr_xdg_surface; struct wlr_xdg_toplevel;
+struct wlr_output; struct wlr_pointer_motion_event; struct wlr_pointer_button_event; struct wlr_pointer_axis_event; struct wlr_keyboard_key_event;
+struct wlr_xdg_decoration_manager_v1;
+#include <map>
+#include <memory>
+#include <vector>
+
+// Forward declarations
+class SRDWindow;
+class Monitor;
+
+// Wayland-specific platform implementation
+class WaylandPlatform : public Platform {
+public:
+    WaylandPlatform();
+    ~WaylandPlatform();
+
+    // Platform interface implementation
+    bool initialize() override;
+    void shutdown() override;
+    
+    // Event handling
+    bool poll_events(std::vector<Event>& events) override;
+    void process_event(const Event& event) override;
+
+    // SRDWindow management
+    std::unique_ptr<SRDWindow> create_window(const std::string& title, int x, int y, int width, int height) override;
+    void destroy_window(SRDWindow* window) override;
+    void set_window_position(SRDWindow* window, int x, int y) override;
+    void set_window_size(SRDWindow* window, int width, int height) override;
+    void set_window_title(SRDWindow* window, const std::string& title) override;
+    void focus_window(SRDWindow* window) override;
+    void minimize_window(SRDWindow* window) override;
+    void maximize_window(SRDWindow* window) override;
+    void close_window(SRDWindow* window) override;
+
+    // Monitor management
+    std::vector<Monitor> get_monitors() override;
+    Monitor get_primary_monitor() override;
+
+    // Input handling
+    void grab_keyboard() override;
+    void ungrab_keyboard() override;
+    void grab_pointer() override;
+    void ungrab_pointer() override;
+
+    // Utility
+    // SRDWindow decorations (Wayland implementation)
+    void set_window_decorations(SRDWindow* window, bool enabled) override;
+    void set_window_border_color(SRDWindow* window, int r, int g, int b) override;
+    void set_window_border_width(SRDWindow* window, int width) override;
+    bool get_window_decorations(SRDWindow* window) const override;
+
+    std::string get_platform_name() const override { return "Wayland"; }
+    bool is_wayland() const override { return true; }
+    bool is_x11() const override { return false; }
+    bool is_windows() const override { return false; }
+    bool is_macos() const override { return false; }
+
+private:
+    static WaylandPlatform* instance_;
+    // Wayland-specific members
+    struct wl_display* display_;
+    struct wl_registry* registry_;
+    struct wl_compositor* compositor_;
+    struct wl_shm* shm_;
+    struct wl_seat* seat_;
+    struct wl_output* output_;
+    struct wl_shell* shell_;
+    
+    // wlroots backend
+    struct wlr_backend* backend_;
+    struct wlr_renderer* renderer_;
+    struct wlr_compositor* wlr_compositor_;
+    struct wlr_output_layout* output_layout_;
+    struct wlr_cursor* cursor_;
+    struct wlr_xcursor_manager* xcursor_manager_;
+    struct wlr_seat* wlr_seat_;
+    
+    // Shell protocols
+    struct wlr_xdg_shell* xdg_shell_;
+    // struct wlr_layer_shell_v1* layer_shell_;
+    
+    // XWayland support (temporarily disabled)
+    // struct wlr_xwayland* xwayland_;
+    // struct wlr_xwayland_server* xwayland_server_;
+    
+    // SRDWindow tracking
+    std::map<struct wlr_surface*, SRDWindow*> surface_window_map_;
+    std::map<struct wlr_xdg_surface*, SRDWindow*> xdg_window_map_;
+    // std::map<struct wlr_xwayland_surface*, SRDWindow*> xwayland_window_map_;
+    
+    // Monitor information
+    std::vector<Monitor> monitors_;
+    Monitor primary_monitor_;
+    
+    // Event handling
+    bool event_loop_running_;
+    std::vector<Event> pending_events_;
+    
+    // Private methods
+    bool setup_wlroots_backend();
+    bool setup_compositor();
+    bool setup_shell_protocols();
+    // bool setup_xwayland();
+    
+    // Event handling
+    void handle_registry_global(struct wl_registry* registry, uint32_t name, 
+                               const char* interface, uint32_t version);
+    void handle_registry_global_remove(struct wl_registry* registry, uint32_t name);
+    
+    // Shell protocol handlers
+    void handle_xdg_surface_new(struct wlr_xdg_surface* surface);
+    void handle_xdg_surface_destroy(struct wlr_xdg_surface* surface);
+    void handle_xdg_toplevel_new(struct wlr_xdg_toplevel* toplevel);
+    void handle_xdg_toplevel_destroy(struct wlr_xdg_toplevel* toplevel);
+    
+    // XWayland handlers (temporarily disabled)
+    // void handle_xwayland_surface_new(struct wlr_xwayland_surface* surface);
+    // void handle_xwayland_surface_destroy(struct wlr_xwayland_surface* surface);
+    
+    // Output handlers
+    void handle_output_new(struct wlr_output* output);
+    void handle_output_destroy(struct wlr_output* output);
+    void handle_output_frame(struct wlr_output* output);
+    
+    // Input handlers
+    void handle_pointer_motion(struct wlr_pointer_motion_event* event);
+    void handle_pointer_button(struct wlr_pointer_button_event* event);
+    void handle_pointer_axis(struct wlr_pointer_axis_event* event);
+    void handle_keyboard_key(struct wlr_keyboard_key_event* event);
+    
+    // SRDWindow management helpers
+    SRDWindow* find_window_by_surface(struct wlr_surface* surface);
+    SRDWindow* find_window_by_xdg_surface(struct wlr_xdg_surface* surface);
+    // SRDWindow* find_window_by_xwayland_surface(struct wlr_xwayland_surface* surface);
+    void manage_xdg_window(struct wlr_xdg_surface* surface);
+    // void manage_xwayland_window(struct wlr_xwayland_surface* surface);
+    void unmanage_window(SRDWindow* window);
+    
+    // Monitor helpers
+    void update_monitor_info();
+    void handle_output_mode(struct wlr_output* output);
+    void handle_output_scale(struct wlr_output* output);
+    
+    // Input helpers
+    void setup_keyboard_grab();
+    void setup_pointer_grab();
+    void handle_key_event(uint32_t key, bool pressed);
+    void handle_button_event(uint32_t button, bool pressed);
+    
+    // Utility helpers
+    void create_surface_window(struct wlr_surface* surface);
+    void destroy_surface_window(struct wlr_surface* surface);
+    void update_surface_window(struct wlr_surface* surface);
+    
+    // Event conversion
+    void convert_wlroots_event_to_srdwm_event(void* event_data, EventType type);
+    
+    // Error handling
+    void handle_wlroots_error(const std::string& error);
+    
+    // Decoration methods
+    void setup_decoration_manager();
+    void handle_decoration_request(struct wlr_xdg_surface* surface, uint32_t mode);
+    
+    // Static callback functions
+    static void registry_global_handler(void* data, struct wl_registry* registry,
+                                       uint32_t name, const char* interface, uint32_t version);
+    static void registry_global_remove_handler(void* data, struct wl_registry* registry, uint32_t name);
+    
+    static void xdg_surface_new_handler(struct wl_listener* listener, void* data);
+    static void xdg_surface_destroy_handler(struct wl_listener* listener, void* data);
+    static void xdg_toplevel_new_handler(struct wl_listener* listener, void* data);
+    static void xdg_toplevel_destroy_handler(struct wl_listener* listener, void* data);
+    
+    // static void xwayland_surface_new_handler(struct wl_listener* listener, void* data);
+    // static void xwayland_surface_destroy_handler(struct wl_listener* listener, void* data);
+    
+    static void output_new_handler(struct wl_listener* listener, void* data);
+    static void output_destroy_handler(struct wl_listener* listener, void* data);
+    static void output_frame_handler(struct wl_listener* listener, void* data);
+    
+    static void pointer_motion_handler(struct wl_listener* listener, void* data);
+    static void pointer_button_handler(struct wl_listener* listener, void* data);
+    static void pointer_axis_handler(struct wl_listener* listener, void* data);
+    static void keyboard_key_handler(struct wl_listener* listener, void* data);
+    
+    // Event listeners removed in stubbed build to avoid wl_listener dependency
+    // wlroots event listeners (instantiated only in real Wayland path)
+    #ifndef USE_WAYLAND_STUB
+    struct wl_listener xdg_surface_new_listener_;
+    struct wl_listener xdg_surface_destroy_listener_;
+    struct wl_listener xdg_toplevel_new_listener_;
+    struct wl_listener xdg_toplevel_destroy_listener_;
+    struct wl_listener output_new_listener_;
+    struct wl_listener output_destroy_listener_;
+    struct wl_listener output_frame_listener_;
+    struct wl_listener pointer_motion_listener_;
+    struct wl_listener pointer_button_listener_;
+    struct wl_listener pointer_axis_listener_;
+    struct wl_listener keyboard_key_listener_;
+    #endif
+
+    // Decoration state
+    bool decorations_enabled_;
+    struct wlr_xdg_decoration_manager_v1* decoration_manager_;
+    
+    // struct wl_listener xwayland_new_surface;
+    // struct wl_listener xwayland_destroy;
+    
+    // Additional listeners removed in stubbed build
+};
+
+#endif // SRDWM_WAYLAND_PLATFORM_H
+
+
diff --git a/src/platform/wayland_platform_stub.cc b/src/platform/wayland_platform_stub.cc
new file mode 100644
index 0000000..bdf6ee9
--- /dev/null
+++ b/src/platform/wayland_platform_stub.cc
@@ -0,0 +1,114 @@
+#include "wayland_platform.h"
+#include <iostream>
+#include <cstdint>
+
+WaylandPlatform* WaylandPlatform::instance_ = nullptr;
+
+WaylandPlatform::WaylandPlatform()
+    : display_(nullptr)
+    , registry_(nullptr)
+    , compositor_(nullptr)
+    , shm_(nullptr)
+    , seat_(nullptr)
+    , output_(nullptr)
+    , shell_(nullptr)
+    , backend_(nullptr)
+    , renderer_(nullptr)
+    , wlr_compositor_(nullptr)
+    , output_layout_(nullptr)
+    , cursor_(nullptr)
+    , xcursor_manager_(nullptr)
+    , wlr_seat_(nullptr)
+    , xdg_shell_(nullptr)
+    , event_loop_running_(false)
+    , decorations_enabled_(true)
+    , decoration_manager_(nullptr) {
+  instance_ = this;
+}
+
+WaylandPlatform::~WaylandPlatform() {
+  shutdown();
+  if (instance_ == this) instance_ = nullptr;
+}
+
+bool WaylandPlatform::initialize() {
+  std::cout << "Wayland (stub): initialize" << std::endl;
+  decorations_enabled_ = true;
+  return true;
+}
+
+void WaylandPlatform::shutdown() {
+  std::cout << "Wayland (stub): shutdown" << std::endl;
+}
+
+bool WaylandPlatform::poll_events(std::vector<Event>& events) {
+  events.clear();
+  return true;
+}
+
+void WaylandPlatform::process_event(const Event& /*event*/) {}
+
+std::unique_ptr<SRDWindow> WaylandPlatform::create_window(const std::string& title, int, int, int, int) {
+  std::cout << "Wayland (stub): create_window '" << title << "'" << std::endl;
+  return nullptr;
+}
+
+void WaylandPlatform::destroy_window(SRDWindow*) {}
+void WaylandPlatform::set_window_position(SRDWindow*, int, int) {}
+void WaylandPlatform::set_window_size(SRDWindow*, int, int) {}
+void WaylandPlatform::set_window_title(SRDWindow*, const std::string&) {}
+void WaylandPlatform::focus_window(SRDWindow*) {}
+void WaylandPlatform::minimize_window(SRDWindow*) {}
+void WaylandPlatform::maximize_window(SRDWindow*) {}
+void WaylandPlatform::close_window(SRDWindow*) {}
+std::vector<Monitor> WaylandPlatform::get_monitors() { return {}; }
+Monitor WaylandPlatform::get_primary_monitor() { return Monitor{}; }
+void WaylandPlatform::grab_keyboard() {}
+void WaylandPlatform::ungrab_keyboard() {}
+void WaylandPlatform::grab_pointer() {}
+void WaylandPlatform::ungrab_pointer() {}
+void WaylandPlatform::set_window_decorations(SRDWindow*, bool enabled) { decorations_enabled_ = enabled; }
+void WaylandPlatform::set_window_border_color(SRDWindow*, int, int, int) {}
+void WaylandPlatform::set_window_border_width(SRDWindow*, int) {}
+bool WaylandPlatform::get_window_decorations(SRDWindow*) const { return decorations_enabled_; }
+
+// Private helpers (stubs)
+bool WaylandPlatform::setup_wlroots_backend() { return true; }
+bool WaylandPlatform::setup_compositor() { return true; }
+bool WaylandPlatform::setup_shell_protocols() { return true; }
+void WaylandPlatform::handle_registry_global(struct wl_registry*, uint32_t, const char*, uint32_t) {}
+void WaylandPlatform::handle_registry_global_remove(struct wl_registry*, uint32_t) {}
+void WaylandPlatform::handle_xdg_surface_new(struct wlr_xdg_surface*) {}
+void WaylandPlatform::handle_xdg_surface_destroy(struct wlr_xdg_surface*) {}
+void WaylandPlatform::handle_xdg_toplevel_new(struct wlr_xdg_toplevel*) {}
+void WaylandPlatform::handle_xdg_toplevel_destroy(struct wlr_xdg_toplevel*) {}
+void WaylandPlatform::handle_output_new(struct wlr_output*) {}
+void WaylandPlatform::handle_output_destroy(struct wlr_output*) {}
+void WaylandPlatform::handle_output_frame(struct wlr_output*) {}
+void WaylandPlatform::handle_pointer_motion(struct wlr_pointer_motion_event*) {}
+void WaylandPlatform::handle_pointer_button(struct wlr_pointer_button_event*) {}
+void WaylandPlatform::handle_pointer_axis(struct wlr_pointer_axis_event*) {}
+void WaylandPlatform::keyboard_key_handler(struct wl_listener*, void*) {}
+void WaylandPlatform::pointer_motion_handler(struct wl_listener*, void*) {}
+void WaylandPlatform::pointer_button_handler(struct wl_listener*, void*) {}
+void WaylandPlatform::pointer_axis_handler(struct wl_listener*, void*) {}
+void WaylandPlatform::output_new_handler(struct wl_listener*, void*) {}
+void WaylandPlatform::output_destroy_handler(struct wl_listener*, void*) {}
+void WaylandPlatform::output_frame_handler(struct wl_listener*, void*) {}
+void WaylandPlatform::xdg_surface_new_handler(struct wl_listener*, void*) {}
+void WaylandPlatform::xdg_surface_destroy_handler(struct wl_listener*, void*) {}
+void WaylandPlatform::xdg_toplevel_new_handler(struct wl_listener*, void*) {}
+void WaylandPlatform::xdg_toplevel_destroy_handler(struct wl_listener*, void*) {}
+void WaylandPlatform::manage_xdg_window(struct wlr_xdg_surface*) {}
+void WaylandPlatform::unmanage_window(SRDWindow*) {}
+void WaylandPlatform::handle_output_mode(struct wlr_output*) {}
+void WaylandPlatform::handle_output_scale(struct wlr_output*) {}
+void WaylandPlatform::handle_key_event(uint32_t, bool) {}
+void WaylandPlatform::handle_button_event(uint32_t, bool) {}
+void WaylandPlatform::create_surface_window(struct wlr_surface*) {}
+void WaylandPlatform::destroy_surface_window(struct wlr_surface*) {}
+void WaylandPlatform::update_surface_window(struct wlr_surface*) {}
+void WaylandPlatform::convert_wlroots_event_to_srdwm_event(void*, EventType) {}
+void WaylandPlatform::handle_wlroots_error(const std::string&) {}
+void WaylandPlatform::setup_decoration_manager() {}
+void WaylandPlatform::handle_decoration_request(struct wlr_xdg_surface*, uint32_t) {}
diff --git a/src/platform/windows_platform.cc b/src/platform/windows_platform.cc
new file mode 100644
index 0000000..11cadca
--- /dev/null
+++ b/src/platform/windows_platform.cc
@@ -0,0 +1,585 @@
+#include "windows_platform.h"
+#include <iostream>
+#include <windows.h>
+#include <dwmapi.h>
+
+// Static member initialization
+SRDWindowsPlatform* SRDWindowsPlatform::instance_ = nullptr;
+
+SRDWindowsPlatform::SRDWindowsPlatform()
+    : h_instance_(nullptr)
+    , keyboard_hook_(nullptr)
+    , mouse_hook_(nullptr) {
+    
+    instance_ = this;
+}
+
+SRDWindowsPlatform::~SRDWindowsPlatform() {
+    shutdown();
+    if (instance_ == this) {
+        instance_ = nullptr;
+    }
+}
+
+bool SRDWindowsPlatform::initialize() {
+    std::cout << "Initializing SRDWindows platform..." << std::endl;
+    
+    // Get module handle
+    h_instance_ = GetModuleHandle(nullptr);
+    if (!h_instance_) {
+        std::cerr << "Failed to get module handle" << std::endl;
+        return false;
+    }
+    
+    // Register window class
+    if (!register_window_class()) {
+        std::cerr << "Failed to register window class" << std::endl;
+        return false;
+    }
+    
+    // Setup global hooks
+    setup_global_hooks();
+    
+    std::cout << "SRDWindows platform initialized successfully" << std::endl;
+    return true;
+}
+
+void SRDWindowsPlatform::shutdown() {
+    std::cout << "Shutting down SRDWindows platform..." << std::endl;
+    
+    // Unhook global hooks
+    if (keyboard_hook_) {
+        UnhookSRDWindowsHookEx(keyboard_hook_);
+        keyboard_hook_ = nullptr;
+    }
+    
+    if (mouse_hook_) {
+        UnhookSRDWindowsHookEx(mouse_hook_);
+        mouse_hook_ = nullptr;
+    }
+    
+    // Clean up windows
+    for (auto& pair : window_map_) {
+        if (pair.second) {
+            delete pair.second;
+        }
+    }
+    window_map_.clear();
+    
+    std::cout << "SRDWindows platform shutdown complete" << std::endl;
+}
+
+// SRDWindow decoration implementations
+void SRDWindowsPlatform::set_window_decorations(SRDWindow* window, bool enabled) {
+    std::cout << "SRDWindowsPlatform: Set window decorations " << (enabled ? "enabled" : "disabled") << std::endl;
+    
+    if (!window) return;
+    
+    // Find the HWND for this window
+    HWND hwnd = nullptr;
+    for (const auto& pair : window_map_) {
+        if (pair.second == window) {
+            hwnd = pair.first;
+            break;
+        }
+    }
+    
+    if (!hwnd) return;
+    
+    decorations_enabled_ = enabled;
+    
+    if (enabled) {
+        // Enable native window decorations
+        LONG style = GetSRDWindowLong(hwnd, GWL_STYLE);
+        style |= WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
+        SetSRDWindowLong(hwnd, GWL_STYLE, style);
+    } else {
+        // Disable native window decorations
+        LONG style = GetSRDWindowLong(hwnd, GWL_STYLE);
+        style &= ~(WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX);
+        SetSRDWindowLong(hwnd, GWL_STYLE, style);
+    }
+    
+    // Force window redraw
+    SetSRDWindowPos(hwnd, nullptr, 0, 0, 0, 0, 
+                SWP_FRAMECHANGED | SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
+}
+
+void SRDWindowsPlatform::set_window_border_color(SRDWindow* window, int r, int g, int b) {
+    std::cout << "SRDWindowsPlatform: Set border color RGB(" << r << "," << g << "," << b << ")" << std::endl;
+    
+    if (!window) return;
+    
+    // Find the HWND for this window
+    HWND hwnd = nullptr;
+    for (const auto& pair : window_map_) {
+        if (pair.second == window) {
+            hwnd = pair.first;
+            break;
+        }
+    }
+    
+    if (!hwnd) return;
+    
+    COLORREF color = RGB(r, g, b);
+    apply_dwm_border_color(hwnd, r, g, b);
+}
+
+void SRDWindowsPlatform::set_window_border_width(SRDWindow* window, int width) {
+    std::cout << "SRDWindowsPlatform: Set border width " << width << std::endl;
+    
+    if (!window) return;
+    
+    border_width_ = width;
+    
+    // SRDWindows doesn't support custom border widths via DWM
+    // This would need to be implemented with custom window frames
+}
+
+bool SRDWindowsPlatform::get_window_decorations(SRDWindow* window) const {
+    if (!window) return false;
+    
+    return decorations_enabled_;
+}
+
+void SRDWindowsPlatform::apply_dwm_border_color(HWND hwnd, int r, int g, int b) {
+    // Use DWM API to set border color (SRDWindows 11 feature)
+    COLORREF color = RGB(r, g, b);
+    
+    HRESULT result = DwmSetSRDWindowAttribute(hwnd, DWMWA_BORDER_COLOR, &color, sizeof(color));
+    if (FAILED(result)) {
+        std::cerr << "Failed to set DWM border color" << std::endl;
+    }
+}
+
+void SRDWindowsPlatform::remove_dwm_border_color(HWND hwnd) {
+    // Remove custom border color
+    COLORREF color = DWMWA_COLOR_DEFAULT;
+    
+    HRESULT result = DwmSetSRDWindowAttribute(hwnd, DWMWA_BORDER_COLOR, &color, sizeof(color));
+    if (FAILED(result)) {
+        std::cerr << "Failed to remove DWM border color" << std::endl;
+    }
+}
+
+bool SRDWindowsPlatform::register_window_class() {
+    WNDCLASSEX wc = {};
+    wc.cbSize = sizeof(WNDCLASSEX);
+    wc.lpfnWndProc = window_proc;
+    wc.hInstance = h_instance_;
+    wc.lpszClassName = L"SRDWM_SRDWindow";
+    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
+    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
+    wc.style = CS_HREDRAW | CS_VREDRAW;
+    
+    return RegisterClassEx(&wc) != 0;
+}
+
+void SRDWindowsPlatform::setup_global_hooks() {
+    std::cout << "Setting up global hooks..." << std::endl;
+    
+    // Global keyboard hook
+    keyboard_hook_ = SetSRDWindowsHookEx(WH_KEYBOARD_LL, 
+        keyboard_proc, h_instance_, 0);
+    if (!keyboard_hook_) {
+        std::cerr << "Failed to set keyboard hook" << std::endl;
+    }
+    
+    // Global mouse hook
+    mouse_hook_ = SetSRDWindowsHookEx(WH_MOUSE_LL, 
+        mouse_proc, h_instance_, 0);
+    if (!mouse_hook_) {
+        std::cerr << "Failed to set mouse hook" << std::endl;
+    }
+    
+    std::cout << "Global hooks setup complete" << std::endl;
+}
+
+LRESULT CALLBACK SRDWindowsPlatform::window_proc(HWND hwnd, UINT msg, 
+                                             WPARAM wparam, LPARAM lparam) {
+    switch (msg) {
+        case WM_CREATE:
+            std::cout << "SRDWindow created: " << hwnd << std::endl;
+            break;
+            
+        case WM_DESTROY:
+            std::cout << "SRDWindow destroyed: " << hwnd << std::endl;
+            break;
+            
+        case WM_SIZE:
+            // Handle window resizing
+            break;
+            
+        case WM_MOVE:
+            // Handle window moving
+            break;
+            
+        case WM_SETFOCUS:
+            // Handle window focus
+            break;
+            
+        case WM_KILLFOCUS:
+            // Handle window unfocus
+            break;
+            
+        case WM_CLOSE:
+            // Handle window close request
+            break;
+            
+        default:
+            return DefSRDWindowProc(hwnd, msg, wparam, lparam);
+    }
+    return 0;
+}
+
+LRESULT CALLBACK SRDWindowsPlatform::keyboard_proc(int nCode, WPARAM wparam, LPARAM lparam) {
+    if (nCode >= 0) {
+        KBDLLHOOKSTRUCT* kbhs = (KBDLLHOOKSTRUCT*)lparam;
+        
+        if (wparam == WM_KEYDOWN || wparam == WM_SYSKEYDOWN) {
+            std::cout << "Key pressed: " << kbhs->vkCode << std::endl;
+        } else if (wparam == WM_KEYUP || wparam == WM_SYSKEYUP) {
+            std::cout << "Key released: " << kbhs->vkCode << std::endl;
+        }
+    }
+    return CallNextHookEx(nullptr, nCode, wparam, lparam);
+}
+
+LRESULT CALLBACK SRDWindowsPlatform::mouse_proc(int nCode, WPARAM wparam, LPARAM lparam) {
+    if (nCode >= 0) {
+        MSLLHOOKSTRUCT* mhs = (MSLLHOOKSTRUCT*)lparam;
+        
+        switch (wparam) {
+            case WM_LBUTTONDOWN:
+                std::cout << "Left mouse button down at (" << mhs->pt.x << ", " << mhs->pt.y << ")" << std::endl;
+                break;
+                
+            case WM_LBUTTONUP:
+                std::cout << "Left mouse button up at (" << mhs->pt.x << ", " << mhs->pt.y << ")" << std::endl;
+                break;
+                
+            case WM_RBUTTONDOWN:
+                std::cout << "Right mouse button down at (" << mhs->pt.x << ", " << mhs->pt.y << ")" << std::endl;
+                break;
+                
+            case WM_RBUTTONUP:
+                std::cout << "Right mouse button up at (" << mhs->pt.x << ", " << mhs->pt.y << ")" << std::endl;
+                break;
+                
+            case WM_MOUSEMOVE:
+                // Handle mouse movement
+                break;
+        }
+    }
+    return CallNextHookEx(nullptr, nCode, wparam, lparam);
+}
+
+void SRDWindowsPlatform::convert_win32_message(UINT msg, WPARAM wparam, LPARAM lparam, std::vector<Event>& events) {
+    Event event;
+    
+    switch (msg) {
+        case WM_CREATE:
+            event.type = EventType::SRDWindowCreated;
+            break;
+        case WM_DESTROY:
+            event.type = EventType::SRDWindowDestroyed;
+            break;
+        case WM_MOVE:
+            event.type = EventType::SRDWindowMoved;
+            break;
+        case WM_SIZE:
+            event.type = EventType::SRDWindowResized;
+            break;
+        case WM_SETFOCUS:
+            event.type = EventType::SRDWindowFocused;
+            break;
+        case WM_KILLFOCUS:
+            event.type = EventType::SRDWindowUnfocused;
+            break;
+        case WM_KEYDOWN:
+            event.type = EventType::KeyPress;
+            break;
+        case WM_KEYUP:
+            event.type = EventType::KeyRelease;
+            break;
+        case WM_LBUTTONDOWN:
+        case WM_RBUTTONDOWN:
+        case WM_MBUTTONDOWN:
+            event.type = EventType::MouseButtonPress;
+            break;
+        case WM_LBUTTONUP:
+        case WM_RBUTTONUP:
+        case WM_MBUTTONUP:
+            event.type = EventType::MouseButtonRelease;
+            break;
+        case WM_MOUSEMOVE:
+            event.type = EventType::MouseMotion;
+            break;
+        default:
+            return; // Skip unknown messages
+    }
+    
+    event.data = nullptr;
+    event.data_size = 0;
+    events.push_back(event);
+}
+
+bool SRDWindowsPlatform::poll_events(std::vector<Event>& events) {
+    if (!initialized_) return false;
+    
+    events.clear();
+    
+    // Process SRDWindows messages
+    MSG msg;
+    while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+        
+        // Convert SRDWindows message to SRDWM event
+        convert_win32_message(msg.message, msg.wParam, msg.lParam, events);
+    }
+    
+    return !events.empty();
+}
+
+void SRDWindowsPlatform::process_event(const Event& event) {
+    // TODO: Implement event processing
+}
+
+std::unique_ptr<SRDWindow> SRDWindowsPlatform::create_window(const std::string& title, int x, int y, int width, int height) {
+    // Convert title to wide string
+    int title_len = MultiByteToWideChar(CP_UTF8, 0, title.c_str(), -1, nullptr, 0);
+    std::wstring wtitle(title_len, 0);
+    MultiByteToWideChar(CP_UTF8, 0, title.c_str(), -1, &wtitle[0], title_len);
+    
+    // Create window
+    HWND hwnd = CreateSRDWindowEx(
+        WS_EX_OVERLAPPEDWINDOW,
+        L"SRDWM_SRDWindow",
+        wtitle.c_str(),
+        WS_OVERLAPPEDWINDOW,
+        x, y, width, height,
+        nullptr, nullptr, h_instance_, nullptr
+    );
+    
+    if (!hwnd) {
+        std::cerr << "Failed to create SRDWindows window" << std::endl;
+        return nullptr;
+    }
+    
+    // Create SRDWM window object
+    auto window = std::make_unique<SRDWindow>();
+    // TODO: Set window properties
+    
+    // Store window mapping
+    window_map_[hwnd] = window.get();
+    
+    std::cout << "Created SRDWindows window: " << hwnd << " (" << title << ")" << std::endl;
+    return window;
+}
+
+void SRDWindowsPlatform::destroy_window(SRDWindow* window) {
+    // Find window handle
+    for (auto& pair : window_map_) {
+        if (pair.second == window) {
+            DestroySRDWindow(pair.first);
+            window_map_.erase(pair.first);
+            break;
+        }
+    }
+}
+
+void SRDWindowsPlatform::set_window_position(SRDWindow* window, int x, int y) {
+    // Find window handle
+    for (auto& pair : window_map_) {
+        if (pair.second == window) {
+            SetSRDWindowPos(pair.first, nullptr, x, y, 0, 0, 
+                        SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
+            break;
+        }
+    }
+}
+
+void SRDWindowsPlatform::set_window_size(SRDWindow* window, int width, int height) {
+    // Find window handle
+    for (auto& pair : window_map_) {
+        if (pair.second == window) {
+            SetSRDWindowPos(pair.first, nullptr, 0, 0, width, height, 
+                        SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
+            break;
+        }
+    }
+}
+
+void SRDWindowsPlatform::set_window_title(SRDWindow* window, const std::string& title) {
+    // Find window handle
+    for (auto& pair : window_map_) {
+        if (pair.second == window) {
+            // Convert title to wide string
+            int title_len = MultiByteToWideChar(CP_UTF8, 0, title.c_str(), -1, nullptr, 0);
+            std::wstring wtitle(title_len, 0);
+            MultiByteToWideChar(CP_UTF8, 0, title.c_str(), -1, &wtitle[0], title_len);
+            
+            SetSRDWindowText(pair.first, wtitle.c_str());
+            break;
+        }
+    }
+}
+
+void SRDWindowsPlatform::focus_window(SRDWindow* window) {
+    // Find window handle
+    for (auto& pair : window_map_) {
+        if (pair.second == window) {
+            SetForegroundSRDWindow(pair.first);
+            SetFocus(pair.first);
+            break;
+        }
+    }
+}
+
+void SRDWindowsPlatform::minimize_window(SRDWindow* window) {
+    // Find window handle
+    for (auto& pair : window_map_) {
+        if (pair.second == window) {
+            ShowSRDWindow(pair.first, SW_MINIMIZE);
+            break;
+        }
+    }
+}
+
+void SRDWindowsPlatform::maximize_window(SRDWindow* window) {
+    // Find window handle
+    for (auto& pair : window_map_) {
+        if (pair.second == window) {
+            ShowSRDWindow(pair.first, SW_MAXIMIZE);
+            break;
+        }
+    }
+}
+
+void SRDWindowsPlatform::close_window(SRDWindow* window) {
+    // Find window handle
+    for (auto& pair : window_map_) {
+        if (pair.second == window) {
+            PostMessage(pair.first, WM_CLOSE, 0, 0);
+            break;
+        }
+    }
+}
+
+std::vector<Monitor> SRDWindowsPlatform::get_monitors() {
+    std::vector<Monitor> monitors;
+    
+    // Enumerate monitors using EnumDisplayMonitors
+    EnumDisplayMonitors(nullptr, nullptr, 
+        [](HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) -> BOOL {
+            auto* monitors = reinterpret_cast<std::vector<Monitor>*>(dwData);
+            
+            MONITORINFOEX monitorInfo;
+            monitorInfo.cbSize = sizeof(MONITORINFOEX);
+            GetMonitorInfo(hMonitor, &monitorInfo);
+            
+            Monitor monitor;
+            monitor.id = reinterpret_cast<int>(hMonitor);
+            monitor.name = std::string(monitorInfo.szDevice);
+            monitor.x = monitorInfo.rcMonitor.left;
+            monitor.y = monitorInfo.rcMonitor.top;
+            monitor.width = monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left;
+            monitor.height = monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top;
+            monitor.refresh_rate = 60; // TODO: Get actual refresh rate
+            
+            monitors->push_back(monitor);
+            
+            return TRUE;
+        }, reinterpret_cast<LPARAM>(&monitors));
+    
+    return monitors;
+}
+
+Monitor SRDWindowsPlatform::get_primary_monitor() {
+    auto monitors = get_monitors();
+    if (!monitors.empty()) {
+        return monitors[0];
+    }
+    
+    // Fallback to primary display
+    Monitor monitor;
+    monitor.id = 0;
+    monitor.name = "Primary Display";
+    monitor.x = 0;
+    monitor.y = 0;
+    monitor.width = GetSystemMetrics(SM_CXSCREEN);
+    monitor.height = GetSystemMetrics(SM_CYSCREEN);
+    monitor.refresh_rate = 60;
+    
+    return monitor;
+}
+
+void SRDWindowsPlatform::grab_keyboard() {
+    // TODO: Implement keyboard grabbing
+    std::cout << "Keyboard grabbing setup" << std::endl;
+}
+
+void SRDWindowsPlatform::ungrab_keyboard() {
+    // TODO: Implement keyboard ungrab
+    std::cout << "Keyboard ungrab" << std::endl;
+}
+
+void SRDWindowsPlatform::grab_pointer() {
+    // TODO: Implement pointer grabbing
+    std::cout << "Pointer grabbing setup" << std::endl;
+}
+
+void SRDWindowsPlatform::ungrab_pointer() {
+    // TODO: Implement pointer ungrab
+    std::cout << "Pointer ungrab" << std::endl;
+}
+
+void SRDWindowsPlatform::convert_windows_message_to_event(const MSG& msg, std::vector<Event>& events) {
+    // TODO: Convert SRDWindows messages to SRDWM events
+    switch (msg.message) {
+        case WM_KEYDOWN:
+        case WM_SYSKEYDOWN:
+            // Convert to key press event
+            break;
+            
+        case WM_KEYUP:
+        case WM_SYSKEYUP:
+            // Convert to key release event
+            break;
+            
+        case WM_LBUTTONDOWN:
+        case WM_RBUTTONDOWN:
+        case WM_MBUTTONDOWN:
+            // Convert to button press event
+            break;
+            
+        case WM_LBUTTONUP:
+        case WM_RBUTTONUP:
+        case WM_MBUTTONUP:
+            // Convert to button release event
+            break;
+            
+        case WM_MOUSEMOVE:
+            // Convert to mouse motion event
+            break;
+            
+        case WM_SIZE:
+            // Convert to window resize event
+            break;
+            
+        case WM_MOVE:
+            // Convert to window move event
+            break;
+    }
+}
+
+void SRDWindowsPlatform::handle_global_keyboard(WPARAM wparam, KBDLLHOOKSTRUCT* kbhs) {
+    // TODO: Implement global keyboard handling
+}
+
+void SRDWindowsPlatform::handle_global_mouse(WPARAM wparam, MSLLHOOKSTRUCT* mhs) {
+    // TODO: Implement global mouse handling
+}
+
+
diff --git a/src/platform/windows_platform.h b/src/platform/windows_platform.h
new file mode 100644
index 0000000..70b7d54
--- /dev/null
+++ b/src/platform/windows_platform.h
@@ -0,0 +1,140 @@
+#ifndef SRDWM_WINDOWS_PLATFORM_H
+#define SRDWM_WINDOWS_PLATFORM_H
+
+#include "platform.h"
+#include <windows.h>
+#include <memory>
+#include <string>
+#include <map>
+
+class SRDWindowsPlatform : public Platform {
+public:
+    SRDWindowsPlatform();
+    ~SRDWindowsPlatform() override;
+
+    // Platform interface implementation
+    bool initialize() override;
+    void shutdown() override;
+    
+    bool poll_events(std::vector<Event>& events) override;
+    void process_event(const Event& event) override;
+    
+    std::unique_ptr<SRDWindow> create_window(const std::string& title, int x, int y, int width, int height) override;
+    void destroy_window(SRDWindow* window) override;
+    void set_window_position(SRDWindow* window, int x, int y) override;
+    void set_window_size(SRDWindow* window, int width, int height) override;
+    void set_window_title(SRDWindow* window, const std::string& title) override;
+    void focus_window(SRDWindow* window) override;
+    void minimize_window(SRDWindow* window) override;
+    void maximize_window(SRDWindow* window) override;
+    void close_window(SRDWindow* window) override;
+    
+    std::vector<Monitor> get_monitors() override;
+    Monitor get_primary_monitor() override;
+    
+    void grab_keyboard() override;
+    void ungrab_keyboard() override;
+    void grab_pointer() override;
+    void ungrab_pointer() override;
+    
+    // SRDWindow decorations (SRDWindows implementation)
+    void set_window_decorations(SRDWindow* window, bool enabled) override;
+    void set_window_border_color(SRDWindow* window, int r, int g, int b) override;
+    void set_window_border_width(SRDWindow* window, int width) override;
+    bool get_window_decorations(SRDWindow* window) const override;
+
+    // Windows-specific features
+    void enable_dwm_composition(bool enabled);
+    void set_dwm_window_attribute(HWND hwnd, DWORD attribute, DWORD value);
+    void set_dwm_window_thumbnail(HWND hwnd, HWND thumbnail_hwnd);
+    void set_dwm_window_peek(HWND hwnd, bool enabled);
+    
+    // Virtual Desktop support (Windows 10+)
+    void create_virtual_desktop();
+    void remove_virtual_desktop(int desktop_id);
+    void switch_to_virtual_desktop(int desktop_id);
+    int get_current_virtual_desktop() const;
+    std::vector<int> get_virtual_desktops() const;
+    void move_window_to_desktop(SRDWindow* window, int desktop_id);
+    
+    // Taskbar integration
+    void set_taskbar_visible(bool visible);
+    void set_taskbar_position(int position); // 0=bottom, 1=top, 2=left, 3=right
+    void set_taskbar_auto_hide(bool enabled);
+    void update_taskbar_preview(HWND hwnd, const std::string& title);
+    
+    // Aero effects
+    void enable_aero_effects(bool enabled);
+    void set_window_transparency(HWND hwnd, BYTE alpha);
+    void set_window_blur(HWND hwnd, bool enabled);
+    void set_window_shadow(HWND hwnd, bool enabled);
+    
+    // System tray integration
+    void add_system_tray_icon(const std::string& tooltip, HICON icon);
+    void remove_system_tray_icon();
+    void show_system_tray_menu(HMENU menu);
+
+    std::string get_platform_name() const override;
+    bool is_wayland() const override;
+    bool is_x11() const override;
+    bool is_windows() const override;
+    bool is_macos() const override;
+
+private:
+    bool initialized_;
+    HINSTANCE h_instance_;
+    std::map<HWND, SRDWindow*> window_map_;
+    std::vector<Monitor> monitors_;
+    
+    // Decoration state
+    bool decorations_enabled_;
+    int border_width_;
+    COLORREF border_color_;
+    COLORREF focused_border_color_;
+    
+    // Windows-specific state
+    bool dwm_enabled_;
+    bool aero_enabled_;
+    bool taskbar_visible_;
+    bool taskbar_auto_hide_;
+    int taskbar_position_;
+    int current_virtual_desktop_;
+    std::vector<int> virtual_desktops_;
+    NOTIFYICONDATA system_tray_icon_;
+    
+    // SRDWindow class registration
+    bool register_window_class();
+    void unregister_window_class();
+    
+    // SRDWindow procedure
+    static LRESULT CALLBACK window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
+    
+    // Event conversion
+    void convert_win32_message(UINT msg, WPARAM wparam, LPARAM lparam, std::vector<Event>& events);
+    
+    // Monitor enumeration
+    static BOOL CALLBACK enum_monitor_proc(HMONITOR hmonitor, HDC hdc_monitor, LPRECT lprc_monitor, LPARAM dw_data);
+    
+    // Utility methods
+    void update_monitors();
+    SRDWindow* find_window_by_hwnd(HWND hwnd);
+    
+    // Decoration methods
+    void apply_dwm_border_color(HWND hwnd, int r, int g, int b);
+    void remove_dwm_border_color(HWND hwnd);
+    
+    // Virtual Desktop methods
+    void initialize_virtual_desktops();
+    void cleanup_virtual_desktops();
+    
+    // DWM methods
+    bool initialize_dwm();
+    void cleanup_dwm();
+    
+    // Taskbar methods
+    void initialize_taskbar();
+    void update_taskbar();
+};
+
+#endif // SRDWM_WINDOWS_PLATFORM_H
+
diff --git a/src/platform/x11_platform.cc b/src/platform/x11_platform.cc
new file mode 100644
index 0000000..0d25369
--- /dev/null
+++ b/src/platform/x11_platform.cc
@@ -0,0 +1,1005 @@
+#include "x11_platform.h"
+#include <iostream>
+#include <cstring>
+
+X11Platform::X11Platform() {
+    std::cout << "X11Platform: Constructor called" << std::endl;
+}
+
+X11Platform::~X11Platform() {
+    std::cout << "X11Platform: Destructor called" << std::endl;
+}
+
+bool X11Platform::initialize() {
+    std::cout << "X11Platform: Initializing X11 backend..." << std::endl;
+    
+    // Open X11 display
+    display_ = XOpenDisplay(nullptr);
+    if (!display_) {
+        std::cerr << "Failed to open X11 display" << std::endl;
+        return false;
+    }
+    
+    // Get root window
+    root_ = DefaultRootWindow(display_);
+    
+    // Check for other window manager
+    if (!check_for_other_wm()) {
+        std::cerr << "Another window manager is already running" << std::endl;
+        return false;
+    }
+    
+    // Setup X11 environment
+    if (!setup_x11_environment()) {
+        std::cerr << "Failed to setup X11 environment" << std::endl;
+        return false;
+    }
+    
+    // Setup event masks
+    if (!setup_event_masks()) {
+        std::cerr << "Failed to setup event masks" << std::endl;
+        return false;
+    }
+    
+    // Setup atoms
+    setup_atoms();
+    
+    // Setup extensions
+    setup_extensions();
+    
+    // Initialize decoration state
+    decorations_enabled_ = true;
+    border_width_ = 2;
+    border_color_ = 0x2e3440; // Default border color
+    focused_border_color_ = 0x88c0d0; // Default focused border color
+    
+    std::cout << "X11Platform: Initialized successfully" << std::endl;
+    return true;
+}
+
+void X11Platform::shutdown() {
+    std::cout << "X11Platform: Shutting down..." << std::endl;
+    
+    // Clean up windows
+    for (auto& pair : window_map_) {
+        if (pair.second) {
+            destroy_window(pair.second);
+        }
+    }
+    window_map_.clear();
+    frame_window_map_.clear();
+    
+    // Close X11 display
+    if (display_) {
+        XCloseDisplay(display_);
+        display_ = nullptr;
+    }
+    
+    std::cout << "X11Platform: Shutdown complete" << std::endl;
+}
+
+bool X11Platform::poll_events(std::vector<Event>& events) {
+    if (!display_) return false;
+    
+    events.clear();
+    
+    // Check for pending events
+    if (XPending(display_) > 0) {
+        XEvent xevent;
+        XNextEvent(display_, &xevent);
+        
+        // Handle the X11 event
+        handle_x11_event(xevent);
+        
+        // Convert to SRDWM events (simplified for now)
+        Event event;
+        event.type = EventType::WindowCreated; // Placeholder
+        event.data = nullptr;
+        event.data_size = 0;
+        events.push_back(event);
+        
+        return true;
+    }
+    
+    return false;
+}
+
+void X11Platform::process_event(const Event& event) {
+    std::cout << "X11Platform: Process event called" << std::endl;
+}
+
+std::unique_ptr<SRDWindow> X11Platform::create_window(const std::string& title, int x, int y, int width, int height) {
+    std::cout << "X11Platform: Create window called" << std::endl;
+    // TODO: Implement actual window creation when headers are available
+    return nullptr;
+}
+
+void X11Platform::destroy_window(SRDWindow* window) {
+    std::cout << "X11Platform: Destroy window called" << std::endl;
+}
+
+void X11Platform::set_window_position(SRDWindow* window, int x, int y) {
+    std::cout << "X11Platform: Set window position to (" << x << "," << y << ")" << std::endl;
+    if (!window || !display_) return;
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    XMoveWindow(display_, to_x11_window(x11_window), x, y);
+    XFlush(display_);
+}
+
+void X11Platform::set_window_size(SRDWindow* window, int width, int height) {
+    std::cout << "X11Platform: Set window size to (" << width << "x" << height << ")" << std::endl;
+    if (!window || !display_) return;
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    XResizeWindow(display_, to_x11_window(x11_window), static_cast<unsigned int>(width), static_cast<unsigned int>(height));
+    XFlush(display_);
+}
+
+void X11Platform::set_window_title(SRDWindow* window, const std::string& title) {
+    std::cout << "X11Platform: Set window title to '" << title << "'" << std::endl;
+    if (!window || !display_) return;
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    XStoreName(display_, to_x11_window(x11_window), title.c_str());
+    XFlush(display_);
+}
+
+void X11Platform::focus_window(SRDWindow* window) {
+    std::cout << "X11Platform: Focus window" << std::endl;
+    if (!window || !display_) return;
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    XSetInputFocus(display_, to_x11_window(x11_window), RevertToParent, CurrentTime);
+    XFlush(display_);
+}
+
+void X11Platform::minimize_window(SRDWindow* window) {
+    std::cout << "X11Platform: Minimize window called" << std::endl;
+}
+
+void X11Platform::maximize_window(SRDWindow* window) {
+    std::cout << "X11Platform: Maximize window called" << std::endl;
+}
+
+void X11Platform::close_window(SRDWindow* window) {
+    std::cout << "X11Platform: Close window" << std::endl;
+    if (!window || !display_) return;
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    Atom wm_delete = XInternAtom(display_, "WM_DELETE_WINDOW", False);
+    if (wm_delete != None) {
+        XEvent ev{};
+        ev.xclient.type = ClientMessage;
+        ev.xclient.message_type = XInternAtom(display_, "WM_PROTOCOLS", False);
+        ev.xclient.display = display_;
+        ev.xclient.window = to_x11_window(x11_window);
+        ev.xclient.format = 32;
+        ev.xclient.data.l[0] = wm_delete;
+        ev.xclient.data.l[1] = CurrentTime;
+        XSendEvent(display_, to_x11_window(x11_window), False, NoEventMask, &ev);
+        XFlush(display_);
+    } else {
+        XDestroyWindow(display_, to_x11_window(x11_window));
+        XFlush(display_);
+    }
+}
+
+// EWMH (Extended Window Manager Hints) support implementation
+void X11Platform::set_ewmh_supported(bool supported) {
+    ewmh_supported_ = supported;
+    if (supported) {
+        setup_ewmh();
+    }
+    std::cout << "X11Platform: EWMH support " << (supported ? "enabled" : "disabled") << std::endl;
+}
+
+void X11Platform::set_window_type(SRDWindow* window, const std::string& type) {
+    if (!ewmh_supported_ || !window) return;
+    
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    Atom window_type_atom = None;
+    
+    if (type == "desktop") window_type_atom = _NET_WM_WINDOW_TYPE_DESKTOP_;
+    else if (type == "dock") window_type_atom = _NET_WM_WINDOW_TYPE_DOCK_;
+    else if (type == "toolbar") window_type_atom = _NET_WM_WINDOW_TYPE_TOOLBAR_;
+    else if (type == "menu") window_type_atom = _NET_WM_WINDOW_TYPE_MENU_;
+    else if (type == "utility") window_type_atom = _NET_WM_WINDOW_TYPE_UTILITY_;
+    else if (type == "splash") window_type_atom = _NET_WM_WINDOW_TYPE_SPLASH_;
+    else if (type == "dialog") window_type_atom = _NET_WM_WINDOW_TYPE_DIALOG_;
+    else if (type == "dropdown_menu") window_type_atom = _NET_WM_WINDOW_TYPE_DROPDOWN_MENU_;
+    else if (type == "popup_menu") window_type_atom = _NET_WM_WINDOW_TYPE_POPUP_MENU_;
+    else if (type == "tooltip") window_type_atom = _NET_WM_WINDOW_TYPE_TOOLTIP_;
+    else if (type == "notification") window_type_atom = _NET_WM_WINDOW_TYPE_NOTIFICATION_;
+    else if (type == "combo") window_type_atom = _NET_WM_WINDOW_TYPE_COMBO_;
+    else if (type == "dnd") window_type_atom = _NET_WM_WINDOW_TYPE_DND_;
+    else window_type_atom = _NET_WM_WINDOW_TYPE_NORMAL_;
+    
+    if (window_type_atom != None) {
+        XChangeProperty(display_, x11_window, _NET_WM_WINDOW_TYPE_, XA_ATOM, 32,
+                       PropModeReplace, (unsigned char*)&window_type_atom, 1);
+    }
+}
+
+void X11Platform::set_window_state(SRDWindow* window, const std::vector<std::string>& states) {
+    if (!ewmh_supported_ || !window) return;
+    
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    std::vector<Atom> state_atoms;
+    
+    for (const auto& state : states) {
+        Atom state_atom = None;
+        if (state == "maximized_vert") state_atom = _NET_WM_STATE_MAXIMIZED_VERT_;
+        else if (state == "maximized_horz") state_atom = _NET_WM_STATE_MAXIMIZED_HORZ_;
+        else if (state == "fullscreen") state_atom = _NET_WM_STATE_FULLSCREEN_;
+        else if (state == "above") state_atom = _NET_WM_STATE_ABOVE_;
+        else if (state == "below") state_atom = _NET_WM_STATE_BELOW_;
+        
+        if (state_atom != None) {
+            state_atoms.push_back(state_atom);
+        }
+    }
+    
+    if (!state_atoms.empty()) {
+        XChangeProperty(display_, x11_window, _NET_WM_STATE_, XA_ATOM, 32,
+                       PropModeReplace, (unsigned char*)state_atoms.data(), state_atoms.size());
+    }
+}
+
+void X11Platform::set_window_strut(SRDWindow* window, int left, int right, int top, int bottom) {
+    if (!ewmh_supported_ || !window) return;
+    
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    long strut[12] = {left, right, top, bottom, 0, 0, 0, 0, 0, 0, 0, 0};
+    
+    XChangeProperty(display_, x11_window, XInternAtom(display_, "_NET_WM_STRUT_PARTIAL", False),
+                   XA_CARDINAL, 32, PropModeReplace, (unsigned char*)strut, 12);
+}
+
+// Virtual Desktop support implementation
+void X11Platform::create_virtual_desktop(const std::string& name) {
+    if (!ewmh_supported_) return;
+    
+    int desktop_id = virtual_desktops_.size();
+    virtual_desktops_.push_back(desktop_id);
+    
+    // Update EWMH desktop info
+    update_ewmh_desktop_info();
+    
+    std::cout << "X11Platform: Created virtual desktop " << desktop_id << " (" << name << ")" << std::endl;
+}
+
+void X11Platform::remove_virtual_desktop(int desktop_id) {
+    if (!ewmh_supported_) return;
+    
+    auto it = std::find(virtual_desktops_.begin(), virtual_desktops_.end(), desktop_id);
+    if (it != virtual_desktops_.end()) {
+        virtual_desktops_.erase(it);
+        
+        // If removing current desktop, switch to first available
+        if (desktop_id == current_virtual_desktop_ && !virtual_desktops_.empty()) {
+            switch_to_virtual_desktop(virtual_desktops_[0]);
+        }
+        
+        update_ewmh_desktop_info();
+        std::cout << "X11Platform: Removed virtual desktop " << desktop_id << std::endl;
+    }
+}
+
+void X11Platform::switch_to_virtual_desktop(int desktop_id) {
+    if (!ewmh_supported_) return;
+    
+    auto it = std::find(virtual_desktops_.begin(), virtual_desktops_.end(), desktop_id);
+    if (it != virtual_desktops_.end()) {
+        current_virtual_desktop_ = desktop_id;
+        
+        // Update EWMH current desktop
+        XChangeProperty(display_, root_, _NET_CURRENT_DESKTOP_, XA_CARDINAL, 32,
+                       PropModeReplace, (unsigned char*)&current_virtual_desktop_, 1);
+        
+        std::cout << "X11Platform: Switched to virtual desktop " << desktop_id << std::endl;
+    }
+}
+
+int X11Platform::get_current_virtual_desktop() const {
+    return current_virtual_desktop_;
+}
+
+std::vector<int> X11Platform::get_virtual_desktops() const {
+    return virtual_desktops_;
+}
+
+void X11Platform::move_window_to_desktop(SRDWindow* window, int desktop_id) {
+    if (!ewmh_supported_ || !window) return;
+    
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    XChangeProperty(display_, x11_window, _NET_WM_DESKTOP_, XA_CARDINAL, 32,
+                   PropModeReplace, (unsigned char*)&desktop_id, 1);
+    
+    std::cout << "X11Platform: Moved window " << window->getId() << " to desktop " << desktop_id << std::endl;
+}
+
+std::vector<Monitor> X11Platform::get_monitors() {
+    std::cout << "X11Platform: Get monitors called" << std::endl;
+    // Return a default monitor for now
+    return {Monitor{0, 0, 0, 1920, 1080}};
+}
+
+Monitor X11Platform::get_primary_monitor() {
+    std::cout << "X11Platform: Get primary monitor called" << std::endl;
+    return Monitor{0, 0, 0, 1920, 1080};
+}
+
+void X11Platform::grab_keyboard() {
+    std::cout << "X11Platform: Grab keyboard called" << std::endl;
+}
+
+void X11Platform::ungrab_keyboard() {
+    std::cout << "X11Platform: Ungrab keyboard called" << std::endl;
+}
+
+void X11Platform::grab_pointer() {
+    std::cout << "X11Platform: Grab pointer called" << std::endl;
+}
+
+void X11Platform::ungrab_pointer() {
+    std::cout << "X11Platform: Ungrab pointer called" << std::endl;
+}
+
+// Private method stubs removed - actual implementations exist below
+
+void X11Platform::setup_extensions() {
+    std::cout << "X11Platform: Setup extensions called" << std::endl;
+}
+
+bool X11Platform::check_for_other_wm() {
+    // Try to select SubstructureRedirectMask on root window
+    // If another WM is running, this will fail
+    XSelectInput(display_, root_, SubstructureRedirectMask);
+    XSync(display_, False);
+    
+    // Check if the selection was successful
+    XErrorHandler old_handler = XSetErrorHandler([](Display*, XErrorEvent*) -> int {
+        return 0; // Ignore errors
+    });
+    
+    XSync(display_, False);
+    XSetErrorHandler(old_handler);
+    
+    return true; // Simplified check
+}
+
+bool X11Platform::setup_x11_environment() {
+    std::cout << "X11Platform: Setting up X11 environment..." << std::endl;
+    
+    // Set up error handling
+    XSetErrorHandler([](Display*, XErrorEvent* e) -> int {
+        if (e->error_code == BadWindow ||
+            e->error_code == BadMatch ||
+            e->error_code == BadAccess) {
+            return 0; // Ignore common errors
+        }
+        std::cerr << "X11 error: " << e->error_code << std::endl;
+        return 0;
+    });
+    
+    return true;
+}
+
+bool X11Platform::setup_event_masks() {
+    std::cout << "X11Platform: Setting up event masks..." << std::endl;
+    
+    // Set up root window event mask
+    long event_mask = SubstructureRedirectMask | SubstructureNotifyMask |
+                     StructureNotifyMask | PropertyChangeMask |
+                     ButtonPressMask | ButtonReleaseMask |
+                     KeyPressMask | KeyReleaseMask |
+                     PointerMotionMask | EnterWindowMask | LeaveWindowMask;
+    
+    XSelectInput(display_, root_, event_mask);
+    
+    return true;
+}
+
+void X11Platform::setup_atoms() {
+    std::cout << "X11Platform: Setting up atoms..." << std::endl;
+    
+    // TODO: Implement atom setup for EWMH/ICCCM
+    // This would involve creating atoms for window manager protocols
+}
+
+void X11Platform::handle_x11_event(XEvent& event) {
+    std::cout << "X11Platform: Handle X11 event called" << std::endl;
+    
+    switch (event.type) {
+        case MapRequest:
+            handle_map_request(event.xmaprequest);
+            break;
+        case ConfigureRequest:
+            handle_configure_request(event.xconfigurerequest);
+            break;
+        case DestroyNotify:
+            handle_destroy_notify(event.xdestroywindow);
+            break;
+        case UnmapNotify:
+            handle_unmap_notify(event.xunmap);
+            break;
+        case KeyPress:
+            handle_key_press(event.xkey);
+            break;
+        case ButtonPress:
+            handle_button_press(event.xbutton);
+            break;
+        case MotionNotify:
+            handle_motion_notify(event.xmotion);
+            break;
+        default:
+            break;
+    }
+}
+
+void X11Platform::handle_map_request(XMapRequestEvent& event) {
+    std::cout << "X11Platform: Map request for window " << static_cast<unsigned long>(event.window) << std::endl;
+    
+    // Create a SRDWindow object for this X11 window
+    auto window = std::make_unique<SRDWindow>(static_cast<int>(static_cast<unsigned long>(event.window)), "X11 Window");
+    
+    // Add to window map
+    window_map_[from_x11_window(event.window)] = window.get();
+    window.release();
+    
+    // Map the window
+    XMapWindow(display_, event.window);
+    
+    // Apply decorations if enabled
+    if (decorations_enabled_) {
+        create_frame_window(window_map_[from_x11_window(event.window)]);
+    }
+}
+
+void X11Platform::handle_configure_request(XConfigureRequestEvent& event) {
+    std::cout << "X11Platform: Configure request for window " << static_cast<unsigned long>(event.window) << std::endl;
+    
+    XWindowChanges changes;
+    changes.x = event.x;
+    changes.y = event.y;
+    changes.width = event.width;
+    changes.height = event.height;
+    changes.border_width = event.border_width;
+    changes.sibling = static_cast<::Window>(event.above);
+    changes.stack_mode = event.detail;
+    
+    XConfigureWindow(display_, event.window, event.value_mask, &changes);
+}
+
+void X11Platform::handle_destroy_notify(XDestroyWindowEvent& event) {
+    std::cout << "X11Platform: Destroy notify for window " << static_cast<unsigned long>(event.window) << std::endl;
+    
+    auto it = window_map_.find(from_x11_window(event.window));
+    if (it != window_map_.end()) {
+        destroy_window(it->second);
+        window_map_.erase(it);
+    }
+}
+
+void X11Platform::handle_unmap_notify(XUnmapEvent& event) {
+    std::cout << "X11Platform: Unmap notify for window " << static_cast<unsigned long>(event.window) << std::endl;
+    
+    // Handle window unmapping
+}
+
+void X11Platform::handle_key_press(XKeyEvent& event) {
+    std::cout << "X11Platform: Key press event" << std::endl;
+    
+    // Convert X11 key event to SRDWM event
+    // TODO: Implement key event conversion
+}
+
+void X11Platform::handle_button_press(XButtonEvent& event) {
+    std::cout << "X11Platform: Button press event" << std::endl;
+    
+    // Convert X11 button event to SRDWM event
+    // TODO: Implement button event conversion
+}
+
+void X11Platform::handle_motion_notify(XMotionEvent& event) {
+    std::cout << "X11Platform: Motion notify event" << std::endl;
+    
+    // Convert X11 motion event to SRDWM event
+    // TODO: Implement motion event conversion
+}
+
+// Window decoration implementations
+void X11Platform::set_window_decorations(SRDWindow* window, bool enabled) {
+    std::cout << "X11Platform: Set window decorations " << (enabled ? "enabled" : "disabled") << std::endl;
+    
+    if (!window || !display_) return;
+    
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    
+    if (enabled) {
+        create_frame_window(window);
+    } else {
+        destroy_frame_window(window);
+    }
+    
+    decorations_enabled_ = enabled;
+}
+
+void X11Platform::set_window_border_color(SRDWindow* window, int r, int g, int b) {
+    std::cout << "X11Platform: Set border color RGB(" << r << "," << g << "," << b << ")" << std::endl;
+    
+    if (!window || !display_) return;
+    
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    unsigned long color = (r << 16) | (g << 8) | b;
+    
+    XSetWindowBorder(display_, to_x11_window(x11_window), color);
+    
+    // Update decoration state
+    if (window == get_focused_window()) {
+        focused_border_color_ = color;
+    } else {
+        border_color_ = color;
+    }
+}
+
+void X11Platform::set_window_border_width(SRDWindow* window, int width) {
+    std::cout << "X11Platform: Set border width " << width << std::endl;
+    
+    if (!window || !display_) return;
+    
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    XSetWindowBorderWidth(display_, to_x11_window(x11_window), width);
+    
+    border_width_ = width;
+}
+
+bool X11Platform::get_window_decorations(SRDWindow* window) const {
+    if (!window) return false;
+    
+    // Check if window has a frame window
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    auto it = frame_window_map_.find(x11_window);
+    
+    return it != frame_window_map_.end();
+}
+
+void X11Platform::create_frame_window(SRDWindow* window) {
+    std::cout << "X11Platform: Create frame window for window " << window->getId() << std::endl;
+    
+    if (!window || !display_) return;
+    
+    X11Window client_window = static_cast<X11Window>(window->getId());
+    
+    // Check if frame already exists
+    if (frame_window_map_.find(client_window) != frame_window_map_.end()) {
+        return;
+    }
+    
+    // Get client window attributes
+    XWindowAttributes attr;
+    attr.x = 0;
+    attr.y = 0;
+    attr.width = 0;
+    attr.height = 0;
+    attr.border_width = 0;
+    attr.depth = 0;
+    attr.visual = nullptr;
+    attr.root = 0;
+    attr.c_class = 0;
+    attr.bit_gravity = 0;
+    attr.win_gravity = 0;
+    attr.backing_store = 0;
+    attr.backing_planes = 0;
+    attr.backing_pixel = 0;
+    attr.save_under = 0;
+    attr.colormap = 0;
+    attr.map_installed = 0;
+    attr.map_state = 0;
+    attr.all_event_masks = 0;
+    attr.your_event_mask = 0;
+    attr.do_not_propagate_mask = 0;
+    attr.override_redirect = 0;
+    if (XGetWindowAttributes(display_, to_x11_window(client_window), &attr) == 0) {
+        std::cerr << "Failed to get window attributes" << std::endl;
+        return;
+    }
+    
+    // Create frame window
+    X11Window frame_window = from_x11_window(XCreateSimpleWindow(
+        display_, to_x11_window(root_),
+        attr.x, attr.y,
+        attr.width + border_width_ * 2,
+        attr.height + border_width_ + 30, // Add titlebar height
+        border_width_,
+        border_color_,
+        0x000000 // Background color
+    ));
+    
+    // Set frame window properties
+    XSetWindowAttributes frame_attr;
+    frame_attr.event_mask = ButtonPressMask | ButtonReleaseMask | 
+                           PointerMotionMask | ExposureMask;
+    XChangeWindowAttributes(display_, to_x11_window(frame_window), CWEventMask, &frame_attr);
+    
+    // Reparent client window into frame
+    XReparentWindow(display_, to_x11_window(client_window), to_x11_window(frame_window), border_width_, 30);
+    
+    // Map frame window
+    XMapWindow(display_, to_x11_window(frame_window));
+    
+    // Store frame window mapping
+    frame_window_map_[client_window] = frame_window;
+    
+    // Draw titlebar
+    draw_titlebar(window);
+    
+    std::cout << "X11Platform: Frame window created successfully" << std::endl;
+}
+
+void X11Platform::destroy_frame_window(SRDWindow* window) {
+    std::cout << "X11Platform: Destroy frame window for window " << window->getId() << std::endl;
+    
+    if (!window || !display_) return;
+    
+    X11Window client_window = static_cast<X11Window>(window->getId());
+    
+    // Find frame window
+    auto it = frame_window_map_.find(client_window);
+    if (it == frame_window_map_.end()) {
+        return;
+    }
+    
+    X11Window frame_window = it->second;
+    
+    // Reparent client window back to root
+    XReparentWindow(display_, to_x11_window(client_window), to_x11_window(root_), 0, 0);
+    
+    // Destroy frame window
+    XDestroyWindow(display_, to_x11_window(frame_window));
+    
+    // Remove from mapping
+    frame_window_map_.erase(it);
+    
+    std::cout << "X11Platform: Frame window destroyed successfully" << std::endl;
+}
+
+void X11Platform::draw_titlebar(SRDWindow* window) {
+    std::cout << "X11Platform: Draw titlebar for window " << window->getId() << std::endl;
+    
+    if (!window || !display_) return;
+    
+    X11Window client_window = static_cast<X11Window>(window->getId());
+    
+    // Find frame window
+    auto it = frame_window_map_.find(client_window);
+    if (it == frame_window_map_.end()) {
+        return;
+    }
+    
+    X11Window frame_window = it->second;
+    
+    // Get window title
+    char* window_name = nullptr;
+    if (XFetchName(display_, to_x11_window(client_window), &window_name) && window_name) {
+        // Create GC for drawing
+        XGCValues gc_values;
+        gc_values.foreground = 0xFFFFFF; // White text
+        gc_values.background = 0x2E3440; // Dark background
+        gc_values.font = XLoadFont(display_, "fixed");
+        
+        GC gc = XCreateGC(display_, to_x11_window(frame_window), 
+                         GCForeground | GCBackground | GCFont, &gc_values);
+        
+        // Draw titlebar background
+        XSetForeground(display_, gc, 0x2E3440);
+        XFillRectangle(display_, to_x11_window(frame_window), gc, 0, 0, 800, 30); // Placeholder size
+        
+        // Draw title text
+        XSetForeground(display_, gc, 0xFFFFFF);
+        XDrawString(display_, to_x11_window(frame_window), gc, 10, 20, window_name, strlen(window_name));
+        
+        // Clean up
+        XFreeGC(display_, gc);
+        XFree(window_name);
+    }
+}
+
+void X11Platform::update_frame_geometry(SRDWindow* window) {
+    std::cout << "X11Platform: Update frame geometry" << std::endl;
+    
+    // TODO: Implement when X11 headers are available
+    // Update frame window geometry when client window changes
+}
+
+SRDWindow* X11Platform::get_focused_window() const {
+    if (!display_) return nullptr;
+    
+    typedef ::Window X11WindowType;
+    X11WindowType focused_window;
+    int revert_to;
+    XGetInputFocus(display_, &focused_window, &revert_to);
+    
+    auto it = window_map_.find(from_x11_window(focused_window));
+    if (it != window_map_.end()) {
+        return it->second;
+    }
+    
+    return nullptr;
+}
+
+// EWMH helper methods
+void X11Platform::setup_ewmh() {
+    if (!display_ || !ewmh_supported_) return;
+    
+    // Set EWMH supported atoms
+    Atom supported[] = {
+        _NET_WM_STATE_,
+        _NET_WM_STATE_MAXIMIZED_VERT_,
+        _NET_WM_STATE_MAXIMIZED_HORZ_,
+        _NET_WM_STATE_FULLSCREEN_,
+        _NET_WM_STATE_ABOVE_,
+        _NET_WM_STATE_BELOW_,
+        _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_,
+        _NET_WM_DESKTOP_,
+        _NET_NUMBER_OF_DESKTOPS_,
+        _NET_CURRENT_DESKTOP_,
+        _NET_DESKTOP_NAMES_
+    };
+    
+    XChangeProperty(display_, root_, XInternAtom(display_, "_NET_SUPPORTED", False),
+                   XA_ATOM, 32, PropModeReplace, (unsigned char*)supported, 
+                   sizeof(supported) / sizeof(supported[0]));
+    
+    // Set initial desktop info
+    update_ewmh_desktop_info();
+    
+    std::cout << "X11Platform: EWMH setup completed" << std::endl;
+}
+
+void X11Platform::update_ewmh_desktop_info() {
+    if (!display_ || !ewmh_supported_) return;
+    
+    // Set number of desktops
+    int num_desktops = virtual_desktops_.size();
+    XChangeProperty(display_, root_, _NET_NUMBER_OF_DESKTOPS_, XA_CARDINAL, 32,
+                   PropModeReplace, (unsigned char*)&num_desktops, 1);
+    
+    // Set current desktop
+    XChangeProperty(display_, root_, _NET_CURRENT_DESKTOP_, XA_CARDINAL, 32,
+                   PropModeReplace, (unsigned char*)&current_virtual_desktop_, 1);
+    
+    // Set desktop names (simplified - just use numbers for now)
+    std::vector<std::string> desktop_names;
+    for (int i = 0; i < num_desktops; ++i) {
+        desktop_names.push_back("Desktop " + std::to_string(i + 1));
+    }
+    
+    // Convert to X11 string format
+    std::string names_str;
+    for (const auto& name : desktop_names) {
+        names_str += name + '\0';
+    }
+    
+    XChangeProperty(display_, root_, _NET_DESKTOP_NAMES_, XA_STRING, 8,
+                   PropModeReplace, (unsigned char*)names_str.c_str(), names_str.length());
+}
+
+// Linux/X11-specific features implementation
+void X11Platform::enable_compositor(bool enabled) {
+    compositor_enabled_ = enabled;
+    
+    if (enabled) {
+        // Try to enable compositor effects
+        // This is a simplified implementation - real compositors have more complex setup
+        std::cout << "X11Platform: Compositor effects enabled" << std::endl;
+    } else {
+        std::cout << "X11Platform: Compositor effects disabled" << std::endl;
+    }
+}
+
+void X11Platform::set_window_opacity(SRDWindow* window, unsigned char opacity) {
+    if (!window) return;
+    
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    
+    // Set window opacity using _NET_WM_WINDOW_OPACITY atom
+    Atom opacity_atom = XInternAtom(display_, "_NET_WM_WINDOW_OPACITY", False);
+    if (opacity_atom != None) {
+        unsigned long opacity_value = (opacity << 24) | (opacity << 16) | (opacity << 8) | opacity;
+        XChangeProperty(display_, x11_window, opacity_atom, XA_CARDINAL, 32,
+                       PropModeReplace, (unsigned char*)&opacity_value, 1);
+    }
+    
+    std::cout << "X11Platform: Set window " << window->getId() << " opacity to " << (int)opacity << std::endl;
+}
+
+void X11Platform::set_window_blur(SRDWindow* window, bool enabled) {
+    if (!window) return;
+    
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    
+    // Set window blur using _NET_WM_WINDOW_BLUR atom (if supported)
+    Atom blur_atom = XInternAtom(display_, "_NET_WM_WINDOW_BLUR", False);
+    if (blur_atom != None) {
+        unsigned long blur_value = enabled ? 1 : 0;
+        XChangeProperty(display_, x11_window, blur_atom, XA_CARDINAL, 32,
+                       PropModeReplace, (unsigned char*)&blur_value, 1);
+    }
+    
+    std::cout << "X11Platform: Set window " << window->getId() << " blur " << (enabled ? "enabled" : "disabled") << std::endl;
+}
+
+void X11Platform::set_window_shadow(SRDWindow* window, bool enabled) {
+    if (!window) return;
+    
+    X11Window x11_window = static_cast<X11Window>(window->getId());
+    
+    // Set window shadow using _NET_WM_WINDOW_SHADOW atom (if supported)
+    Atom shadow_atom = XInternAtom(display_, "_NET_WM_WINDOW_SHADOW", False);
+    if (shadow_atom != None) {
+        unsigned long shadow_value = enabled ? 1 : 0;
+        XChangeProperty(display_, x11_window, shadow_atom, XA_CARDINAL, 32,
+                       PropModeReplace, (unsigned char*)&shadow_value, 1);
+    }
+    
+    std::cout << "X11Platform: Set window " << window->getId() << " shadow " << (enabled ? "enabled" : "disabled") << std::endl;
+}
+
+// RandR (Resize and Rotate) support implementation
+void X11Platform::enable_randr(bool enabled) {
+    randr_enabled_ = enabled;
+    
+    if (enabled) {
+        initialize_randr();
+    } else {
+        cleanup_randr();
+    }
+    
+    std::cout << "X11Platform: RandR support " << (enabled ? "enabled" : "disabled") << std::endl;
+}
+
+void X11Platform::set_monitor_rotation(int monitor_id, int rotation) {
+    if (!randr_enabled_) return;
+    
+    // Rotation values: 0=0°, 1=90°, 2=180°, 3=270°
+    if (rotation < 0 || rotation > 3) return;
+    
+    // TODO: Implement actual RandR rotation
+    std::cout << "X11Platform: Set monitor " << monitor_id << " rotation to " << (rotation * 90) << "°" << std::endl;
+}
+
+void X11Platform::set_monitor_refresh_rate(int monitor_id, int refresh_rate) {
+    if (!randr_enabled_) return;
+    
+    if (refresh_rate < 30 || refresh_rate > 240) return;
+    
+    // TODO: Implement actual RandR refresh rate setting
+    std::cout << "X11Platform: Set monitor " << monitor_id << " refresh rate to " << refresh_rate << " Hz" << std::endl;
+}
+
+void X11Platform::set_monitor_scale(int monitor_id, float scale) {
+    if (!randr_enabled_) return;
+    
+    if (scale < 0.5f || scale > 3.0f) return;
+    
+    // TODO: Implement actual RandR scaling
+    std::cout << "X11Platform: Set monitor " << monitor_id << " scale to " << scale << "x" << std::endl;
+}
+
+void X11Platform::initialize_randr() {
+    if (!display_) return;
+    
+    // Check if RandR extension is available
+    int event_base, error_base;
+    if (XRRQueryExtension(display_, &event_base, &error_base)) {
+        std::cout << "X11Platform: RandR extension available" << std::endl;
+        
+        // Get screen resources
+        Window root = DefaultRootWindow(display_);
+        int screen = DefaultScreen(display_);
+        XRRScreenResources* resources = XRRGetScreenResources(display_, root);
+        
+        if (resources) {
+            // Process monitor information
+            for (int i = 0; i < resources->noutput; ++i) {
+                XRROutputInfo* output_info = XRRGetOutputInfo(display_, resources, resources->outputs[i]);
+                if (output_info && output_info->connection == RR_Connected) {
+                    // Add monitor to our list
+                    Monitor monitor;
+                    monitor.id = i;
+                    monitor.x = 0; // TODO: Get actual position
+                    monitor.y = 0;
+                    monitor.width = output_info->mm_width; // Convert mm to pixels
+                    monitor.height = output_info->mm_height;
+                    monitor.name = output_info->name;
+                    monitor.refresh_rate = 60; // Default
+                    
+                    monitors_.push_back(monitor);
+                }
+                if (output_info) XRRFreeOutputInfo(output_info);
+            }
+            XRRFreeScreenResources(resources);
+        }
+    } else {
+        std::cout << "X11Platform: RandR extension not available" << std::endl;
+    }
+}
+
+void X11Platform::cleanup_randr() {
+    // Clean up RandR resources if needed
+    std::cout << "X11Platform: RandR cleanup completed" << std::endl;
+}
+
+// Panel/Dock integration implementation
+void X11Platform::set_panel_visible(bool visible) {
+    panel_visible_ = visible;
+    
+    // TODO: Implement actual panel visibility control
+    std::cout << "X11Platform: Panel visibility " << (visible ? "enabled" : "disabled") << std::endl;
+}
+
+void X11Platform::set_panel_position(int position) {
+    if (position < 0 || position > 3) return;
+    
+    panel_position_ = position;
+    
+    // Position values: 0=bottom, 1=top, 2=left, 3=right
+    std::string position_str;
+    switch (position) {
+        case 0: position_str = "bottom"; break;
+        case 1: position_str = "top"; break;
+        case 2: position_str = "left"; break;
+        case 3: position_str = "right"; break;
+        default: position_str = "unknown"; break;
+    }
+    
+    std::cout << "X11Platform: Panel position set to " << position_str << std::endl;
+}
+
+void X11Platform::set_panel_auto_hide(bool enabled) {
+    panel_auto_hide_ = enabled;
+    
+    // TODO: Implement actual panel auto-hide behavior
+    std::cout << "X11Platform: Panel auto-hide " << (enabled ? "enabled" : "disabled") << std::endl;
+}
+
+void X11Platform::update_panel_workspace_list() {
+    if (!ewmh_supported_) return;
+    
+    // Update panel with current workspace information
+    // This would typically involve communicating with the panel application
+    std::cout << "X11Platform: Updated panel workspace list" << std::endl;
+}
+
+// System tray integration implementation
+void X11Platform::add_system_tray_icon(const std::string& tooltip, Pixmap icon) {
+    // TODO: Implement actual system tray icon addition
+    // This would involve using the _NET_SYSTEM_TRAY_S0 atom and related protocols
+    
+    system_tray_icon_ = 1; // Placeholder
+    std::cout << "X11Platform: Added system tray icon with tooltip: " << tooltip << std::endl;
+}
+
+void X11Platform::remove_system_tray_icon() {
+    if (system_tray_icon_) {
+        // TODO: Implement actual system tray icon removal
+        system_tray_icon_ = 0;
+        std::cout << "X11Platform: Removed system tray icon" << std::endl;
+    }
+}
+
+void X11Platform::show_system_tray_menu(Window menu) {
+    // TODO: Implement system tray menu display
+    std::cout << "X11Platform: Show system tray menu" << std::endl;
+}
diff --git a/src/platform/x11_platform.h b/src/platform/x11_platform.h
new file mode 100644
index 0000000..095081e
--- /dev/null
+++ b/src/platform/x11_platform.h
@@ -0,0 +1,210 @@
+#ifndef SRDWM_X11_PLATFORM_H
+#define SRDWM_X11_PLATFORM_H
+
+#include "platform.h"
+#include <string>
+#include <vector>
+#include <map>
+#include <algorithm>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/extensions/Xrandr.h>
+#include <X11/extensions/Xinerama.h>
+
+// X11 types are now properly included
+// Use X11Window typedef to avoid collision with our SRDWindow class
+typedef unsigned long X11Window;
+
+// Helper functions to convert between X11Window and X11's Window type
+inline ::Window to_x11_window(X11Window w) { return static_cast<::Window>(w); }
+inline X11Window from_x11_window(::Window w) { return static_cast<X11Window>(w); }
+
+class X11Platform : public Platform {
+public:
+    X11Platform();
+    ~X11Platform() override;
+
+    // Platform interface implementation
+    bool initialize() override;
+    void shutdown() override;
+    bool poll_events(std::vector<Event>& events) override;
+    void process_event(const Event& event) override;
+
+    // Window management
+    std::unique_ptr<SRDWindow> create_window(const std::string& title, int x, int y, int width, int height) override;
+    void destroy_window(SRDWindow* window) override;
+    void set_window_position(SRDWindow* window, int x, int y) override;
+    void set_window_size(SRDWindow* window, int width, int height) override;
+    void set_window_title(SRDWindow* window, const std::string& title) override;
+    void focus_window(SRDWindow* window) override;
+    void minimize_window(SRDWindow* window) override;
+    void maximize_window(SRDWindow* window) override;
+    void close_window(SRDWindow* window) override;
+
+    // Monitor management
+    std::vector<Monitor> get_monitors() override;
+    Monitor get_primary_monitor() override;
+
+    // Input handling
+    void grab_keyboard() override;
+    void ungrab_keyboard() override;
+    void grab_pointer() override;
+    void ungrab_pointer() override;
+
+    // Window decorations (X11 implementation)
+    void set_window_decorations(SRDWindow* window, bool enabled) override;
+    void set_window_border_color(SRDWindow* window, int r, int g, int b) override;
+    void set_window_border_width(SRDWindow* window, int width) override;
+    bool get_window_decorations(SRDWindow* window) const override;
+
+    // Linux/X11-specific features
+    void enable_compositor(bool enabled);
+    void set_window_opacity(SRDWindow* window, unsigned char opacity);
+    void set_window_blur(SRDWindow* window, bool enabled);
+    void set_window_shadow(SRDWindow* window, bool enabled);
+    
+    // EWMH (Extended Window Manager Hints) support
+    void set_ewmh_supported(bool supported);
+    void set_window_type(SRDWindow* window, const std::string& type);
+    void set_window_state(SRDWindow* window, const std::vector<std::string>& states);
+    void set_window_strut(SRDWindow* window, int left, int right, int top, int bottom);
+    
+    // Virtual Desktop support (X11 workspaces)
+    void create_virtual_desktop(const std::string& name);
+    void remove_virtual_desktop(int desktop_id);
+    void switch_to_virtual_desktop(int desktop_id);
+    int get_current_virtual_desktop() const;
+    std::vector<int> get_virtual_desktops() const;
+    void move_window_to_desktop(SRDWindow* window, int desktop_id);
+    
+    // Panel/Dock integration
+    void set_panel_visible(bool visible);
+    void set_panel_position(int position); // 0=bottom, 1=top, 2=left, 3=right
+    void set_panel_auto_hide(bool enabled);
+    void update_panel_workspace_list();
+    
+    // System tray integration
+    void add_system_tray_icon(const std::string& tooltip, Pixmap icon);
+    void remove_system_tray_icon();
+    void show_system_tray_menu(Window menu);
+    
+    // RandR (Resize and Rotate) support
+    void enable_randr(bool enabled);
+    void set_monitor_rotation(int monitor_id, int rotation);
+    void set_monitor_refresh_rate(int monitor_id, int refresh_rate);
+    void set_monitor_scale(int monitor_id, float scale);
+
+    // Utility
+    std::string get_platform_name() const override { return "X11"; }
+    bool is_wayland() const override { return false; }
+    bool is_x11() const override { return true; }
+    bool is_windows() const override { return false; }
+    bool is_macos() const override { return false; }
+
+private:
+    // X11-specific members
+    Display* display_ = nullptr;
+    X11Window root_ = 0;
+    
+    // Window tracking
+    std::map<X11Window, ::SRDWindow*> window_map_;
+    std::map<X11Window, X11Window> frame_window_map_; // client -> frame
+    
+    // Monitor information
+    std::vector<Monitor> monitors_;
+    
+    // Decoration state
+    bool decorations_enabled_;
+    int border_width_;
+    unsigned long border_color_;
+    unsigned long focused_border_color_;
+    
+    // Linux/X11-specific state
+    bool compositor_enabled_;
+    bool ewmh_supported_;
+    bool randr_enabled_;
+    int current_virtual_desktop_;
+    std::vector<int> virtual_desktops_;
+    bool panel_visible_;
+    bool panel_auto_hide_;
+    int panel_position_;
+    Window system_tray_icon_;
+    
+    // EWMH atoms
+    Atom _NET_WM_STATE_;
+    Atom _NET_WM_STATE_MAXIMIZED_VERT_;
+    Atom _NET_WM_STATE_MAXIMIZED_HORZ_;
+    Atom _NET_WM_STATE_FULLSCREEN_;
+    Atom _NET_WM_STATE_ABOVE_;
+    Atom _NET_WM_STATE_BELOW_;
+    Atom _NET_WM_WINDOW_TYPE_;
+    Atom _NET_WM_WINDOW_TYPE_DESKTOP_;
+    Atom _NET_WM_WINDOW_TYPE_DOCK_;
+    Atom _NET_WM_WINDOW_TYPE_TOOLBAR_;
+    Atom _NET_WM_WINDOW_TYPE_MENU_;
+    Atom _NET_WM_WINDOW_TYPE_UTILITY_;
+    Atom _NET_WM_WINDOW_TYPE_SPLASH_;
+    Atom _NET_WM_WINDOW_TYPE_DIALOG_;
+    Atom _NET_WM_WINDOW_TYPE_DROPDOWN_MENU_;
+    Atom _NET_WM_WINDOW_TYPE_POPUP_MENU_;
+    Atom _NET_WM_WINDOW_TYPE_TOOLTIP_;
+    Atom _NET_WM_WINDOW_TYPE_NOTIFICATION_;
+    Atom _NET_WM_WINDOW_TYPE_COMBO_;
+    Atom _NET_WM_WINDOW_TYPE_DND_;
+    Atom _NET_WM_WINDOW_TYPE_NORMAL_;
+    Atom _NET_WM_DESKTOP_;
+    Atom _NET_NUMBER_OF_DESKTOPS_;
+    Atom _NET_CURRENT_DESKTOP_;
+    Atom _NET_DESKTOP_NAMES_;
+    Atom _NET_WM_STRUT_;
+    Atom _NET_WM_STRUT_PARTIAL_;
+    Atom _NET_WM_OPACITY_;
+    
+    // Helper methods
+    SRDWindow* get_focused_window() const;
+
+    // Private methods
+    bool setup_x11_environment();
+    bool setup_event_masks();
+    void handle_x11_event(XEvent& event);
+    void setup_atoms();
+    void setup_extensions();
+    bool check_for_other_wm();
+    
+    // Event handlers
+    void handle_map_request(XMapRequestEvent& event);
+    void handle_configure_request(XConfigureRequestEvent& event);
+    void handle_destroy_notify(XDestroyWindowEvent& event);
+    void handle_unmap_notify(XUnmapEvent& event);
+    void handle_key_press(XKeyEvent& event);
+    void handle_button_press(XButtonEvent& event);
+    void handle_motion_notify(XMotionEvent& event);
+    
+    // Decoration methods
+    void create_frame_window(SRDWindow* window);
+    void destroy_frame_window(SRDWindow* window);
+    void draw_titlebar(SRDWindow* window);
+    void update_frame_geometry(SRDWindow* window);
+    
+    // EWMH methods
+    void setup_ewmh();
+    void update_ewmh_desktop_info();
+    void handle_ewmh_message(XClientMessageEvent& event);
+    
+    // Virtual Desktop methods
+    void initialize_virtual_desktops();
+    void cleanup_virtual_desktops();
+    
+    // RandR methods
+    void initialize_randr();
+    void cleanup_randr();
+    
+    // Panel methods
+    void initialize_panel();
+    void update_panel();
+};
+
+#endif // SRDWM_X11_PLATFORM_H
+