diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 04cc963d..f4fc958d 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -9,26 +9,45 @@ on:
 
 jobs:
   build:
-
+    name: build ${{ matrix.variant }}
     runs-on: ${{matrix.os}}
     env:
       DISPLAY: ':99'
     strategy:
       fail-fast: false
       matrix: 
-        os: [macos-latest, ubuntu-latest, windows-latest]
         include:
-        - os: ubuntu-latest
+        - variant: ubuntu-x11-latest
+          os: ubuntu-latest
           headless: Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 &
-        - os: ubuntu-latest
-          dependencies: sudo apt-get install libxtst-dev libevdev-dev --assume-yes
-        - os: macos-latest
+          dependencies: sudo apt-get install libxtst-dev libevdev-dev libudev-dev --assume-yes
+          build: cargo build --verbose --features x11
+          test: cargo test --verbose --features=serialize,x11
+        - variant: ubuntu-wayland-latest
+          os: ubuntu-latest
+          headless: weston --no-config --socket=wl-test-env --backend=headless &
+          dependencies: |
+            sudo apt-get install libxtst-dev libevdev-dev libudev-dev libinput-dev libxkbcommon-dev weston --assume-yes
+            sudo chown root:input /dev/uinput
+            sudo chmod g+rw /dev/uinput
+            id -a
+            whoami
+            sudo usermod -aG input runner
+            echo 'KERNEL=="uinput", MODE="0660", GROUP="input", TAG+="uaccess"' | sudo tee /etc/udev/rules.d/99-uinput.rules
+            sudo udevadm control --reload-rules
+            sudo udevadm trigger --attr-match=name="uinput"
+
+          build: cargo build --verbose --features wayland
+          # Keyboard not implemented in wayland
+          test: WAYLAND_DISPLAY=wl-test-env cargo test --verbose --no-default-features --features=serialize,wayland -- --skip test_grab --skip test_listen_and_simulate 
+        - variant: macos-latest
+          os: macos-latest
+          build: cargo build --verbose
           # TODO: We can't test this on github, we can't set accessibility yet.
           test: cargo test --verbose --all-features -- --skip test_listen_and_simulate --skip test_grab
-        - os: ubuntu-latest
-          # TODO unstable_grab feature is not supported on Linux.
-          test: cargo test --verbose --features=serialize
-        - os: windows-latest
+        - variant: windows-latest
+          os: windows-latest
+          build: cargo build --verbose
           test: cargo test --verbose --all-features
 
     steps:
@@ -44,7 +63,7 @@ jobs:
         rustup component add rustfmt
         cargo fmt -- --check
     - name: Build
-      run: cargo build --verbose
+      run: ${{ matrix.build }}
     - name: Run tests
       run: ${{matrix.test}}
     - name: Linter
diff --git a/Cargo.toml b/Cargo.toml
index 6d22c668..7d483426 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -18,8 +18,11 @@ serde = {version = "1.0", features = ["derive"], optional=true}
 lazy_static = "1.4"
 
 [features]
+default = []
 serialize = ["serde"]
 unstable_grab = ["evdev-rs", "epoll", "inotify"]
+wayland = ["input", "input-linux", "xkbcommon"]
+x11 = ["dep:x11"]
 
 [target.'cfg(target_os = "macos")'.dependencies]
 cocoa = "0.26"
@@ -31,10 +34,13 @@ dispatch = "0.2"
 
 [target.'cfg(target_os = "linux")'.dependencies]
 libc = "0.2"
-x11 = {version = "2.18", features = ["xlib", "xrecord", "xinput"]}
+x11 = {version = "2.18", features = ["xlib", "xrecord", "xinput"], optional = true}
 evdev-rs = {version = "0.6", optional=true}
 epoll = {version = "4.1.0", optional=true}
 inotify = {version = "0.11", default-features=false, optional=true}
+input = {version = "0.9", optional=true}
+input-linux = { version = "0.7.1", optional = true }
+xkbcommon = { version = "0.5.0", optional = true }
 
 [target.'cfg(target_os = "windows")'.dependencies]
 winapi = { version = "0.3", features = ["winuser", "errhandlingapi", "processthreadsapi"] }
@@ -57,7 +63,7 @@ required-features = ["unstable_grab"]
 
 [[example]]
 name = "tokio_channel"
-required-features = ["unstable_grab"]
+required-features = []
 
 [[test]]
 name = "grab"
diff --git a/examples/simulate.rs b/examples/simulate.rs
index 1f50f042..8212a927 100644
--- a/examples/simulate.rs
+++ b/examples/simulate.rs
@@ -1,5 +1,8 @@
 use rdev::{simulate, Button, EventType, Key, SimulateError};
