diff --git a/src/backend.rs b/src/backend.rs
deleted file mode 100644
index ab520b2..0000000
--- a/src/backend.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use std::sync::mpsc::Sender;
-
-use crate::{AppEvent, KbtError};
-
-pub trait KeyBackend {
-    fn subscribe(&self, sender: Sender<AppEvent>) -> Result<(), KbtError>;
-}
diff --git a/src/linux.rs b/src/generic_backend.rs
similarity index 68%
rename from src/linux.rs
rename to src/generic_backend.rs
index 93e007a..f1bd403 100644
--- a/src/linux.rs
+++ b/src/generic_backend.rs
@@ -1,58 +1,45 @@
-use std::{
-    sync::{mpsc::Sender, Arc, Mutex},
-    thread,
-};
+use std::sync::{mpsc::Sender, Arc, Mutex};
+
+use device_query_revamped::{CallbackGuard, DeviceEvents, DeviceState, Keycode};
 
 use crate::{
-    backend::KeyBackend,
     key::Key,
     model::{AppEvent, KeyEventType},
 };
-use device_query_revamped::{DeviceEvents, DeviceState, Keycode};
-
-pub struct X11;
 
-impl KeyBackend for X11 {
-    fn subscribe(&self, sender: Sender<AppEvent>) -> Result<(), crate::model::KbtError> {
-        let shared_sender = Arc::new(Mutex::new(sender.clone()));
+pub struct GenericKeyBackend;
 
-        thread::spawn(move || {
-            let device_state = DeviceState::new();
-            let _guard = device_state.on_key_down(move |keycode| {
-                shared_sender
-                    .lock()
-                    .unwrap()
-                    .send(AppEvent::KeyEvent(KeyEventType::KeyPressed(map_keycode(
-                        keycode,
-                    ))))
-                    .map_err(|err| log::error!("Key down channel died {}", err))
-                    .unwrap();
-                ()
-            });
+type KeycodeCallback = Box<dyn Fn(&Keycode) -> () + Send + Sync + 'static>;
+type KeyStreamGuard = CallbackGuard<KeycodeCallback>;
 
-            loop {}
-        });
+impl GenericKeyBackend {
+    pub fn subscribe(sender: &Sender<AppEvent>) -> (KeyStreamGuard, KeyStreamGuard) {
+        let device_state = DeviceState::new();
+        let shared_sender = Arc::new(Mutex::new(sender.clone()));
 
-        let shared_sender = Arc::new(Mutex::new(sender));
+        let key_up_guard: KeyStreamGuard = device_state.on_key_up(Box::new(move |keycode| {
+            let _ = shared_sender
+                .lock()
+                .unwrap()
+                .send(AppEvent::KeyEvent(KeyEventType::KeyReleased(map_keycode(
+                    keycode,
+                ))))
+                .map_err(|err| log::error!("Key down channel died {}", err));
+        }));
 
-        thread::spawn(move || {
-            let device_state = DeviceState::new();
-            let _guard = device_state.on_key_up(move |keycode| {
-                shared_sender
-                    .lock()
-                    .unwrap()
-                    .send(AppEvent::KeyEvent(KeyEventType::KeyReleased(map_keycode(
-                        keycode,
-                    ))))
-                    .map_err(|err| log::error!("Key up channel died {}", err))
-                    .unwrap();
-                ()
-            });
+        let shared_sender = Arc::new(Mutex::new(sender.clone()));
 
-            loop {}
-        });
+        let key_down_guard: KeyStreamGuard = device_state.on_key_down(Box::new(move |keycode| {
+            let _ = shared_sender
+                .lock()
+                .unwrap()
+                .send(AppEvent::KeyEvent(KeyEventType::KeyPressed(map_keycode(
+                    keycode,
+                ))))
+                .map_err(|err| log::error!("Key down channel died {}", err));
+        }));
 
-        Ok(())
+        (key_up_guard, key_down_guard)
     }
 }
 
diff --git a/src/main.rs b/src/main.rs
index d5409e9..32544cb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,11 +1,10 @@
-mod backend;
 mod key;
 mod keyboard60;
 mod keyboard80;
-mod linux;
 mod menu;
 mod model;
 mod view;
+mod generic_backend;
 
 use std::{
     collections::HashMap,
@@ -14,13 +13,12 @@ use std::{
     thread,
 };
 
-use backend::KeyBackend;
 use crossterm::{
     event::{self, DisableMouseCapture, Event, KeyCode, KeyModifiers},
     execute,
     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
 };
-use linux::X11;
+use generic_backend::GenericKeyBackend;
 use model::*;
 use ratatui::{
     backend::{Backend, CrosstermBackend},
@@ -58,7 +56,7 @@ fn run() -> Result<(), KbtError> {
         MenuResult::Terminate => Ok(()),
         MenuResult::KeyboardSelected(selection) => {
             let (sender, receiver): (Sender<AppEvent>, Receiver<AppEvent>) = channel();
-            X11.subscribe(sender.clone()).unwrap();
+            let (_up_guard, _down_guard) = GenericKeyBackend::subscribe(&sender);
             thread::spawn(move || listen_for_control(sender).unwrap());
 
             let initial_app = App {