-use std::{thread, time};
+use std::{
+    thread,
+    time::{self, Duration},
+};
 
 fn send(event_type: &EventType) {
     let delay = time::Duration::from_millis(20);
@@ -14,8 +17,14 @@ fn send(event_type: &EventType) {
 }
 
 fn main() {
+    send(&EventType::MouseMove { x: 0.0, y: 0.0 });
+    thread::sleep(Duration::from_millis(1000));
     send(&EventType::KeyPress(Key::KeyS));
     send(&EventType::KeyRelease(Key::KeyS));
+    send(&EventType::KeyPress(Key::KeyA));
+    send(&EventType::KeyRelease(Key::KeyA));
+    send(&EventType::KeyPress(Key::KeyB));
+    send(&EventType::KeyRelease(Key::KeyB));
 
     send(&EventType::MouseMove { x: 0.0, y: 0.0 });
     send(&EventType::MouseMove { x: 400.0, y: 400.0 });
diff --git a/flake.lock b/flake.lock
index a44ef7a5..6fb1525d 100644
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1730531603,
-        "narHash": "sha256-Dqg6si5CqIzm87sp57j5nTaeBbWhHFaVyG7V6L8k3lY=",
+        "lastModified": 1747542820,
+        "narHash": "sha256-GaOZntlJ6gPPbbkTLjbd8BMWaDYafhuuYRNrxCGnPJw=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "7ffd9ae656aec493492b44d0ddfb28e79a1ea25d",
+        "rev": "292fa7d4f6519c074f0a50394dbbe69859bb6043",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index 44346eee..6253e680 100644
--- a/flake.nix
+++ b/flake.nix
@@ -29,7 +29,6 @@
               ++ (
                 if stdenv.isLinux then
                   [
-                    xkbmon
                     xorg.libX11
                     xorg.libXcursor
                     xorg.libXrandr
@@ -37,6 +36,9 @@
                     xorg.libXtst
                     libevdev
                     libnotify
+                    libinput
+                    libxkbcommon
+                    udev
                   ]
                 else
                   [ ]
diff --git a/src/lib.rs b/src/lib.rs
index 9cac0394..ed04c38f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -226,9 +226,9 @@ pub use crate::rdev::{
 #[cfg(target_os = "macos")]
 mod macos;
 #[cfg(target_os = "macos")]
-pub use crate::macos::{set_is_main_thread, Keyboard};
-#[cfg(target_os = "macos")]
 use crate::macos::{display_size as _display_size, listen as _listen, simulate as _simulate};
+#[cfg(target_os = "macos")]
+pub use crate::macos::{set_is_main_thread, Keyboard};
 
 #[cfg(target_os = "linux")]
 mod linux;
@@ -305,7 +305,8 @@ where
 /// }
 /// ```
 pub fn simulate(event_type: &EventType) -> Result<(), SimulateError> {
-    _simulate(event_type)
+    _simulate(event_type)?;
+    Ok(())
 }
 
 /// Returns the size in pixels of the main screen.
diff --git a/src/linux/mod.rs b/src/linux/mod.rs
index bf073fa8..6b98fb6c 100644
--- a/src/linux/mod.rs
+++ b/src/linux/mod.rs
@@ -1,18 +1,14 @@
-extern crate libc;
-extern crate x11;
+#[cfg(feature = "x11")]
+mod x11;
 
-mod common;
-mod display;
-#[cfg(feature = "unstable_grab")]
-mod grab;
-mod keyboard;
-mod keycodes;
-mod listen;
-mod simulate;
+#[cfg(feature = "x11")]
+pub use x11::*;
 
-pub use crate::linux::display::display_size;
-#[cfg(feature = "unstable_grab")]
-pub use crate::linux::grab::grab;
-pub use crate::linux::keyboard::Keyboard;
-pub use crate::linux::listen::listen;
-pub use crate::linux::simulate::simulate;
+#[cfg(all(feature = "wayland", not(feature = "x11")))]
+mod wayland;
+
+#[cfg(all(feature = "wayland", not(feature = "x11")))]
+pub use wayland::*;
+
+#[cfg(not(any(feature = "wayland", feature = "x11")))]
+compile_error!("Need to activate either wayland or x11 feature on linux");
diff --git a/src/linux/wayland/common.rs b/src/linux/wayland/common.rs
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/src/linux/wayland/common.rs
@@ -0,0 +1 @@
+
diff --git a/src/linux/wayland/display.rs b/src/linux/wayland/display.rs
new file mode 100644
index 00000000..1700fbc8
--- /dev/null
+++ b/src/linux/wayland/display.rs
@@ -0,0 +1,7 @@
+use crate::rdev::DisplayError;
+
+pub fn display_size() -> Result<(u64, u64), DisplayError> {
+    todo!("Not implemented");
+    // let display = Display::new().ok_or(DisplayError::NoDisplay)?;
+    // display.get_size().ok_or(DisplayError::NoDisplay)
+}
diff --git a/src/linux/wayland/grab.rs b/src/linux/wayland/grab.rs
new file mode 100644
index 00000000..0fb95d16
--- /dev/null
+++ b/src/linux/wayland/grab.rs
@@ -0,0 +1,529 @@
+use crate::linux::common::Display;
+use crate::linux::keyboard::Keyboard;
+use crate::rdev::{Button, Event, EventType, GrabError, Key, KeyboardState};
+use epoll::ControlOptions::{EPOLL_CTL_ADD, EPOLL_CTL_DEL};
+use evdev_rs::{
+    enums::{EventCode, EV_KEY, EV_REL},
+    Device, InputEvent, UInputDevice,
+};
+use inotify::{Inotify, WatchMask};
+use std::ffi::{OsStr, OsString};
+use std::fs::{read_dir, File};
+use std::io;
+use std::os::unix::{
+    ffi::OsStrExt,
+    fs::FileTypeExt,
+    io::{AsRawFd, IntoRawFd, RawFd},
+};
+use std::path::Path;
+use std::time::SystemTime;
+
+// TODO The x, y coordinates are currently wrong !! Is there mouse acceleration
+// to take into account ??
+
+macro_rules! convert_keys {
+    ($($ev_key:ident, $rdev_key:ident),*) => {
+        //TODO: make const when rust lang issue #49146 is fixed
+        #[allow(unreachable_patterns)]
+        fn evdev_key_to_rdev_key(key: &EV_KEY) -> Option<Key> {
+            match key {
+                $(
+                    EV_KEY::$ev_key => Some(Key::$rdev_key),
+                )*
+                _ => None,
+            }
+        }
+
+        // //TODO: make const when rust lang issue #49146 is fixed
+        // fn rdev_key_to_evdev_key(key: &Key) -> Option<EV_KEY> {
+        //     match key {
+        //         $(
+        //             Key::$rdev_key => Some(EV_KEY::$ev_key),
+        //         )*
+        //         _ => None
+        //     }
+        // }
+    };
+}
+
+macro_rules! convert_buttons {
+    ($($ev_key:ident, $rdev_key:ident),*) => {
+        //TODO: make const when rust lang issue #49146 is fixed
+        fn evdev_key_to_rdev_button(key: &EV_KEY) -> Option<Button> {
+            match key {
+                $(
+                    EV_KEY::$ev_key => Some(Button::$rdev_key),
+                )*
+                _ => None,
+            }
+        }
+
+        // //TODO: make const when rust lang issue #49146 is fixed
+        // fn rdev_button_to_evdev_key(event: &Button) -> Option<EV_KEY> {
+        //     match event {
+        //         $(
+        //             Button::$rdev_key => Some(EV_KEY::$ev_key),
+        //         )*
+        //         _ => None
+        //     }
+        // }
+    };
+}
+
+#[rustfmt::skip]
+convert_buttons!(
+    BTN_LEFT, Left,
+    BTN_RIGHT, Right,
+    BTN_MIDDLE, Middle
+);
+
+//TODO: IntlBackslash, kpDelete
+#[rustfmt::skip]
+convert_keys!(
+    KEY_ESC, Escape,
+    KEY_1, Num1,
+    KEY_2, Num2,
+    KEY_3, Num3,
+    KEY_4, Num4,
+    KEY_5, Num5,
+    KEY_6, Num6,
+    KEY_7, Num7,
+    KEY_8, Num8,
+    KEY_9, Num9,
+    KEY_0, Num0,
+    KEY_MINUS, Minus,
+    KEY_EQUAL, Equal,
+    KEY_BACKSPACE, Backspace,
+    KEY_TAB, Tab,
+    KEY_Q, KeyQ,
+    KEY_W, KeyW,
+    KEY_E, KeyE,
+    KEY_R, KeyR,
+    KEY_T, KeyT,
+    KEY_Y, KeyY,
+    KEY_U, KeyU,
+    KEY_I, KeyI,
+    KEY_O, KeyO,
+    KEY_P, KeyP,
+    KEY_LEFTBRACE, LeftBracket,
+    KEY_RIGHTBRACE, RightBracket,
+    KEY_ENTER, Return,
+    KEY_LEFTCTRL, ControlLeft,
+    KEY_A, KeyA,
+    KEY_S, KeyS,
+    KEY_D, KeyD,
+    KEY_F, KeyF,
+    KEY_G, KeyG,
+    KEY_H, KeyH,
+    KEY_J, KeyJ,
+    KEY_K, KeyK,
+    KEY_L, KeyL,
+    KEY_SEMICOLON, SemiColon,
+    KEY_APOSTROPHE, Quote,
+    KEY_GRAVE, BackQuote,
+    KEY_LEFTSHIFT, ShiftLeft,
+    KEY_BACKSLASH, BackSlash,
+    KEY_Z, KeyZ,
+    KEY_X, KeyX,
+    KEY_C, KeyC,
+    KEY_V, KeyV,
+    KEY_B, KeyB,
+    KEY_N, KeyN,
+    KEY_M, KeyM,
+    KEY_COMMA, Comma,
+    KEY_DOT, Dot,
+    KEY_SLASH, Slash,
+    KEY_RIGHTSHIFT, ShiftRight,
+    KEY_KPASTERISK , KpMultiply,
+    KEY_LEFTALT, Alt,
+    KEY_SPACE, Space,
+    KEY_CAPSLOCK, CapsLock,
+    KEY_F1, F1,
+    KEY_F2, F2,
+    KEY_F3, F3,
+    KEY_F4, F4,
+    KEY_F5, F5,
+    KEY_F6, F6,
+    KEY_F7, F7,
+    KEY_F8, F8,
+    KEY_F9, F9,
+    KEY_F10, F10,
+    KEY_NUMLOCK, NumLock,
+    KEY_SCROLLLOCK, ScrollLock,
+    KEY_KP7, Kp7,
+    KEY_KP8, Kp8,
+    KEY_KP9, Kp9,
+    KEY_KPMINUS, KpMinus,
+    KEY_KP4, Kp4,
+    KEY_KP5, Kp5,
+    KEY_KP6, Kp6,
+    KEY_KPPLUS, KpPlus,
+    KEY_KP1, Kp1,
+    KEY_KP2, Kp2,
+    KEY_KP3, Kp3,
+    KEY_KP0, Kp0,
+    KEY_F11, F11,
+    KEY_F12, F12,
+    KEY_KPENTER, KpReturn,
+    KEY_RIGHTCTRL, ControlRight,
+    KEY_KPSLASH, KpDivide,
+    KEY_RIGHTALT, AltGr,
+    KEY_HOME , Home,
+    KEY_UP, UpArrow,
+    KEY_PAGEUP, PageUp,
+    KEY_LEFT, LeftArrow,
+    KEY_RIGHT, RightArrow,
+    KEY_END, End,
+    KEY_DOWN, DownArrow,
+    KEY_PAGEDOWN, PageDown,
+    KEY_INSERT, Insert,
+    KEY_DELETE, Delete,
+    KEY_PAUSE, Pause,
+    KEY_LEFTMETA, MetaLeft,
+    KEY_RIGHTMETA, MetaRight,
+    KEY_PRINT, PrintScreen,
+    // KpDelete behaves like normal Delete most of the time
+    KEY_DELETE, KpDelete,
+    // Linux doesn't have an IntlBackslash key
+    KEY_BACKSLASH, IntlBackslash
+);
+
+fn evdev_event_to_rdev_event(
+    event: &InputEvent,
+    x: &mut f64,
+    y: &mut f64,
+    w: f64,
+    h: f64,
+) -> Option<EventType> {
+    match &event.event_code {
+        EventCode::EV_KEY(key) => {
+            if let Some(button) = evdev_key_to_rdev_button(key) {
+                // first check if pressed key is a mouse button
+                match event.value {
+                    0 => Some(EventType::ButtonRelease(button)),
+                    _ => Some(EventType::ButtonPress(button)),
+                }
+            } else if let Some(key) = evdev_key_to_rdev_key(key) {
+                // check if pressed key is a keyboard key
+                match event.value {
+                    0 => Some(EventType::KeyRelease(key)),
+                    _ => Some(EventType::KeyPress(key)),
+                }
+            } else {
+                // if neither mouse button nor keyboard key, return none
+                None
+            }
+        }
+        EventCode::EV_REL(mouse) => match mouse {
+            EV_REL::REL_X => {
+                let dx = event.value as f64;
+                *x += dx;
+                if *x < 0.0 {
+                    *x = 0.0;
+                }
+                if *x > w {
+                    *x = w;
+                }
+                Some(EventType::MouseMove { x: *x, y: *y })
+            }
+            EV_REL::REL_Y => {
+                let dy = event.value as f64;
+                *y += dy;
+                if *y < 0.0 {
+                    *y = 0.0;
+                }
+                if *y > h {
+                    *y = h;
+                }
+                Some(EventType::MouseMove { x: *x, y: *y })
+            }
+            EV_REL::REL_HWHEEL => Some(EventType::Wheel {
+                delta_x: event.value.into(),
+                delta_y: 0,
+            }),
+            EV_REL::REL_WHEEL => Some(EventType::Wheel {
+                delta_x: 0,
+                delta_y: event.value.into(),
+            }),
+            // Other EV_REL events cannot be represented by rdev
+            _ => None,
+        },
+        // Other event_codes cannot be represented by rdev,
+        // and some never will e.g. EV_SYN
+        _ => None,
+    }
+}
+
+// fn rdev_event_to_evdev_event(event: &EventType, time: &TimeVal) -> Option<InputEvent> {
+//     match event {
+//         EventType::KeyPress(key) => {
+//             let key = rdev_key_to_evdev_key(&key)?;
+//             Some(InputEvent::new(&time, &EventCode::EV_KEY(key), 1))
+//         }
+//         EventType::KeyRelease(key) => {
+//             let key = rdev_key_to_evdev_key(&key)?;
+//             Some(InputEvent::new(&time, &EventCode::EV_KEY(key), 0))
+//         }
+//         EventType::ButtonPress(button) => {
+//             let button = rdev_button_to_evdev_key(&button)?;
+//             Some(InputEvent::new(&time, &EventCode::EV_KEY(button), 1))
+//         }
+//         EventType::ButtonRelease(button) => {
+//             let button = rdev_button_to_evdev_key(&button)?;
+//             Some(InputEvent::new(&time, &EventCode::EV_KEY(button), 0))
+//         }
+//         EventType::MouseMove { x, y } => {
+//             let (x, y) = (*x as i32, *y as i32);
+//             //TODO allow both x and y movements simultaneously
+//             if x != 0 {
+//                 Some(InputEvent::new(&time, &EventCode::EV_REL(EV_REL::REL_X), x))
+//             } else {
+//                 Some(InputEvent::new(&time, &EventCode::EV_REL(EV_REL::REL_Y), y))
+//             }
+//         }
+//         EventType::Wheel { delta_x, delta_y } => {
+//             let (x, y) = (*delta_x as i32, *delta_y as i32);
+//             //TODO allow both x and y movements simultaneously
+//             if x != 0 {
+//                 Some(InputEvent::new(
+//                     &time,
+//                     &EventCode::EV_REL(EV_REL::REL_HWHEEL),
+//                     x,
+//                 ))
+//             } else {
+//                 Some(InputEvent::new(
+//                     &time,
+//                     &EventCode::EV_REL(EV_REL::REL_WHEEL),
+//                     y,
+//                 ))
+//             }
+//         }
+//     }
+// }
+
+pub fn grab<T>(callback: T) -> Result<(), GrabError>
+where
+    T: Fn(Event) -> Option<Event> + 'static,
+{
+    let mut kb = Keyboard::new().ok_or(GrabError::KeyboardError)?;
+    let display = Display::new().ok_or(GrabError::MissingDisplayError)?;
+    let (width, height) = display.get_size().ok_or(GrabError::MissingDisplayError)?;
+    let (current_x, current_y) = display
+        .get_mouse_pos()
+        .ok_or(GrabError::MissingDisplayError)?;
+    let mut x = current_x as f64;
+    let mut y = current_y as f64;
+    let w = width as f64;
+    let h = height as f64;
+    filter_map_events(|event| {
+        let event_type = match evdev_event_to_rdev_event(&event, &mut x, &mut y, w, h) {
+            Some(rdev_event) => rdev_event,
+            // If we can't convert event, simulate it
+            None => return (Some(event), GrabStatus::Continue),
+        };
+        let name = kb.add(&event_type);
+        let rdev_event = Event {
+            time: SystemTime::now(),
+            name,
+            event_type,
+        };
+        if callback(rdev_event).is_some() {
+            (Some(event), GrabStatus::Continue)
+        } else {
+            // callback returns None, swallow the event
+            (None, GrabStatus::Continue)
+        }
+    })?;
+    Ok(())
+}
+
+pub fn filter_map_events<F>(mut func: F) -> io::Result<()>
+where
+    F: FnMut(InputEvent) -> (Option<InputEvent>, GrabStatus),
+{
+    let (epoll_fd, mut devices, output_devices) = setup_devices()?;
+    let mut inotify = setup_inotify(epoll_fd, &devices)?;
+
+    //grab devices
+    devices
+        .iter_mut()
+        .try_for_each(|device| device.grab(evdev_rs::GrabMode::Grab))?;
+
+    // create buffer for epoll to fill
+    let mut epoll_buffer = [epoll::Event::new(epoll::Events::empty(), 0); 4];
+    let mut inotify_buffer = vec![0_u8; 4096];
+    'event_loop: loop {
+        let num_events = epoll::wait(epoll_fd, -1, &mut epoll_buffer)?;
+
+        //map and simulate events, dealing with
+        'events: for event in &epoll_buffer[0..num_events] {
+            // new device file created
+            if event.data == INOTIFY_DATA {
+                for event in inotify.read_events(&mut inotify_buffer)? {
+                    assert!(
+                        event.mask.contains(inotify::EventMask::CREATE),
+                        "inotify is listening for events other than file creation"
+                    );
+                    add_device_to_epoll_from_inotify_event(epoll_fd, event, &mut devices)?;
+                }
+            } else {
+                // Input device received event
+                let device_idx = event.data as usize;
+                let device = devices.get(device_idx).unwrap();
+                while device.has_event_pending() {
+                    //TODO: deal with EV_SYN::SYN_DROPPED
+                    let (_, event) = match device.next_event(evdev_rs::ReadFlag::NORMAL) {
+                        Ok(event) => event,
+                        Err(_) => {
+                            let device_fd = device.file().as_raw_fd();
+                            let empty_event = epoll::Event::new(epoll::Events::empty(), 0);
+                            epoll::ctl(epoll_fd, EPOLL_CTL_DEL, device_fd, empty_event)?;
+                            continue 'events;
+                        }
+                    };
+                    let (event, grab_status) = func(event);
+
+                    if let (Some(event), Some(out_device)) = (event, output_devices.get(device_idx))
+                    {
+                        out_device.write_event(&event)?;
+                    }
+                    if grab_status == GrabStatus::Stop {
+                        break 'event_loop;
+                    }
+                }
+            }
+        }
+    }
+
+    for device in devices.iter_mut() {
+        //ungrab devices, ignore errors
+        device.grab(evdev_rs::GrabMode::Ungrab).ok();
+    }
+
+    epoll::close(epoll_fd)?;
+    Ok(())
+}
+
+static DEV_PATH: &str = "/dev/input";
+const INOTIFY_DATA: u64 = u64::max_value();
+const EPOLLIN: epoll::Events = epoll::Events::EPOLLIN;
+
+/// Whether to continue grabbing events or to stop
+/// Used in `filter_map_events` (and others)
+#[derive(Debug, Eq, PartialEq, Hash)]
+pub enum GrabStatus {
+    /// Stop grabbing
+    Continue,
+    /// ungrab events
+    Stop,
+}
+
+fn get_device_files<T>(path: T) -> io::Result<Vec<File>>
+where
+    T: AsRef<Path>,
+{
+    let mut res = Vec::new();
+    for entry in read_dir(path)? {
+        let entry = entry?;
+        // /dev/input files are character devices
+        if !entry.file_type()?.is_char_device() {
+            continue;
+        }
+
+        let path = entry.path();
+        let file_name_bytes = match path.file_name() {
+            Some(file_name) => file_name.as_bytes(),
+            None => continue, // file_name was "..", should be impossible
+        };
+        // skip filenames matching "mouse.* or mice".
+        // these files don't play nice with libevdev, not sure why
+        // see: https://askubuntu.com/questions/1043832/difference-between-dev-input-mouse0-and-dev-input-mice
+        if file_name_bytes == OsStr::new("mice").as_bytes()
+            || file_name_bytes
+                .get(0..=1)
+                .map(|s| s == OsStr::new("js").as_bytes())
+                .unwrap_or(false)
+            || file_name_bytes
+                .get(0..=4)
+                .map(|s| s == OsStr::new("mouse").as_bytes())
+                .unwrap_or(false)
+        {
+            continue;
+        }
+        res.push(File::open(path)?);
+    }
+    Ok(res)
+}
+
+fn epoll_watch_all<'a, T>(device_files: T) -> io::Result<RawFd>
+where
+    T: Iterator<Item = &'a File>,
+{
+    let epoll_fd = epoll::create(true)?;
+    // add file descriptors to epoll
+    for (file_idx, file) in device_files.enumerate() {
+        let epoll_event = epoll::Event::new(EPOLLIN, file_idx as u64);
+        epoll::ctl(epoll_fd, EPOLL_CTL_ADD, file.as_raw_fd(), epoll_event)?;
+    }
+    Ok(epoll_fd)
+}
+
+fn inotify_devices() -> io::Result<Inotify> {
+    let inotify = Inotify::init()?;
+    inotify.watches().add(DEV_PATH, WatchMask::CREATE)?;
+    Ok(inotify)
+}
+
+fn add_device_to_epoll_from_inotify_event(
+    epoll_fd: RawFd,
+    event: inotify::Event<&OsStr>,
+    devices: &mut Vec<Device>,
+) -> io::Result<()> {
+    let mut device_path = OsString::from(DEV_PATH);
+    device_path.push(OsString::from("/"));
+    device_path.push(event.name.unwrap());
+    // new plug events
+    let file = File::open(device_path)?;
+    let fd = file.as_raw_fd();
+    let device = Device::new_from_file(file)?;
+    let event = epoll::Event::new(EPOLLIN, devices.len() as u64);
+    devices.push(device);
+    epoll::ctl(epoll_fd, EPOLL_CTL_ADD, fd, event)?;
+    Ok(())
+}
+
+/// Returns tuple of epoll_fd, all devices, and uinput devices, where
+/// uinputdevices is the same length as devices, and each uinput device is
+/// a libevdev copy of its corresponding device.The epoll_fd is level-triggered
+/// on any available data in the original devices.
+fn setup_devices() -> io::Result<(RawFd, Vec<Device>, Vec<UInputDevice>)> {
+    let device_files = get_device_files(DEV_PATH)?;
+    let epoll_fd = epoll_watch_all(device_files.iter())?;
+    let devices = device_files
+        .into_iter()
+        .map(Device::new_from_file)
+        .collect::<io::Result<Vec<Device>>>()?;
+    let output_devices = devices
+        .iter()
+        .map(UInputDevice::create_from_device)
+        .collect::<io::Result<Vec<UInputDevice>>>()?;
+    Ok((epoll_fd, devices, output_devices))
+}
+
+/// Creates an inotify instance looking at /dev/input and adds it to an epoll instance.
+/// Ensures devices isnt too long, which would make the epoll data ambigious.
+fn setup_inotify(epoll_fd: RawFd, devices: &[Device]) -> io::Result<Inotify> {
+    //Ensure there is space for inotify at last epoll index.
+    if devices.len() as u64 >= INOTIFY_DATA {
+        eprintln!("number of devices: {}", devices.len());
+        return Err(io::Error::new(
+            io::ErrorKind::Other,
+            "too many device files!",
+        ));
+    }
+    // Set up inotify to listen for new devices being plugged in
+    let inotify = inotify_devices()?;
+    let epoll_event = epoll::Event::new(EPOLLIN, INOTIFY_DATA);
+    epoll::ctl(epoll_fd, EPOLL_CTL_ADD, inotify.as_raw_fd(), epoll_event)?;
+    Ok(inotify)
+}
diff --git a/src/linux/wayland/keyboard.rs b/src/linux/wayland/keyboard.rs
new file mode 100644
index 00000000..8a2b8db5
--- /dev/null
+++ b/src/linux/wayland/keyboard.rs
@@ -0,0 +1,177 @@
+use super::keycodes::code_from_key;
+use super::xkb_keycodes::internal_to_xkb_keycode;
+use crate::rdev::{EventType, Key, KeyboardState};
+use xkbcommon::xkb;
+
+pub struct Keyboard {
+    context: xkb::Context,
+    keymap: xkb::Keymap,
+    state: xkb::State,
+    shift: bool,
+    caps_lock: bool,
+    alt: bool,
+    ctrl: bool,
+    meta: bool,
+    shift_idx: u32,
+    caps_idx: u32,
+    alt_idx: u32,
+    ctrl_idx: u32,
+    meta_idx: u32,
+    current_layout: String,
+    current_variant: String,
+    current_model: String,
+}
+
+impl Keyboard {
+    pub fn new() -> Result<Self, crate::rdev::SimulateError> {
+        let context = xkb::Context::new(xkb::CONTEXT_NO_FLAGS);
+
+        // Get current keyboard layout information from environment
+        let layout = std::env::var("XKB_DEFAULT_LAYOUT").unwrap_or_else(|_| "us".to_string());
+        let variant = std::env::var("XKB_DEFAULT_VARIANT").unwrap_or_else(|_| "".to_string());
+        let model = std::env::var("XKB_DEFAULT_MODEL").unwrap_or_else(|_| "pc104".to_string());
+        let rules = std::env::var("XKB_DEFAULT_RULES").unwrap_or_else(|_| "evdev".to_string());
+
+        let keymap = xkb::Keymap::new_from_names(
+            &context,
+            &rules,
+            &model,
+            &layout,
+            &variant,
+            Some("terminate:ctrl_alt_bksp".to_string()),
+            xkb::KEYMAP_COMPILE_NO_FLAGS,
+        )
+        .ok_or(crate::rdev::SimulateError)?;
+
+        let state = xkb::State::new(&keymap);
+        // Lookup modifier indices
+        let shift_idx = keymap.mod_get_index("Shift");
+        let caps_idx = keymap.mod_get_index("Lock");
+        let alt_idx = keymap.mod_get_index("Mod1");
+        let ctrl_idx = keymap.mod_get_index("Control");
+        let meta_idx = keymap.mod_get_index("Mod4");
+
+        Ok(Self {
+            context,
+            keymap,
+            state,
+            shift: false,
+            caps_lock: false,
+            alt: false,
+            ctrl: false,
+            meta: false,
+            shift_idx,
+            caps_idx,
+            alt_idx,
+            ctrl_idx,
+            meta_idx,
+            current_layout: layout,
+            current_variant: variant,
+            current_model: model,
+        })
+    }
+
+    fn update_modifiers(&mut self) {
+        let mut depressed = 0;
+        if self.shift {
+            depressed |= 1 << self.shift_idx;
+        }
+        if self.caps_lock {
+            depressed |= 1 << self.caps_idx;
+        }
+        if self.alt {
+            depressed |= 1 << self.alt_idx;
+        }
+        if self.ctrl {
+            depressed |= 1 << self.ctrl_idx;
+        }
+        if self.meta {
+            depressed |= 1 << self.meta_idx;
+        }
+        self.state.update_mask(depressed, 0, 0, 0, 0, 0);
+    }
+
+    fn get_key_utf8(&self, keycode: u32) -> Option<String> {
+        let keysym = self.state.key_get_one_sym(keycode);
+        if keysym == xkb::KEY_NoSymbol {
+            return None;
+        }
+        let utf8 = self.state.key_get_utf8(keycode);
+        if utf8.is_empty() {
+            return None;
+        }
+        Some(utf8)
+    }
+}
+
+impl KeyboardState for Keyboard {
+    fn add(&mut self, event_type: &EventType) -> Option<String> {
+        match event_type {
+            EventType::KeyPress(key) => match key {
+                Key::ShiftLeft | Key::ShiftRight => {
+                    self.shift = true;
+                    self.update_modifiers();
+                    None
+                }
+                Key::CapsLock => {
+                    self.caps_lock = !self.caps_lock;
+                    self.update_modifiers();
+                    None
+                }
+                Key::Alt => {
+                    self.alt = true;
+                    self.update_modifiers();
+                    None
+                }
+                Key::ControlLeft | Key::ControlRight => {
+                    self.ctrl = true;
+                    self.update_modifiers();
+                    None
+                }
+                Key::MetaLeft | Key::MetaRight => {
+                    self.meta = true;
+                    self.update_modifiers();
+                    None
+                }
+                key => {
+                    let internal_code = code_from_key(*key)?;
+                    let xkb_code = internal_to_xkb_keycode(internal_code);
+                    self.get_key_utf8(xkb_code)
+                }
+            },
+            EventType::KeyRelease(key) => match key {
+                Key::ShiftLeft | Key::ShiftRight => {
+                    self.shift = false;
+                    self.update_modifiers();
+                    None
+                }
+                Key::Alt => {
+                    self.alt = false;
+                    self.update_modifiers();
+                    None
+                }
+                Key::ControlLeft | Key::ControlRight => {
+                    self.ctrl = false;
+                    self.update_modifiers();
+                    None
+                }
+                Key::MetaLeft | Key::MetaRight => {
+                    self.meta = false;
+                    self.update_modifiers();
+                    None
+                }
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+
+    fn reset(&mut self) {
+        self.shift = false;
+        self.caps_lock = false;
+        self.alt = false;
+        self.ctrl = false;
+        self.meta = false;
+        self.update_modifiers();
+    }
+}
diff --git a/src/linux/wayland/keycodes.rs b/src/linux/wayland/keycodes.rs
new file mode 100644
index 00000000..d9da7497
--- /dev/null
+++ b/src/linux/wayland/keycodes.rs
@@ -0,0 +1,290 @@
+use crate::rdev::Key;
+use input_linux::Key as UKey;
+use std::os::raw::c_uint;
+
+macro_rules! decl_keycodes {
+    ($($key:ident, $code:literal),*) => {
+        pub const fn code_from_key(key: Key) -> Option<c_uint> {
+            match key {
+                $(
+                    Key::$key => Some($code),
+                )*
+                Key::Unknown(code) => Some(code),
+                _ => None,
+            }
+        }
+
+        pub const fn key_from_code(code: c_uint) -> Key {
+            match code {
+                $(
+                    $code => Key::$key,
+                )*
+                _ => Key::Unknown(code)
+            }
+        }
+    };
+}
+
+macro_rules! decl_keycodes_uinput {
+    ($($key:path, $ukey:path),*) => {
+        pub const fn ukey_from_key(key: Key) -> Option<UKey> {
+            match key {
+                $(
+                    $key => Some($ukey),
+                )*
+                Key::Unknown(code) => Some(unsafe { std::mem::transmute::<u16, UKey>(code as u16) }),
+                _ => None,
+            }
+        }
+
+        #[cfg(test)]
+        pub const fn key_from_ukey(code: UKey) -> Key {
+            match code {
+                $(
+                    $ukey => $key,
+                )*
+                ukey => Key::Unknown(unsafe { std::mem::transmute::<UKey, u16>(ukey) } as u32),
+            }
+        }
+    };
+}
+
+#[rustfmt::skip]
+decl_keycodes!(
+    Alt, 56,
+    AltGr, 126,
+    Backspace, 14,
+    CapsLock, 58,
+    ControlLeft, 29,
+    ControlRight, 97,
+    Delete, 110,
+    DownArrow, 108,
+    End, 107,
+    Escape, 1,
+    F1, 59,
+    F2, 60,
+    F3, 61,
+    F4, 62,
+    F5, 63,
+    F6, 64,
+    F7, 65,
+    F8, 66,
+    F9, 67,
+    F10, 68,
+    F11, 87,
+    F12, 88,
+    Home, 102,
+    LeftArrow, 105,
+    MetaLeft, 125,
+    PageDown, 109,
+    PageUp, 104,
+    Return, 28,
+    RightArrow, 106,
+    ShiftLeft, 42,
+    ShiftRight, 54,
+    Space, 57,
+    Tab, 15,
+    UpArrow, 103,
+    PrintScreen, 99,
+    ScrollLock, 70,
+    Pause, 119,
+    NumLock, 69,
+    BackQuote, 41,
+    Num1, 2,
+    Num2, 3,
+    Num3, 4,
+    Num4, 5,
+    Num5, 6,
+    Num6, 7,
+    Num7, 8,
+    Num8, 9,
+    Num9, 10,
+    Num0, 11,
+    Minus, 12,
+    Equal, 13,
+    KeyQ, 16,
+    KeyW, 17,
+    KeyE, 18,
+    KeyR, 19,
+    KeyT, 20,
+    KeyY, 21,
+    KeyU, 22,
+    KeyI, 23,
+    KeyO, 24,
+    KeyP, 25,
+    LeftBracket, 26,
+    RightBracket, 27,
+    KeyA, 30,
+    KeyS, 31,
+    KeyD, 32,
+    KeyF, 33,
+    KeyG, 34,
+    KeyH, 35,
+    KeyJ, 36,
+    KeyK, 37,
+    KeyL, 38,
+    SemiColon, 39,
+    Quote, 40,
+    BackSlash, 43,
+    IntlBackslash, 86,
+    KeyZ, 44,
+    KeyX, 45,
+    KeyC, 46,
+    KeyV, 47,
+    KeyB, 48,
+    KeyN, 49,
+    KeyM, 50,
+    Comma, 51,
+    Dot, 52,
+    Slash, 53,
+    Insert, 111,
+    KpReturn, 96,
+    KpMinus, 74,
+    KpPlus, 78,
+    KpMultiply, 55,
+    KpDivide, 98,
+    Kp0, 82,
+    Kp1, 79,
+    Kp2, 80,
+    Kp3, 81,
+    Kp4, 75,
+    Kp5, 76,
+    Kp6, 77,
+    Kp7, 71,
+    Kp8, 72,
+    Kp9, 73,
+    KpDelete, 83
+);
+
+#[rustfmt::skip]
+decl_keycodes_uinput!(
+    Key::Escape , UKey::Esc,
+    Key::Num1 , UKey::Num1,
+    Key::Num2 , UKey::Num2,
+    Key::Num3 , UKey::Num3,
+    Key::Num4 , UKey::Num4,
+    Key::Num5 , UKey::Num5,
+    Key::Num6 , UKey::Num6,
+    Key::Num7 , UKey::Num7,
+    Key::Num8 , UKey::Num8,
+    Key::Num9 , UKey::Num9,
+    Key::Num0 , UKey::Num0,
+    Key::Minus , UKey::Minus,
+    Key::Equal , UKey::Equal,
+    Key::Backspace , UKey::Backspace,
+    Key::Tab , UKey::Tab,
+    Key::KeyQ , UKey::Q,
+    Key::KeyW , UKey::W,
+    Key::KeyE , UKey::E,
+    Key::KeyR , UKey::R,
+    Key::KeyT , UKey::T,
+    Key::KeyY , UKey::Y,
+    Key::KeyU , UKey::U,
+    Key::KeyI , UKey::I,
+    Key::KeyO , UKey::O,
+    Key::KeyP , UKey::P,
+    Key::LeftBracket , UKey::LeftBrace,
+    Key::RightBracket , UKey::RightBrace,
+    Key::Return , UKey::Enter,
+    Key::ControlLeft , UKey::LeftCtrl,
+    Key::KeyA , UKey::A,
+    Key::KeyS , UKey::S,
+    Key::KeyD , UKey::D,
+    Key::KeyF , UKey::F,
+    Key::KeyG , UKey::G,
+    Key::KeyH , UKey::H,
+    Key::KeyJ , UKey::J,
+    Key::KeyK , UKey::K,
+    Key::KeyL , UKey::L,
+    Key::SemiColon , UKey::Semicolon,
+    Key::Quote , UKey::Apostrophe,
+    Key::BackQuote , UKey::Grave,
+    Key::ShiftLeft , UKey::LeftShift,
+    Key::BackSlash , UKey::Backslash,
+    Key::KeyZ , UKey::Z,
+    Key::KeyX , UKey::X,
+    Key::KeyC , UKey::C,
+    Key::KeyV , UKey::V,
+    Key::KeyB , UKey::B,
+    Key::KeyN , UKey::N,
+    Key::KeyM , UKey::M,
+    Key::Comma , UKey::Comma,
+    Key::Dot , UKey::Dot,
+    Key::Slash , UKey::Slash,
+    Key::ShiftRight , UKey::RightShift,
+    Key::KpMultiply , UKey::KpAsterisk,
+    Key::Alt , UKey::LeftAlt,
+    Key::Space , UKey::Space,
+    Key::CapsLock , UKey::CapsLock,
+    Key::F1 , UKey::F1,
+    Key::F2 , UKey::F2,
+    Key::F3 , UKey::F3,
+    Key::F4 , UKey::F4,
+    Key::F5 , UKey::F5,
+    Key::F6 , UKey::F6,
+    Key::F7 , UKey::F7,
+    Key::F8 , UKey::F8,
+    Key::F9 , UKey::F9,
+    Key::F10 , UKey::F10,
+    Key::NumLock , UKey::NumLock,
+    Key::ScrollLock , UKey::ScrollLock,
+    Key::Kp7 , UKey::Kp7,
+    Key::Kp8 , UKey::Kp8,
+    Key::Kp9 , UKey::Kp9,
+    Key::KpMinus , UKey::KpMinus,
+    Key::Kp4 , UKey::Kp4,
+    Key::Kp5 , UKey::Kp5,
+    Key::Kp6 , UKey::Kp6,
+    Key::KpPlus , UKey::KpPlus,
+    Key::Kp1 , UKey::Kp1,
+    Key::Kp2 , UKey::Kp2,
+    Key::Kp3 , UKey::Kp3,
+    Key::Kp0 , UKey::Kp0,
+    // Key::KpDelete , UKey::Delete,
+    Key::F11 , UKey::F11,
+    Key::F12 , UKey::F12,
+    Key::KpReturn , UKey::KpEnter,
+    Key::ControlRight , UKey::RightCtrl,
+    Key::KpDivide , UKey::KpSlash,
+    Key::AltGr , UKey::RightAlt,
+    Key::Home , UKey::Home,
+    Key::UpArrow , UKey::Up,
+    Key::PageUp , UKey::PageUp,
+    Key::LeftArrow , UKey::Left,
+    Key::RightArrow , UKey::Right,
+    Key::End , UKey::End,
+    Key::DownArrow , UKey::Down,
+    Key::PageDown , UKey::PageDown,
+    Key::Insert , UKey::Insert,
+    Key::Delete , UKey::Delete,
+    Key::Pause , UKey::Pause,
+    Key::MetaLeft , UKey::LeftMeta,
+    Key::PrintScreen , UKey::Print
+    //Key::IntlBackslash , UKey::Backslash
+);
+
+#[cfg(test)]
+mod test {
+    use super::{code_from_key, key_from_code, key_from_ukey, ukey_from_key, UKey};
+    #[test]
+    fn test_reversible() {
+        for code in 0..65636 {
+            let key = key_from_code(code);
+            match code_from_key(key) {
+                Some(code2) => assert_eq!(code, code2),
+                None => panic!("Could not convert back code: {:?}", code),
+            }
+        }
+    }
+
+    #[test]
+    fn test_reversible_uinput() {
+        for code in 0..u16::MAX {
+            let ukey = unsafe { std::mem::transmute::<u16, UKey>(code) };
+            let key = key_from_ukey(ukey);
+            if let Some(ukey2) = ukey_from_key(key) {
+                assert_eq!(ukey, ukey2, "Key conversion mismatch for code: {}", code);
+            }
+        }
+    }
+}
diff --git a/src/linux/wayland/listen.rs b/src/linux/wayland/listen.rs
new file mode 100644
index 00000000..4fec31d2
--- /dev/null
+++ b/src/linux/wayland/listen.rs
@@ -0,0 +1,105 @@
+extern crate libc;
+use super::keyboard::Keyboard;
+use super::keycodes::key_from_code;
+use crate::rdev::{Event, KeyboardState, ListenError};
+use crate::{Button, EventType};
+use input::event::keyboard::{KeyState, KeyboardEventTrait};
+use input::event::pointer::{Axis, ButtonState};
+use input::event::PointerEvent;
+use input::{Event as LibEvent, Libinput, LibinputInterface};
+use libc::{O_RDONLY, O_RDWR, O_WRONLY};
+use std::fs::{File, OpenOptions};
+use std::os::unix::{fs::OpenOptionsExt, io::OwnedFd};
+use std::path::Path;
+use std::time::{Duration, SystemTime};
+
+struct Interface;
+
+fn convert_type(libevent: LibEvent) -> Option<EventType> {
+    match libevent {
+        LibEvent::Keyboard(key) => {
+            let k = key_from_code(key.key());
+            let state: KeyState = key.key_state();
+            match state {
+                KeyState::Pressed => Some(EventType::KeyPress(k)),
+                KeyState::Released => Some(EventType::KeyRelease(k)),
+            }
+        }
+        LibEvent::Pointer(PointerEvent::Button(btn)) => {
+            let rdev_btn = match btn.button() {
+                272 => Some(Button::Left),
+                273 => Some(Button::Right),
+                274 => Some(Button::Middle),
+                _ => None,
+            };
+            if let Some(rdev_btn) = rdev_btn {
+                let state: ButtonState = btn.button_state();
+                match state {
+                    ButtonState::Pressed => Some(EventType::ButtonPress(rdev_btn)),
+                    ButtonState::Released => Some(EventType::ButtonRelease(rdev_btn)),
+                }
+            } else {
+                None
+            }
+        }
+        LibEvent::Pointer(PointerEvent::Motion(btn)) => Some(EventType::MouseMove {
+            // TODO Convert to absolute X, Y
+            x: btn.dx_unaccelerated(),
+            y: btn.dy_unaccelerated(),
+        }),
+        LibEvent::Pointer(PointerEvent::MotionAbsolute(btn)) => Some(EventType::MouseMove {
+            x: btn.absolute_x(),
+            y: btn.absolute_y(),
+        }),
+        LibEvent::Pointer(PointerEvent::ScrollWheel(btn)) => Some(EventType::Wheel {
+            delta_x: -(btn.scroll_value_v120(Axis::Horizontal) / 120.0) as i64,
+            delta_y: -(btn.scroll_value_v120(Axis::Vertical) / 120.0) as i64,
+        }),
+        _ => {
+            // dbg!(format!("Received unhandlded event {lib:?}"));
+            None
+        }
+    }
+}
+fn convert(keyboard: &mut Keyboard, libevent: LibEvent) -> Option<Event> {
+    let event_type = convert_type(libevent)?;
+    let name = keyboard.add(&event_type);
+    Some(Event {
+        time: SystemTime::now(),
+        name,
+        event_type,
+    })
+}
+
+impl LibinputInterface for Interface {
+    fn open_restricted(&mut self, path: &Path, flags: i32) -> Result<OwnedFd, i32> {
+        OpenOptions::new()
+            .custom_flags(flags)
+            .read((flags & O_RDONLY != 0) | (flags & O_RDWR != 0))
+            .write((flags & O_WRONLY != 0) | (flags & O_RDWR != 0))
+            .open(path)
+            .map(|file| file.into())
+            .map_err(|err| err.raw_os_error().unwrap())
+    }
+    fn close_restricted(&mut self, fd: OwnedFd) {
+        drop(File::from(fd));
+    }
+}
+
+pub fn listen<T>(mut callback: T) -> Result<(), ListenError>
+where
+    T: FnMut(Event) + 'static,
+{
+    let mut input = Libinput::new_with_udev(Interface);
+    input.udev_assign_seat("seat0").unwrap();
+    let mut keyboard = Keyboard::new().map_err(|_| ListenError::KeyboardError)?;
+    loop {
+        input.dispatch().unwrap();
+        for libevent in &mut input {
+            if let Some(event) = convert(&mut keyboard, libevent) {
+                callback(event);
+            }
+        }
+        std::thread::sleep(Duration::from_millis(1));
+    }
+}
diff --git a/src/linux/wayland/mod.rs b/src/linux/wayland/mod.rs
new file mode 100644
index 00000000..0d5b499b
--- /dev/null
+++ b/src/linux/wayland/mod.rs
@@ -0,0 +1,18 @@
+extern crate libc;
+
+mod common;
+mod display;
+#[cfg(feature = "unstable_grab")]
+mod grab;
+mod keyboard;
+mod keycodes;
+mod listen;
+mod simulate;
+mod xkb_keycodes;
+
+pub use self::display::display_size;
+#[cfg(feature = "unstable_grab")]
+pub use self::grab::grab;
+pub use self::keyboard::Keyboard;
+pub use self::listen::listen;
+pub use self::simulate::simulate;
diff --git a/src/linux/wayland/simulate.rs b/src/linux/wayland/simulate.rs
new file mode 100644
index 00000000..80ececec
--- /dev/null
+++ b/src/linux/wayland/simulate.rs
@@ -0,0 +1,168 @@
+use crate::linux::wayland::keycodes::ukey_from_key;
+use crate::rdev::{Button, EventType};
+use crate::SimulateError;
+use input_linux::{
+    EventKind, EventTime, InputEvent, InputId, Key as UKey, KeyEvent, KeyState, RelativeAxis,
+    RelativeEvent, SynchronizeEvent, SynchronizeKind, UInputHandle,
+};
+use libc::{input_event, O_NONBLOCK};
+use std::fs::{File, OpenOptions};
+use std::os::unix::fs::OpenOptionsExt;
+use std::sync::{LazyLock, Mutex};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+static HANDLE: LazyLock<Mutex<Option<UInputHandle<File>>>> = LazyLock::new(|| Mutex::new(None));
+
+pub struct Handle;
+
+impl Handle {
+    pub fn new() -> Self {
+        let mut handle = HANDLE.lock().unwrap();
+        if handle.is_none() {
+            let file = OpenOptions::new()
+                .write(true)
+                .custom_flags(O_NONBLOCK)
+                .open("/dev/uinput")
+                .unwrap();
+            let uinput = UInputHandle::new(file);
+            uinput.set_evbit(EventKind::Key).unwrap();
+            uinput.set_evbit(EventKind::Relative).unwrap();
+            uinput.set_relbit(RelativeAxis::X).unwrap();
+            uinput.set_relbit(RelativeAxis::Y).unwrap();
+            uinput.set_relbit(RelativeAxis::Wheel).unwrap();
+            uinput.set_relbit(RelativeAxis::WheelHiRes).unwrap();
+
+            // Enable all keys
+            for key in UKey::iter() {
+                uinput.set_keybit(key).unwrap();
+            }
+            // Enable all keys
+            for rel in RelativeAxis::iter() {
+                uinput.set_relbit(rel).unwrap();
+            }
+
+            let input_id = InputId {
+                bustype: input_linux::sys::BUS_VIRTUAL,
+                vendor: 0x1234,
+                product: 0x5678,
+                version: 1,
+            };
+            let device_name = b"rdev virtual input";
+            uinput.create(&input_id, device_name, 0, &[]).unwrap();
+            *handle = Some(uinput);
+        }
+        Handle
+    }
+
+    fn get_current_time() -> EventTime {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default();
+        EventTime::new(now.as_secs() as i64, now.subsec_micros() as i64)
+    }
+
+    fn send_key_event(
+        &self,
+        handle: &UInputHandle<File>,
+        ukey: UKey,
+        state: KeyState,
+    ) -> Result<(), SimulateError> {
+        let time = Self::get_current_time();
+        let event = KeyEvent::new(time, ukey, state);
+        let event: input_event = InputEvent::from(event).into();
+        let sync = SynchronizeEvent::new(time, SynchronizeKind::Report, 0);
+        let sync: input_event = InputEvent::from(sync).into();
+
+        handle.write(&[event, sync]).map_err(|_| SimulateError)?;
+        Ok(())
+    }
+
+    pub fn send(&self, event: &EventType) -> Result<(), SimulateError> {
+        let handle = HANDLE.lock().unwrap();
+        if let Some(handle) = handle.as_ref() {
+            match event {
+                EventType::KeyPress(key) => {
+                    if let Some(ukey) = ukey_from_key(*key) {
+                        self.send_key_event(handle, ukey, KeyState::PRESSED)?;
+                    }
+                }
+                EventType::KeyRelease(key) => {
+                    if let Some(ukey) = ukey_from_key(*key) {
+                        self.send_key_event(handle, ukey, KeyState::RELEASED)?;
+                    }
+                }
+                EventType::ButtonPress(button) => {
+                    let ukey = match button {
+                        Button::Left => UKey::ButtonLeft,
+                        Button::Right => UKey::ButtonRight,
+                        Button::Middle => UKey::ButtonMiddle,
+                        Button::Unknown(_) => return Err(SimulateError),
+                    };
+                    let time = Self::get_current_time();
+                    let event = KeyEvent::new(time, ukey, KeyState::PRESSED);
+                    let event: input_event = InputEvent::from(event).into();
+                    let sync = SynchronizeEvent::new(time, SynchronizeKind::Report, 0);
+                    let sync: input_event = InputEvent::from(sync).into();
+                    handle.write(&[event, sync]).map_err(|_| SimulateError)?;
+                }
+                EventType::ButtonRelease(button) => {
+                    let ukey = match button {
+                        Button::Left => UKey::ButtonLeft,
+                        Button::Right => UKey::ButtonRight,
+                        Button::Middle => UKey::ButtonMiddle,
+                        Button::Unknown(_) => return Err(SimulateError),
+                    };
+                    let time = Self::get_current_time();
+                    let event = KeyEvent::new(time, ukey, KeyState::RELEASED);
+                    let event: input_event = InputEvent::from(event).into();
+                    let sync = SynchronizeEvent::new(time, SynchronizeKind::Report, 0);
+                    let sync: input_event = InputEvent::from(sync).into();
+                    handle.write(&[event, sync]).map_err(|_| SimulateError)?;
+                }
+                EventType::MouseMove { x, y } => {
+                    let time = Self::get_current_time();
+                    // let reset_x = RelativeEvent::new(time, RelativeAxis::X, i32::MIN);
+                    // let reset_x: input_event = InputEvent::from(reset_x).into();
+                    // let reset_y = RelativeEvent::new(time, RelativeAxis::Y, i32::MIN);
+                    // let reset_y: input_event = InputEvent::from(reset_y).into();
+                    // let rsync = SynchronizeEvent::new(time, SynchronizeKind::Report, 0);
+                    // let rsync: input_event = InputEvent::from(rsync).into();
+                    // handle
+                    //     .write(&[reset_x, reset_y, rsync])
+                    //     .map_err(|_| SimulateError)?;
+
+                    let event_x = RelativeEvent::new(time, RelativeAxis::X, *x as i32);
+                    let event_x: input_event = InputEvent::from(event_x).into();
+                    let event_y = RelativeEvent::new(time, RelativeAxis::Y, *y as i32);
+                    let event_y: input_event = InputEvent::from(event_y).into();
+                    let sync = SynchronizeEvent::new(time, SynchronizeKind::Report, 0);
+                    let sync: input_event = InputEvent::from(sync).into();
+                    handle
+                        .write(&[event_x, event_y, sync])
+                        .map_err(|_| SimulateError)?;
+                }
+                EventType::Wheel { delta_x, delta_y } => {
+                    let time = Self::get_current_time();
+                    let event_x =
+                        RelativeEvent::new(time, RelativeAxis::WheelHiRes, (*delta_x * 120) as i32);
+                    let event_x: input_event = InputEvent::from(event_x).into();
+                    let event_y =
+                        RelativeEvent::new(time, RelativeAxis::WheelHiRes, (*delta_y * 120) as i32);
+                    let event_y: input_event = InputEvent::from(event_y).into();
+                    let sync = SynchronizeEvent::new(time, SynchronizeKind::Report, 0);
+                    let sync: input_event = InputEvent::from(sync).into();
+                    handle
+                        .write(&[event_x, event_y, sync])
+                        .map_err(|_| SimulateError)?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+pub fn simulate(event: &EventType) -> Result<(), SimulateError> {
+    let handle = Handle::new();
+    handle.send(event)?;
+    Ok(())
+}
diff --git a/src/linux/wayland/xkb_keycodes.rs b/src/linux/wayland/xkb_keycodes.rs
new file mode 100644
index 00000000..3f59a549
--- /dev/null
+++ b/src/linux/wayland/xkb_keycodes.rs
@@ -0,0 +1,7 @@
+use std::os::raw::c_uint;
+
+// Maps our internal keycodes to XKB keycodes
+pub fn internal_to_xkb_keycode(internal_code: c_uint) -> u32 {
+    // XKB keycodes start at 8, so we need to offset them
+    internal_code as u32 + 8
+}
diff --git a/src/linux/common.rs b/src/linux/x11/common.rs
similarity index 97%
rename from src/linux/common.rs
rename to src/linux/x11/common.rs
index 94ecbb99..95e786ae 100644
--- a/src/linux/common.rs
+++ b/src/linux/x11/common.rs
@@ -1,5 +1,5 @@
-use crate::linux::keyboard::Keyboard;
-use crate::linux::keycodes::key_from_code;
+use super::keyboard::Keyboard;
+use super::keycodes::key_from_code;
 use crate::rdev::{Button, Event, EventType, KeyboardState};
 use std::convert::TryInto;
 use std::os::raw::{c_int, c_uchar, c_uint};
diff --git a/src/linux/display.rs b/src/linux/x11/display.rs
similarity index 85%
rename from src/linux/display.rs
rename to src/linux/x11/display.rs
index d50e91f7..b717357d 100644
--- a/src/linux/display.rs
+++ b/src/linux/x11/display.rs
@@ -1,4 +1,4 @@
-use crate::linux::common::Display;
+use super::common::Display;
 use crate::rdev::DisplayError;
 
 pub fn display_size() -> Result<(u64, u64), DisplayError> {
diff --git a/src/linux/grab.rs b/src/linux/x11/grab.rs
similarity index 99%
rename from src/linux/grab.rs
rename to src/linux/x11/grab.rs
index 7b2f4795..0f241053 100644
--- a/src/linux/grab.rs
+++ b/src/linux/x11/grab.rs
@@ -1,5 +1,5 @@
-use crate::linux::common::Display;
-use crate::linux::keyboard::Keyboard;
+use super::common::Display;
+use super::keyboard::Keyboard;
 use crate::rdev::{Button, Event, EventType, GrabError, Key, KeyboardState};
 use epoll::ControlOptions::{EPOLL_CTL_ADD, EPOLL_CTL_DEL};
 use evdev_rs::{
@@ -367,7 +367,7 @@ where
                     add_device_to_epoll_from_inotify_event(epoll_fd, event, &mut devices)?;
                 }
             } else {
-                // Input device recieved event
+                // Input device received event
                 let device_idx = event.data as usize;
                 let device = devices.get(device_idx).unwrap();
                 while device.has_event_pending() {
diff --git a/src/linux/keyboard.rs b/src/linux/x11/keyboard.rs
similarity index 99%
rename from src/linux/keyboard.rs
rename to src/linux/x11/keyboard.rs
index 795ca238..52cf33ac 100644
--- a/src/linux/keyboard.rs
+++ b/src/linux/x11/keyboard.rs
@@ -1,5 +1,5 @@
 extern crate x11;
-use crate::linux::keycodes::code_from_key;
+use super::keycodes::code_from_key;
 use crate::rdev::{EventType, Key, KeyboardState};
 use std::ffi::CString;
 use std::os::raw::{c_char, c_int, c_uint, c_ulong, c_void};
diff --git a/src/linux/keycodes.rs b/src/linux/x11/keycodes.rs
similarity index 100%
rename from src/linux/keycodes.rs
rename to src/linux/x11/keycodes.rs
diff --git a/src/linux/listen.rs b/src/linux/x11/listen.rs
similarity index 97%
rename from src/linux/listen.rs
rename to src/linux/x11/listen.rs
index ac304451..46667c7a 100644
--- a/src/linux/listen.rs
+++ b/src/linux/x11/listen.rs
@@ -1,7 +1,7 @@
 extern crate libc;
 extern crate x11;
-use crate::linux::common::{convert, FALSE, KEYBOARD};
-use crate::linux::keyboard::Keyboard;
+use super::common::{convert, FALSE, KEYBOARD};
+use super::keyboard::Keyboard;
 use crate::rdev::{Event, ListenError};
 use std::convert::TryInto;
 use std::ffi::CStr;
diff --git a/src/linux/x11/mod.rs b/src/linux/x11/mod.rs
new file mode 100644
index 00000000..9dfb5291
--- /dev/null
+++ b/src/linux/x11/mod.rs
@@ -0,0 +1,18 @@
+extern crate libc;
+extern crate x11;
+
+mod common;
+mod display;
+#[cfg(feature = "unstable_grab")]
+mod grab;
+mod keyboard;
+mod keycodes;
+mod listen;
+mod simulate;
+
+pub use display::display_size;
+#[cfg(feature = "unstable_grab")]
+pub use grab::grab;
+pub use keyboard::Keyboard;
+pub use listen::listen;
+pub use simulate::simulate;
diff --git a/src/linux/simulate.rs b/src/linux/x11/simulate.rs
similarity index 97%
rename from src/linux/simulate.rs
rename to src/linux/x11/simulate.rs
index a846ccea..a2cc93a3 100644
--- a/src/linux/simulate.rs
+++ b/src/linux/x11/simulate.rs
@@ -1,5 +1,5 @@
-use crate::linux::common::{FALSE, TRUE};
-use crate::linux::keycodes::code_from_key;
+use super::common::{FALSE, TRUE};
+use super::keycodes::code_from_key;
 use crate::rdev::{Button, EventType, SimulateError};
 use std::os::raw::c_int;
 use std::ptr::null;
diff --git a/src/macos/common.rs b/src/macos/common.rs
index 62bd40ec..1eabb635 100644
--- a/src/macos/common.rs
+++ b/src/macos/common.rs
@@ -34,8 +34,8 @@ pub enum CGEventTapOption {
     ListenOnly = 1,
 }
 
-pub static mut LAST_FLAGS: CGEventFlags = CGEventFlags::CGEventFlagNull;
 lazy_static! {
+    pub static ref LAST_FLAGS: Mutex<CGEventFlags> = Mutex::new(CGEventFlags::CGEventFlagNull);
     pub static ref KEYBOARD_STATE: Mutex<Keyboard> = Mutex::new(Keyboard::new().unwrap());
 }
 
@@ -128,22 +128,64 @@ pub unsafe fn convert(
         }
         CGEventType::KeyDown => {
             let code = cg_event.get_integer_value_field(EventField::KEYBOARD_EVENT_KEYCODE);
-            Some(EventType::KeyPress(key_from_code(code.try_into().ok()?)))
+            let key = key_from_code(code.try_into().ok()?);
+            Some(EventType::KeyPress(key))
         }
         CGEventType::KeyUp => {
             let code = cg_event.get_integer_value_field(EventField::KEYBOARD_EVENT_KEYCODE);
-            Some(EventType::KeyRelease(key_from_code(code.try_into().ok()?)))
+            let key = key_from_code(code.try_into().ok()?);
+            Some(EventType::KeyRelease(key))
         }
         CGEventType::FlagsChanged => {
             let code = cg_event.get_integer_value_field(EventField::KEYBOARD_EVENT_KEYCODE);
             let code = code.try_into().ok()?;
             let flags = cg_event.get_flags();
-            if flags < LAST_FLAGS {
-                LAST_FLAGS = flags;
-                Some(EventType::KeyRelease(key_from_code(code)))
+            let key = key_from_code(code);
+
+            // Determine if this is a press or release based on flag changes
+            let mut global_flags = LAST_FLAGS.lock().unwrap();
+            if flags.contains(CGEventFlags::CGEventFlagShift)
+                && !global_flags.contains(CGEventFlags::CGEventFlagShift)
+            {
+                *global_flags = flags;
+                Some(EventType::KeyPress(key))
+            } else if !flags.contains(CGEventFlags::CGEventFlagShift)
+                && global_flags.contains(CGEventFlags::CGEventFlagShift)
+            {
+                *global_flags = flags;
+                Some(EventType::KeyRelease(key))
+            } else if flags.contains(CGEventFlags::CGEventFlagControl)
+                && !global_flags.contains(CGEventFlags::CGEventFlagControl)
+            {
+                *global_flags = flags;
+                Some(EventType::KeyPress(key))
+            } else if !flags.contains(CGEventFlags::CGEventFlagControl)
+                && global_flags.contains(CGEventFlags::CGEventFlagControl)
+            {
+                *global_flags = flags;
+                Some(EventType::KeyRelease(key))
+            } else if flags.contains(CGEventFlags::CGEventFlagAlternate)
+                && !global_flags.contains(CGEventFlags::CGEventFlagAlternate)
+            {
+                *global_flags = flags;
+                Some(EventType::KeyPress(key))
+            } else if !flags.contains(CGEventFlags::CGEventFlagAlternate)
+                && global_flags.contains(CGEventFlags::CGEventFlagAlternate)
+            {
+                *global_flags = flags;
+                Some(EventType::KeyRelease(key))
+            } else if flags.contains(CGEventFlags::CGEventFlagCommand)
+                && !global_flags.contains(CGEventFlags::CGEventFlagCommand)
+            {
+                *global_flags = flags;
+                Some(EventType::KeyPress(key))
+            } else if !flags.contains(CGEventFlags::CGEventFlagCommand)
+                && global_flags.contains(CGEventFlags::CGEventFlagCommand)
+            {
+                *global_flags = flags;
+                Some(EventType::KeyRelease(key))
             } else {
-                LAST_FLAGS = flags;
-                Some(EventType::KeyPress(key_from_code(code)))
+                None
             }
         }
         CGEventType::ScrollWheel => {
diff --git a/src/macos/listen.rs b/src/macos/listen.rs
index 3a4ac811..59754358 100644
--- a/src/macos/listen.rs
+++ b/src/macos/listen.rs
@@ -13,15 +13,13 @@ extern "C" {}
 
 unsafe extern "C" fn raw_callback(
     _proxy: CGEventTapProxy,
-    _type: CGEventType,
+    event_type: CGEventType,
     cg_event: CGEventRef,
     _user_info: *mut c_void,
 ) -> CGEventRef {
-    // println!("Event ref {:?}", cg_event_ptr);
-    // let cg_event: CGEvent = transmute_copy::<*mut c_void, CGEvent>(&cg_event_ptr);
     let opt = KEYBOARD_STATE.lock();
     if let Ok(mut keyboard) = opt {
-        if let Some(event) = convert(_type, &cg_event, &mut keyboard) {
+        if let Some(event) = convert(event_type, &cg_event, &mut keyboard) {
             // Reborrowing the global callback pointer.
             // Totally UB. but not sure there's a great alternative.
             let ptr = &raw mut GLOBAL_CALLBACK;
@@ -30,8 +28,6 @@ unsafe extern "C" fn raw_callback(
             }
         }
     }
-    // println!("Event ref END {:?}", cg_event_ptr);
-    // cg_event_ptr
     cg_event
 }
 
diff --git a/src/macos/simulate.rs b/src/macos/simulate.rs
index 6242e195..c030ed24 100644
--- a/src/macos/simulate.rs
+++ b/src/macos/simulate.rs
@@ -1,11 +1,14 @@
 use crate::rdev::{Button, EventType, SimulateError};
+use crate::Key;
 use core_graphics::event::{
-    CGEvent, CGEventTapLocation, CGEventType, CGMouseButton, ScrollEventUnit,
+    CGEvent, CGEventFlags, CGEventTapLocation, CGEventType, CGMouseButton, EventField,
+    ScrollEventUnit,
 };
 use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
 use core_graphics::geometry::CGPoint;
 use std::convert::TryInto;
 
+use crate::macos::common::LAST_FLAGS;
 use crate::macos::keycodes::code_from_key;
 
 unsafe fn convert_native_with_source(
@@ -15,11 +18,71 @@ unsafe fn convert_native_with_source(
     match event_type {
         EventType::KeyPress(key) => {
             let code = code_from_key(*key)?;
-            CGEvent::new_keyboard_event(source, code, true).ok()
+            // For modifier keys, we need to use FlagsChanged event type
+            if is_modifier_key(*key) {
+                let event = CGEvent::new(source).ok()?;
+                event.set_type(CGEventType::FlagsChanged);
+                event.set_integer_value_field(EventField::KEYBOARD_EVENT_KEYCODE, code as i64);
+
+                // Get current flags and update them
+                let mut new_flags = LAST_FLAGS.lock().unwrap();
+                match key {
+                    Key::ShiftLeft | Key::ShiftRight => {
+                        new_flags.insert(CGEventFlags::CGEventFlagShift);
+                    }
+                    Key::ControlLeft | Key::ControlRight => {
+                        new_flags.insert(CGEventFlags::CGEventFlagControl);
+                    }
+                    Key::AltGr | Key::Alt => {
+                        new_flags.insert(CGEventFlags::CGEventFlagAlternate);
+                    }
+                    Key::MetaLeft | Key::MetaRight => {
+                        new_flags.insert(CGEventFlags::CGEventFlagCommand);
+                    }
+                    _ => {}
+                }
+                event.set_flags(*new_flags);
+                Some(event)
+            } else {
+                // For non-modifier keys, use regular key events
+                let event = CGEvent::new_keyboard_event(source, code, true).ok()?;
+                event.set_flags(*LAST_FLAGS.lock().unwrap());
+                Some(event)
+            }
         }
         EventType::KeyRelease(key) => {
             let code = code_from_key(*key)?;
-            CGEvent::new_keyboard_event(source, code, false).ok()
+            // For modifier keys, we need to use FlagsChanged event type
+            if is_modifier_key(*key) {
+                let event = CGEvent::new(source).ok()?;
+                event.set_type(CGEventType::FlagsChanged);
+                event.set_integer_value_field(EventField::KEYBOARD_EVENT_KEYCODE, code as i64);
+
+                // Get current flags and update them
+                let mut new_flags = LAST_FLAGS.lock().unwrap();
+                match key {
+                    Key::ShiftLeft | Key::ShiftRight => {
+                        new_flags.remove(CGEventFlags::CGEventFlagShift);
+                    }
+                    Key::ControlLeft | Key::ControlRight => {
+                        new_flags.remove(CGEventFlags::CGEventFlagControl);
+                    }
+                    Key::AltGr | Key::Alt => {
+                        new_flags.remove(CGEventFlags::CGEventFlagAlternate);
+                    }
+                    Key::MetaLeft | Key::MetaRight => {
+                        new_flags.remove(CGEventFlags::CGEventFlagCommand);
+                    }
+                    _ => {}
+                }
+                event.set_flags(*new_flags);
+                Some(event)
+            } else {
+                // For non-modifier keys, use regular key events
+                let event = CGEvent::new_keyboard_event(source, code, false).ok()?;
+                event.set_flags(*LAST_FLAGS.lock().unwrap());
+                Some(event)
+            }
         }
         EventType::ButtonPress(button) => {
             let point = get_current_mouse_location()?;
@@ -82,6 +145,20 @@ unsafe fn get_current_mouse_location() -> Option<CGPoint> {
     Some(event.location())
 }
 
+fn is_modifier_key(key: Key) -> bool {
+    matches!(
+        key,
+        Key::ShiftLeft
+            | Key::ShiftRight
+            | Key::ControlLeft
+            | Key::ControlRight
+            | Key::Alt
+            | Key::AltGr
+            | Key::MetaLeft
+            | Key::MetaRight
+    )
+}
+
 #[link(name = "Cocoa", kind = "framework")]
 extern "C" {}
 
diff --git a/tests/listen_and_simulate.rs b/tests/listen_and_simulate.rs
index 03b9809d..77edb501 100644
--- a/tests/listen_and_simulate.rs
+++ b/tests/listen_and_simulate.rs
@@ -1,42 +1,26 @@
-use lazy_static::lazy_static;
-use rdev::{listen, simulate, Button, Event, EventType, Key};
+use rdev::{listen, simulate, Button, EventType, Key};
 use serial_test::serial;
 use std::error::Error;
 use std::iter::Iterator;
-use std::sync::mpsc::{channel, Receiver, Sender};
-use std::sync::Mutex;
+use std::sync::mpsc::channel;
 use std::thread;
 use std::time::Duration;
 
-lazy_static! {
-    static ref EVENT_CHANNEL: (Mutex<Sender<Event>>, Mutex<Receiver<Event>>) = {
-        let (send, recv) = channel();
-        (Mutex::new(send), Mutex::new(recv))
-    };
-}
-
-fn send_event(event: Event) {
-    EVENT_CHANNEL
-        .0
-        .lock()
-        .expect("Failed to unlock Mutex")
-        .send(event)
-        .expect("Receiving end of EVENT_CHANNEL was closed");
-}
-
 fn sim_then_listen(events: &mut dyn Iterator<Item = EventType>) -> Result<(), Box<dyn Error>> {
+    let (send, recv) = channel();
     // spawn new thread because listen blocks
     let _listener = thread::spawn(move || {
-        listen(send_event).expect("Could not listen");
+        listen(move |event| send.send(event).unwrap()).expect("Could not listen");
     });
     let second = Duration::from_millis(1000);
     thread::sleep(second);
 
-    let recv = EVENT_CHANNEL.1.lock()?;
     for event in events {
         simulate(&event)?;
-        let recieved_event = recv.recv_timeout(second).expect("No events to recieve");
-        assert_eq!(recieved_event.event_type, event);
+        let received_event = recv
+            .recv_timeout(second)
+            .unwrap_or_else(|_| panic!("{}", "No events to receive {event:?}"));
+        assert_eq!(received_event.event_type, event);
     }
     Ok(())
 }
@@ -47,10 +31,15 @@ fn test_listen_and_simulate() -> Result<(), Box<dyn Error>> {
     // wait for user input from keyboard to stop
     // (i.e. the return/enter keypress to run test command)
     thread::sleep(Duration::from_millis(50));
+    // On wayland we need to open libuinput and the hooks take
+    // some time to install, this forces the handle to get installed
+    simulate(&EventType::MouseMove { x: 0.0, y: 0.0 })?;
+    thread::sleep(Duration::from_millis(50));
 
     let events = vec![
         //TODO: fix sending shift keypress events on linux
-        //EventType::KeyPress(Key::ShiftLeft),
+        EventType::KeyPress(Key::ShiftLeft),
+        EventType::KeyRelease(Key::ShiftLeft),
         EventType::KeyPress(Key::KeyS),
         EventType::KeyRelease(Key::KeyS),
         EventType::ButtonPress(Button::Right),
@@ -65,7 +54,7 @@ fn test_listen_and_simulate() -> Result<(), Box<dyn Error>> {
         },
     ]
     .into_iter();
-    let click_events = (0..480).map(|pixel| EventType::MouseMove {
+    let click_events = (1..480).map(|pixel| EventType::MouseMove {
         x: pixel as f64,
         y: pixel as f64,
     });