diff --git a/.github/workflows/Release-Windows.yml b/.github/workflows/Release-Windows.yml
index 7ca6e9f..925701f 100644
--- a/.github/workflows/Release-Windows.yml
+++ b/.github/workflows/Release-Windows.yml
@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        target: ["x86_64-pc-windows-gnu"] # Waiting for `aarch64-pc-windows-gnu` to be available.
+        target: ["x86_64-pc-windows-gnu"]
 
     steps:
       - name: "Checkout"
@@ -31,10 +31,10 @@ jobs:
       - name: "Zip"
         run: |
           cp target/${{ matrix.target }}/release/dygma-layer-switcher.exe .
-          zip windows-${{ github.ref_name }}-${{ matrix.target }}.zip readme.md dygma-layer-switcher.exe assets/icons/icon.ico
+          zip dls-${{ github.ref_name }}-${{ matrix.target }}.zip dygma-layer-switcher.exe
 
       - name: "Release"
         uses: softprops/action-gh-release@v1
         with:
           files: |
-            windows-${{ github.ref_name }}-${{ matrix.target }}.zip
+            dls-${{ github.ref_name }}-${{ matrix.target }}.zip
diff --git a/.github/workflows/Validate.yml b/.github/workflows/Validate.yml
index 2ae35e1..f8ad9ed 100644
--- a/.github/workflows/Validate.yml
+++ b/.github/workflows/Validate.yml
@@ -10,8 +10,8 @@ env:
   APT_PACKAGES: libatk1.0-dev libpango1.0-dev libgtk-3-dev libudev-dev libxdo-dev
 
 jobs:
-  formatting:
-    name: "Format"
+  checks:
+    name: "Checks"
     runs-on: ubuntu-latest
 
     steps:
@@ -22,52 +22,13 @@ jobs:
         uses: dtolnay/rust-toolchain@stable
         with:
           toolchain: stable
-          components: rustfmt
-
-      - name: "Format"
-        run: cargo fmt -- --check
-
-  clippy:
-    name: "Clippy"
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: "Checkout"
-        uses: actions/checkout@master
-
-      - name: "Rust"
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: stable
-          components: clippy
+          components: rustfmt, clippy
 
       - name: "Dependencies"
         run: sudo apt-get install -y ${{ env.APT_PACKAGES }}
 
+      - name: "Format"
+        run: cargo fmt -- --check
+
       - name: "Clippy"
         run: cargo clippy -- -D warnings
-
-  check:
-    name: "Check"
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        target: ["x86_64-pc-windows-gnu", "x86_64-unknown-linux-gnu"]
-
-    steps:
-      - name: "Checkout"
-        uses: actions/checkout@master
-
-      - name: "Rust"
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          toolchain: stable
-          targets: ${{ matrix.target }}
-
-      - name: "Dependencies"
-        if: contains(matrix.target, 'linux')
-        run: sudo apt-get install -y ${{ env.APT_PACKAGES }}
-
-      - name: "Check"
-        run: cargo check --target ${{ matrix.target }}
diff --git a/.run/Debug.run.xml b/.run/Debug.run.xml
index 15fd48d..9a1dc0f 100644
--- a/.run/Debug.run.xml
+++ b/.run/Debug.run.xml
@@ -1,6 +1,6 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Debug" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
-    <option name="command" value="run --features no-admin" />
+    <option name="command" value="run --bin dygma-layer-switcher" />
     <option name="workingDirectory" value="file://$PROJECT_DIR$" />
     <option name="emulateTerminal" value="true" />
     <option name="channel" value="DEFAULT" />
diff --git a/Cargo.toml b/Cargo.toml
index 3f6ea2a..b838745 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,8 +2,6 @@
 resolver = "2"
 members = [
     "dygma-layer-switcher",
-    "common",
-    "windows",
 ]
 
 [profile.release]
diff --git a/common/Cargo.toml b/common/Cargo.toml
deleted file mode 100644
index c77acd8..0000000
--- a/common/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "common"
-version = "0.1.0"
-edition = "2021"
-authors = ["Matthew Wilding <mbwilding@gmail.com>"]
-
-[dependencies]
-dygma_focus = { git = "https://github.com/mbwilding/dygma-focus-api-rs" }
-anyhow = "1.0"
-log = "0.4"
-single-instance = "0.3"
-serde = { version = "1.0", features = ["derive"] }
-serde_yaml = "0.9"
-sysinfo = "0.29"
-tracing = "0.1"
diff --git a/common/src/app.rs b/common/src/app.rs
deleted file mode 100644
index efc192e..0000000
--- a/common/src/app.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Default, Clone, Deserialize, Serialize)]
-pub struct AppDetails {
-    pub window: Option<String>,
-    pub process: Option<String>,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct Layer {
-    pub layer: u8,
-    pub apps: Vec<AppConfig>,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct AppConfig {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub window: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub process: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub parent: Option<Parent>,
-}
-
-#[derive(Default, Debug, Clone, Deserialize, Serialize)]
-pub struct Parent {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub process: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub excludes: Option<Vec<String>>,
-}
diff --git a/common/src/config.rs b/common/src/config.rs
deleted file mode 100644
index 471b1d2..0000000
--- a/common/src/config.rs
+++ /dev/null
@@ -1,256 +0,0 @@
-use crate::app::{AppConfig, AppDetails, Layer, Parent};
-use serde::{Deserialize, Serialize};
-use std::fs::File;
-use std::io;
-use std::io::{Read, Write};
-use sysinfo::{Process, ProcessExt, System, SystemExt};
-use tracing::{error, trace, warn};
-
-const CONFIG_PATH: &str = "config.yml";
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Config {
-    pub logging: Option<bool>,
-    pub comm_port: Option<String>,
-    pub base_layer: Option<u8>,
-    pub mappings: Option<Vec<Layer>>,
-}
-
-impl Default for Config {
-    fn default() -> Self {
-        let focus = dygma_focus::Focus::default();
-
-        let device = focus.find_first().unwrap_or_else(|e| {
-            error!(
-                "Connect a Dygma keyboard and restart the application: {:?}",
-                e
-            );
-            std::process::exit(1);
-        });
-
-        Config {
-            logging: Some(false),
-            comm_port: Some(device.port),
-            base_layer: Some(1),
-            mappings: Some(vec![]),
-        }
-    }
-}
-
-impl Config {
-    pub fn load() -> Config {
-        let file = File::open(CONFIG_PATH);
-        let config = match file {
-            Ok(mut f) => {
-                let mut contents = String::new();
-                match f.read_to_string(&mut contents) {
-                    Ok(_) => match serde_yaml::from_str(&contents) {
-                        Ok(data) => {
-                            trace!("Config loaded");
-                            data
-                        }
-                        Err(e) => {
-                            error!("Error parsing config file: {:?}", e);
-                            Config::default()
-                        }
-                    },
-                    Err(e) => {
-                        error!("Error reading config file: {:?}", e);
-                        Config::default()
-                    }
-                }
-            }
-            Err(_) => {
-                warn!("No config file found, creating with default config");
-                let default_config = Config::default();
-                match File::create(CONFIG_PATH) {
-                    Ok(mut file) => match serde_yaml::to_string(&default_config) {
-                        Ok(yaml) => {
-                            if let Err(e) = file.write_all(yaml.as_bytes()) {
-                                error!("Failed to write default config to file: {:?}", e);
-                            }
-                        }
-                        Err(e) => {
-                            error!("Failed to serialize default config: {:?}", e);
-                        }
-                    },
-                    Err(e) => {
-                        error!("Failed to create config file: {:?}", e);
-                    }
-                }
-
-                default_config
-            }
-        };
-
-        config
-    }
-
-    pub fn add(&mut self) {
-        if let Some(mappings) = self.mappings.as_mut() {
-            mappings.push(Layer::default());
-        } else {
-            error!("Mappings not initialized");
-        }
-    }
-
-    pub fn remove(&mut self, index: usize) {
-        if let Some(mappings) = self.mappings.as_mut() {
-            if index < mappings.len() {
-                mappings.remove(index);
-            }
-        } else {
-            error!("Mappings not initialized");
-        }
-    }
-
-    pub fn save(&self) {
-        match File::create(CONFIG_PATH) {
-            Ok(file) => {
-                let mut writer = io::BufWriter::new(file);
-                if let Err(e) = serde_yaml::to_writer(&mut writer, &self) {
-                    error!("Failed to serialize config: {:?}", e);
-                }
-                if let Err(e) = writer.flush() {
-                    error!("Failed to write config to file: {:?}", e);
-                }
-            }
-            Err(e) => {
-                error!("Failed to create config file: {:?}", e);
-            }
-        }
-    }
-
-    pub fn check_process(&self, app_details: &AppDetails) -> Option<u8> {
-        app_details
-            .process
-            .as_ref()
-            .and_then(|x| self.match_property_opt_string(x, |mapping| &mapping.process))
-    }
-
-    pub fn check_window(&self, app_details: &AppDetails) -> Option<u8> {
-        app_details
-            .window
-            .as_ref()
-            .and_then(|x| self.match_property_opt_string(x, |mapping| &mapping.window))
-    }
-
-    pub fn check_parent(&self, app_details: &AppDetails) -> Option<u8> {
-        if let Some(process) = &app_details.process {
-            let mut sys = System::new();
-            sys.refresh_processes();
-
-            if let Some((_, proc)) = sys
-                .processes()
-                .iter()
-                .find(|(_, proc)| proc.name().to_lowercase().contains(&process.to_lowercase()))
-            {
-                return self.check_parent_recursively(proc, &sys, |mapping| &mapping.parent, 0);
-            }
-        }
-
-        None
-    }
-
-    fn is_process_excluded(&self, process: &str, parent_process: &str) -> bool {
-        if let Some(layers) = &self.mappings {
-            layers.iter().any(|layer| {
-                layer.apps.iter().any(|app| {
-                    if let Some(parent) = &app.parent {
-                        if let Some(parent_process_name) = &parent.process {
-                            if parent_process_name
-                                .to_lowercase()
-                                .contains(&parent_process.to_lowercase())
-                            {
-                                if let Some(excludes) = &parent.excludes {
-                                    return excludes.iter().any(|excluded_process| {
-                                        excluded_process
-                                            .to_lowercase()
-                                            .contains(&process.to_lowercase())
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    false
-                })
-            })
-        } else {
-            false
-        }
-    }
-
-    fn check_parent_recursively<F>(
-        &self,
-        proc: &Process,
-        sys: &System,
-        mapping_property: F,
-        level: usize,
-    ) -> Option<u8>
-    where
-        F: Fn(&AppConfig) -> &Option<Parent> + Copy,
-    {
-        if let Some(parent_pid) = proc.parent() {
-            if let Some(parent_proc) = sys.processes().get(&parent_pid) {
-                if level > 0 && self.is_process_excluded(proc.name(), parent_proc.name()) {
-                    return None;
-                }
-
-                trace!("Parent: {:?}, Level: {}", parent_proc.name(), level);
-
-                if let Some(layer) =
-                    self.match_property_opt_parent(parent_proc.name(), mapping_property)
-                {
-                    return Some(layer);
-                }
-
-                return self.check_parent_recursively(
-                    parent_proc,
-                    sys,
-                    mapping_property,
-                    level + 1,
-                );
-            }
-        }
-
-        None
-    }
-
-    fn match_property_opt_parent<T, F>(&self, app_property: T, mapping_property: F) -> Option<u8>
-    where
-        T: AsRef<str>,
-        F: Fn(&AppConfig) -> &Option<Parent>,
-    {
-        let app_prop = app_property.as_ref().to_lowercase();
-
-        self.mappings.as_ref()?.iter().find_map(|mapping| {
-            mapping.apps.iter().find_map(|app| {
-                mapping_property(app)
-                    .as_ref()?
-                    .process
-                    .as_ref()?
-                    .to_lowercase()
-                    .contains(&app_prop)
-                    .then_some(mapping.layer)
-            })
-        })
-    }
-
-    fn match_property_opt_string<T, F>(&self, app_property: T, mapping_property: F) -> Option<u8>
-    where
-        T: AsRef<str>,
-        F: Fn(&AppConfig) -> &Option<String>,
-    {
-        let app_prop = app_property.as_ref().to_lowercase();
-
-        self.mappings.as_ref()?.iter().find_map(|mapping| {
-            mapping.apps.iter().find_map(|app| {
-                mapping_property(app)
-                    .as_ref()?
-                    .to_lowercase()
-                    .contains(&app_prop)
-                    .then_some(mapping.layer)
-            })
-        })
-    }
-}
diff --git a/common/src/layer.rs b/common/src/layer.rs
deleted file mode 100644
index 5974e0f..0000000
--- a/common/src/layer.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use crate::app::AppDetails;
-use crate::config::Config;
-use tracing::{debug, error, info};
-
-pub fn process(app_details: &AppDetails) {
-    debug!("{:?}", app_details);
-
-    let config = Config::load();
-
-    let layer = config
-        .check_window(app_details)
-        .or_else(|| config.check_process(app_details))
-        .or_else(|| config.check_parent(app_details))
-        .unwrap_or_else(|| config.base_layer.unwrap_or_default());
-
-    layer_change(&config, layer);
-}
-
-fn layer_change(config: &Config, layer: u8) {
-    if let Some(port) = &config.comm_port {
-        let mut focus = dygma_focus::Focus::default();
-        if focus.open_via_port(port).is_ok() {
-            if focus.layer_move_to(layer - 1).is_ok() {
-                info!("Changed layer: {}", layer);
-            } else {
-                error!("Failed to write to serial port: {:?}", &config.comm_port);
-            }
-        } else {
-            error!("Failed to open serial port: {:?}", &config.comm_port);
-        }
-    } else {
-        error!("No serial port specified");
-    }
-}
diff --git a/common/src/lib.rs b/common/src/lib.rs
deleted file mode 100644
index 1bdd65b..0000000
--- a/common/src/lib.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-pub mod app;
-pub mod config;
-pub mod layer;
-pub mod single;
diff --git a/dygma-layer-switcher/Cargo.toml b/dygma-layer-switcher/Cargo.toml
index fc1e82d..85984a9 100644
--- a/dygma-layer-switcher/Cargo.toml
+++ b/dygma-layer-switcher/Cargo.toml
@@ -5,17 +5,35 @@ edition = "2021"
 authors = ["Matthew Wilding <mbwilding@gmail.com>"]
 
 [dependencies]
-common = { path = "../common" }
 anyhow = "1.0"
+crossbeam-channel = "0.5"
+dygma_focus = { git = "https://github.com/mbwilding/dygma-focus-api-rs" }
+eframe = { version = "0.24", default-features = false, features = [
+    "default_fonts",
+    "wgpu",
+    "persistence",
+] }
+image = "0.24"
+lazy_static = "1.4"
+serde = { version = "1.0", features = ["derive"] }
+single-instance = "0.3"
+sysinfo = "0.29"
 tracing = "0.1"
 tracing-appender = "0.2"
-tracing-subscriber = "0.3"
-
-[target.'cfg(windows)'.dependencies]
-windows = { path = "../windows" }
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tray-icon = "0.11"
+windows = { version = "0.52", features = [
+    "Win32_Foundation",
+    "Win32_UI_Accessibility",
+    "Win32_UI_WindowsAndMessaging",
+    "Win32_System_LibraryLoader",
+    "Win32_System_Threading",
+    "Win32_System_ProcessStatus"
+] }
+winit = "0.29"
 
 [build-dependencies]
 embed-resource = "2.4"
 
 [features]
-no-admin = [] # Disable forced administrator mode [Windows]
+no-admin = [] # Disable forced administrator mode
diff --git a/dygma-layer-switcher/src/app.rs b/dygma-layer-switcher/src/app.rs
new file mode 100644
index 0000000..32883c0
--- /dev/null
+++ b/dygma-layer-switcher/src/app.rs
@@ -0,0 +1,385 @@
+use crate::helpers::remove_opt_index;
+use crate::structs::*;
+use crate::templates::*;
+use crate::{layer, verbiage};
+use crossbeam_channel::{Receiver, Sender};
+use dygma_focus::Focus;
+use eframe::egui::{
+    CentralPanel, CollapsingHeader, Context, DragValue, ScrollArea, TopBottomPanel,
+};
+use eframe::{egui, Frame, Storage};
+use lazy_static::lazy_static;
+use serde::{Deserialize, Serialize};
+use std::collections::{BTreeMap, BTreeSet};
+use tracing::{error, trace, warn};
+use tray_icon::menu::MenuEvent;
+use tray_icon::{ClickType, TrayIconEvent};
+
+const MAX_LAYERS: u8 = 10;
+
+lazy_static! {
+    pub static ref CHANNELS: (Sender<AppDetails>, Receiver<AppDetails>) =
+        crossbeam_channel::unbounded::<AppDetails>();
+}
+
+#[derive(Deserialize, Serialize, Clone)]
+#[serde(default)]
+pub struct DygmaLayerSwitcher {
+    pub logging: bool,
+    pub port: String,
+    pub base_layer: u8,
+    pub mappings: BTreeMap<u8, Layer>,
+    pub hidden_layers: BTreeSet<u8>,
+
+    #[serde(skip)]
+    pub editing_port: bool,
+
+    #[serde(skip)]
+    pub remove_app: Option<usize>,
+
+    #[serde(skip)]
+    pub remove_exclude: Option<usize>,
+
+    #[serde(skip)]
+    pub remove_hidden_layer: Option<u8>,
+
+    #[serde(skip)]
+    pub window_visible: bool,
+}
+
+impl Default for DygmaLayerSwitcher {
+    fn default() -> Self {
+        let focus = Focus::default();
+        let port = focus.find_first().unwrap_or_else(|_| {
+            error!("{}", verbiage::NO_KEYBOARD_MESSAGE);
+            std::process::exit(1);
+        });
+
+        Self {
+            logging: false,
+            port: port.port,
+            base_layer: 1,
+            mappings: (0..MAX_LAYERS)
+                .map(|i| (i, Layer::new(i)))
+                .collect::<BTreeMap<u8, Layer>>(),
+            hidden_layers: BTreeSet::new(),
+
+            editing_port: false,
+            remove_app: None,
+            remove_exclude: None,
+            remove_hidden_layer: None,
+            window_visible: true,
+        }
+    }
+}
+
+impl DygmaLayerSwitcher {
+    pub fn new(cc: &eframe::CreationContext<'_>) -> Self {
+        // This is also where you can customize the look and feel of egui using
+        // `cc.egui_ctx.set_visuals` and `cc.egui_ctx.set_fonts`.
+
+        if let Some(storage) = cc.storage {
+            return eframe::get_value(storage, eframe::APP_KEY).unwrap_or_default();
+        }
+
+        Default::default()
+    }
+
+    fn logging_control(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            ui.label(verbiage::LOGGING_SETTING_HEADING)
+                .on_hover_text(verbiage::LOGGING_SETTING_HINT);
+            ui.checkbox(&mut self.logging, "");
+        });
+    }
+
+    fn port_control(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            ui.label(verbiage::PORT_SETTING_HEADING)
+                .on_hover_text(verbiage::PORT_SETTING_HINT);
+            if ui
+                .button(verbiage::PORT_SETTING_REFRESH_HEADING)
+                .on_hover_text(verbiage::PORT_SETTING_REFRESH_HINT)
+                .clicked()
+            {
+                let focus = Focus::default();
+                match focus.find_first() {
+                    Ok(port) => self.port = port.port,
+                    Err(_) => warn!("{}", verbiage::NO_KEYBOARD_MESSAGE),
+                }
+            };
+            editable_label(ui, &mut self.port, &mut self.editing_port);
+        });
+    }
+
+    fn base_layer_control(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            ui.label(verbiage::BASE_LAYER_SETTING_HEADING)
+                .on_hover_text(verbiage::BASE_LAYER_SETTING_HINT);
+            ui.add(DragValue::new(&mut self.base_layer).clamp_range(1..=MAX_LAYERS))
+                .on_hover_text(verbiage::BASE_LAYER_VALUE_HINT);
+        });
+    }
+
+    fn hidden_layer_control(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            if !self.hidden_layers.is_empty() {
+                CollapsingHeader::new(verbiage::HIDDEN_LAYERS_HEADING)
+                    .default_open(false)
+                    .show(ui, |ui| {
+                        for layer in self.hidden_layers.iter() {
+                            ui.horizontal(|ui| {
+                                if ui
+                                    .button(verbiage::BUTTON_REMOVE)
+                                    .on_hover_text(format!(
+                                        "{} {}.",
+                                        verbiage::HIDDEN_LAYERS_UNHIDE_HINT,
+                                        layer + 1
+                                    ))
+                                    .clicked()
+                                {
+                                    self.remove_hidden_layer = Some(*layer);
+                                }
+                                ui.label(self.mappings[layer].name.as_str())
+                                    .on_hover_text(format!("{} {}.", verbiage::LAYER, layer + 1));
+                            });
+                        }
+                        if let Some(layer) = self.remove_hidden_layer {
+                            self.hidden_layers.remove(&layer);
+                            self.remove_hidden_layer = None;
+                        }
+                    });
+            }
+        });
+    }
+
+    fn top_panel(&mut self, ctx: &Context) {
+        TopBottomPanel::top("top_panel").show(ctx, |ui| {
+            CollapsingHeader::new(verbiage::SETTINGS_HEADING)
+                .default_open(true)
+                .show(ui, |ui| {
+                    self.logging_control(ui);
+                    self.port_control(ui);
+                    self.base_layer_control(ui);
+                    self.hidden_layer_control(ui);
+                });
+        });
+    }
+
+    fn central_panel(&mut self, ctx: &Context) {
+        CentralPanel::default().show(ctx, |ui| {
+            ScrollArea::new([true, true])
+                .drag_to_scroll(true)
+                .auto_shrink(false)
+                .show(ui, |ui| {
+                    for (index, layer) in self.mappings.iter_mut() {
+                        if self.hidden_layers.contains(index) {
+                            continue;
+                        }
+                        ui.horizontal(|ui| {
+                            if ui.button("👁").clicked() {
+                                self.hidden_layers.insert(*index);
+                            }
+                            editable_collapsing(ui, &mut layer.name, &mut layer.is_editing, |ui| {
+                                ui.horizontal(|ui| {
+                                    ui.label(format!("{} {}", verbiage::LAYER, index + 1));
+                                    if ui
+                                        .button(verbiage::BUTTON_ADD_WINDOW)
+                                        .on_hover_text(verbiage::WINDOW)
+                                        .clicked()
+                                    {
+                                        layer.apps.push(App::new_window());
+                                    }
+                                    if ui
+                                        .button(verbiage::BUTTON_ADD_PROCESS)
+                                        .on_hover_text(verbiage::PROCESS)
+                                        .clicked()
+                                    {
+                                        layer.apps.push(App::new_process());
+                                    }
+                                    if ui
+                                        .button(verbiage::BUTTON_ADD_PARENT)
+                                        .on_hover_text(verbiage::PARENT)
+                                        .clicked()
+                                    {
+                                        layer.apps.push(App::new_parent());
+                                    }
+                                });
+
+                                CollapsingHeader::new(verbiage::MODE_WINDOWS_HEADING)
+                                    .default_open(true)
+                                    .show(ui, |ui| {
+                                        for (index, app) in layer.apps.iter_mut().enumerate() {
+                                            if let Mode::Window(window) = &mut app.mode {
+                                                ui.horizontal(|ui| {
+                                                    ui.checkbox(&mut app.is_enabled, "");
+                                                    if ui
+                                                        .button(verbiage::BUTTON_REMOVE)
+                                                        .on_hover_text(verbiage::MODE_WINDOWS_HINT)
+                                                        .clicked()
+                                                    {
+                                                        self.remove_app = Some(index);
+                                                    }
+                                                    editable_label(
+                                                        ui,
+                                                        &mut window.name,
+                                                        &mut window.is_editing,
+                                                    );
+                                                });
+                                            }
+                                        }
+                                    })
+                                    .header_response
+                                    .on_hover_text(verbiage::WINDOW);
+
+                                CollapsingHeader::new(verbiage::MODE_PROCESSES_HEADING)
+                                    .default_open(true)
+                                    .show(ui, |ui| {
+                                        for (index, app) in layer.apps.iter_mut().enumerate() {
+                                            if let Mode::Process(process) = &mut app.mode {
+                                                ui.horizontal(|ui| {
+                                                    ui.checkbox(&mut app.is_enabled, "");
+                                                    if ui
+                                                        .button(verbiage::BUTTON_REMOVE)
+                                                        .on_hover_text(verbiage::MODE_PROCESSES_HINT)
+                                                        .clicked()
+                                                    {
+                                                        self.remove_app = Some(index);
+                                                    }
+                                                    editable_label(
+                                                        ui,
+                                                        &mut process.name,
+                                                        &mut process.is_editing,
+                                                    );
+                                                });
+                                            }
+                                        }
+                                    })
+                                    .header_response
+                                    .on_hover_text(verbiage::PROCESS);
+
+                                CollapsingHeader::new(verbiage::MODE_PARENT_HEADING)
+                                    .default_open(true)
+                                    .show(ui, |ui| {
+                                        for (index, app) in layer.apps.iter_mut().enumerate() {
+                                            if let Mode::Parent(parent) = &mut app.mode {
+                                                ui.horizontal(|ui| {
+                                                    ui.checkbox(&mut app.is_enabled, "");
+                                                    if ui
+                                                        .button(verbiage::BUTTON_REMOVE)
+                                                        .on_hover_text(verbiage::MODE_PARENT_HINT)
+                                                        .clicked()
+                                                    {
+                                                        self.remove_app = Some(index);
+                                                    }
+                                                    if ui
+                                                        .button(verbiage::BUTTON_ADD_EXCLUDE)
+                                                        .on_hover_text(verbiage::EXCLUDES_HINT)
+                                                        .clicked()
+                                                    {
+                                                        parent.excludes.push(Exclude::new());
+                                                    }
+                                                    editable_label(
+                                                        ui,
+                                                        &mut parent.name,
+                                                        &mut parent.is_editing,
+                                                    );
+                                                });
+
+                                                if !parent.excludes.is_empty() {
+                                                    CollapsingHeader::new(verbiage::MODE_PARENT_EXCLUDES_HEADING)
+                                                        .id_source(format!("excludes_{}", index))
+                                                        .default_open(true)
+                                                        .show(ui, |ui| {
+                                                            parent
+                                                                .excludes
+                                                                .iter_mut()
+                                                                .enumerate()
+                                                                .for_each(|(index, exclude)| {
+                                                                    ui.horizontal(|ui| {
+                                                                        ui.checkbox(
+                                                                            &mut exclude.is_enabled,
+                                                                            "",
+                                                                        );
+                                                                        if ui
+                                                                        .button(verbiage::BUTTON_REMOVE)
+                                                                        .on_hover_text(
+                                                                            verbiage::MODE_PARENT_EXCLUDES_HINT,
+                                                                        )
+                                                                        .clicked()
+                                                                    {
+                                                                        self.remove_exclude =
+                                                                            Some(index);
+                                                                    }
+                                                                        editable_label(
+                                                                            ui,
+                                                                            &mut exclude.name,
+                                                                            &mut exclude.is_editing,
+                                                                        );
+                                                                    });
+                                                                });
+                                                            remove_opt_index(
+                                                                &mut parent.excludes,
+                                                                &mut self.remove_exclude,
+                                                            );
+                                                        })
+                                                        .header_response
+                                                        .on_hover_text(verbiage::EXCLUDES_HINT);
+                                                }
+                                            }
+                                        }
+                                    })
+                                    .header_response
+                                    .on_hover_text(verbiage::PARENT);
+                                remove_opt_index(&mut layer.apps, &mut self.remove_app);
+                            });
+                        });
+                    }
+                });
+        });
+    }
+}
+
+impl eframe::App for DygmaLayerSwitcher {
+    fn update(&mut self, ctx: &Context, _frame: &mut Frame) {
+        // TODO: Temp fix to run loop while app is out of focus
+        ctx.request_repaint();
+
+        // Window focus
+        if let Ok(event) = CHANNELS.1.try_recv() {
+            // let config = self.clone();
+            // thread::spawn(move || layer::process(&config, &event));
+            layer::process(self, &event)
+        }
+
+        // Tray
+        if let Ok(event) = TrayIconEvent::receiver().try_recv() {
+            trace!("Tray icon event: {event:?}");
+            match event.click_type {
+                ClickType::Left => {}
+                ClickType::Right => {
+                    // Menu
+                }
+                ClickType::Double => {
+                    self.window_visible = !self.window_visible;
+                    ctx.send_viewport_cmd(egui::ViewportCommand::Visible(self.window_visible))
+                }
+            }
+        }
+        if let Ok(event) = MenuEvent::receiver().try_recv() {
+            trace!("Tray menu event: {:?}", event);
+            // Exit
+            if event.id == "1001" {
+                ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+            }
+        }
+
+        // UI
+        self.top_panel(ctx);
+        self.central_panel(ctx);
+    }
+
+    fn save(&mut self, storage: &mut dyn Storage) {
+        eframe::set_value(storage, eframe::APP_KEY, self);
+    }
+}
diff --git a/dygma-layer-switcher/src/helpers.rs b/dygma-layer-switcher/src/helpers.rs
new file mode 100644
index 0000000..ec9fc1d
--- /dev/null
+++ b/dygma-layer-switcher/src/helpers.rs
@@ -0,0 +1,6 @@
+pub fn remove_opt_index<T>(vec: &mut Vec<T>, index: &mut Option<usize>) {
+    if let Some(i) = index {
+        vec.remove(*i);
+        *index = None;
+    }
+}
diff --git a/dygma-layer-switcher/src/icon.rs b/dygma-layer-switcher/src/icon.rs
new file mode 100644
index 0000000..974f6c8
--- /dev/null
+++ b/dygma-layer-switcher/src/icon.rs
@@ -0,0 +1,27 @@
+use anyhow::Result;
+use eframe::egui::IconData;
+use tray_icon::Icon;
+
+pub fn load_tray_icon(bytes: &[u8]) -> Result<Icon> {
+    let icon = load_icon(bytes);
+    let icon = Icon::from_rgba(icon.rgba, icon.width, icon.height)?;
+
+    Ok(icon)
+}
+
+pub fn load_icon(bytes: &[u8]) -> IconData {
+    let (icon_rgba, icon_width, icon_height) = {
+        let image = image::load_from_memory(bytes)
+            .expect("Failed to open icon path")
+            .into_rgba8();
+        let (width, height) = image.dimensions();
+        let rgba = image.into_raw();
+        (rgba, width, height)
+    };
+
+    IconData {
+        rgba: icon_rgba,
+        width: icon_width,
+        height: icon_height,
+    }
+}
diff --git a/dygma-layer-switcher/src/layer.rs b/dygma-layer-switcher/src/layer.rs
new file mode 100644
index 0000000..96c945e
--- /dev/null
+++ b/dygma-layer-switcher/src/layer.rs
@@ -0,0 +1,103 @@
+use crate::app::DygmaLayerSwitcher;
+use crate::structs::{AppDetails, Mode};
+use sysinfo::{ProcessExt, System, SystemExt};
+use tracing::{error, info};
+
+pub fn process(config: &DygmaLayerSwitcher, app_details: &AppDetails) {
+    let layer = check_window(config, app_details)
+        .or_else(|| check_process(config, app_details))
+        .or_else(|| check_parent(config, app_details))
+        .unwrap_or(config.base_layer - 1);
+
+    layer_change(config, layer);
+}
+
+fn layer_change(config: &DygmaLayerSwitcher, layer: u8) {
+    let mut focus = dygma_focus::Focus::default();
+    match focus.open_via_port(&config.port) {
+        Ok(_) => {
+            if let Err(e) = focus.layer_move_to(layer) {
+                error!("Failed to write to serial port '{}': {:?}", &config.port, e);
+            } else {
+                info!("Changed layer: {}", config.mappings[&layer].name);
+            }
+        }
+        Err(e) => {
+            error!("Failed to open serial port '{}': {:?}", &config.port, e);
+        }
+    }
+}
+
+fn check_window(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Option<u8> {
+    for (&layer_number, layer) in &config.mappings {
+        for app in &layer.apps {
+            if let Mode::Window(ref window) = app.mode {
+                if app.is_enabled
+                    && window
+                        .name
+                        .to_lowercase()
+                        .contains(&app_details.window.to_lowercase())
+                {
+                    return Some(layer_number);
+                }
+            }
+        }
+    }
+
+    None
+}
+
+fn check_process(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Option<u8> {
+    for (&layer_number, layer) in &config.mappings {
+        for app in &layer.apps {
+            if let Mode::Process(ref process) = app.mode {
+                if app.is_enabled
+                    && process.name.to_lowercase() == app_details.process.to_lowercase()
+                {
+                    return Some(layer_number);
+                }
+            }
+        }
+    }
+
+    None
+}
+
+fn check_parent(config: &DygmaLayerSwitcher, app_details: &AppDetails) -> Option<u8> {
+    let mut sys = System::new_all();
+    sys.refresh_all();
+
+    // Find the specified process.
+    let specified_process = sys
+        .processes()
+        .values()
+        .find(|p| p.name() == app_details.process);
+
+    if let Some(proc) = specified_process {
+        // Check each parent process of the specified process.
+        let mut current_proc = Some(proc);
+        while let Some(proc) = current_proc {
+            for (&layer_number, layer) in &config.mappings {
+                for app in &layer.apps {
+                    if let Mode::Parent(ref parent) = app.mode {
+                        if app.is_enabled && parent.name == proc.name() {
+                            // Check if the process is disabled or is not excluded.
+                            let is_excluded = parent.excludes.iter().any(|exclude| {
+                                exclude.is_enabled && exclude.name == app_details.process
+                            });
+
+                            if !is_excluded {
+                                return Some(layer_number);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Move to the parent process in the next iteration.
+            current_proc = proc.parent().and_then(|pid| sys.process(pid));
+        }
+    }
+
+    None
+}
diff --git a/dygma-layer-switcher/src/log.rs b/dygma-layer-switcher/src/log.rs
index 5a98ec9..094b7cd 100644
--- a/dygma-layer-switcher/src/log.rs
+++ b/dygma-layer-switcher/src/log.rs
@@ -1,30 +1,39 @@
-use common::config::Config;
-use tracing_subscriber::filter::LevelFilter;
+use tracing_subscriber::filter::EnvFilter;
 use tracing_subscriber::fmt;
 use tracing_subscriber::prelude::*;
 
-pub fn init(config: &Config) {
-    if let Some(logging) = config.logging {
-        let console_layer = fmt::layer()
-            .with_ansi(true)
-            .without_time()
-            .compact()
-            .with_filter(LevelFilter::DEBUG);
+pub fn init(logging: bool) {
+    let console_filter = EnvFilter::new("debug")
+        .add_directive("dygma-layer-switcher=trace".parse().unwrap())
+        .add_directive("egui=warn".parse().unwrap())
+        .add_directive("eframe=warn".parse().unwrap())
+        .add_directive("wgpu=warn".parse().unwrap());
 
-        let subscriber_builder = tracing_subscriber::registry();
+    let console_layer = fmt::layer()
+        .with_ansi(true)
+        .without_time()
+        .compact()
+        .with_filter(console_filter);
 
-        if logging {
-            subscriber_builder
-                .with(console_layer)
-                .with(
-                    fmt::layer()
-                        .with_ansi(false)
-                        .with_writer(tracing_appender::rolling::daily("logs", "dsl"))
-                        .with_filter(LevelFilter::TRACE),
-                )
-                .init();
-        } else {
-            subscriber_builder.with(console_layer).init();
-        }
+    let subscriber_builder = tracing_subscriber::registry();
+
+    if logging {
+        let file_filter = EnvFilter::new("trace")
+            .add_directive("dygma-layer-switcher=trace".parse().unwrap())
+            .add_directive("eframe=warn".parse().unwrap())
+            .add_directive("egui=warn".parse().unwrap())
+            .add_directive("wgpu=warn".parse().unwrap());
+
+        subscriber_builder
+            .with(console_layer)
+            .with(
+                fmt::layer()
+                    .with_ansi(false)
+                    .with_writer(tracing_appender::rolling::daily("logs", "dsl"))
+                    .with_filter(file_filter),
+            )
+            .init();
+    } else {
+        subscriber_builder.with(console_layer).init();
     }
 }
diff --git a/dygma-layer-switcher/src/main.rs b/dygma-layer-switcher/src/main.rs
index 58b209e..86603bf 100644
--- a/dygma-layer-switcher/src/main.rs
+++ b/dygma-layer-switcher/src/main.rs
@@ -1,30 +1,72 @@
 // hide console window on Windows in release
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-mod log;
-
-use common::config::Config;
-use common::single;
-use tracing::error;
+use crate::app::DygmaLayerSwitcher;
+use anyhow::Result;
+use eframe::egui::ViewportBuilder;
+use eframe::*;
+use std::sync::Arc;
+use std::{cell::RefCell, rc::Rc};
+use tray_icon::menu::{Menu, MenuItem};
+use tray_icon::TrayIconBuilder;
 
-fn main() -> anyhow::Result<()> {
-    let config = Config::load();
-    log::init(&config);
+mod app;
+mod helpers;
+mod icon;
+mod layer;
+mod log;
+mod single;
+mod structs;
+mod templates;
+mod verbiage;
+mod windows;
 
-    #[cfg(not(windows))]
-    error!("Platform not yet supported");
+pub const ICON: &[u8] = include_bytes!("../../assets/icons/icon.ico");
 
+pub fn main() -> Result<()> {
     single::check()?;
 
-    #[cfg(windows)]
-    {
-        windows::init::start();
+    let icon = icon::load_tray_icon(ICON)?;
+    let mut _tray_icon = Rc::new(RefCell::new(None));
+    let tray_rc = _tray_icon.clone();
+
+    let tray_menu = Menu::new();
+    tray_menu
+        .append(&MenuItem::new(verbiage::TRAY_QUIT, true, None))
+        .unwrap();
 
-        windows::tray::load().unwrap_or_else(|e| {
-            error!("Failed to load tray: {}", e);
-            std::process::exit(1);
-        });
-    }
+    run_native(
+        verbiage::APP_NAME,
+        NativeOptions {
+            default_theme: Theme::Dark,
+            // follow_system_theme: true,
+            persist_window: true,
+            centered: false,
+            vsync: true,
+            viewport: ViewportBuilder::default()
+                .with_inner_size((400.0, 320.0))
+                .with_resizable(true)
+                .with_close_button(true)
+                .with_minimize_button(true)
+                .with_maximize_button(true)
+                .with_icon(Arc::new(icon::load_icon(ICON))),
+            ..Default::default()
+        },
+        Box::new(move |cc| {
+            tray_rc.borrow_mut().replace(
+                TrayIconBuilder::new()
+                    .with_menu(Box::new(tray_menu))
+                    .with_tooltip(verbiage::APP_NAME)
+                    .with_icon(icon)
+                    .build()
+                    .unwrap(),
+            );
+            let app = DygmaLayerSwitcher::new(cc);
+            log::init(app.logging);
+            windows::start();
+            Box::new(app)
+        }),
+    )?;
 
     Ok(())
 }
diff --git a/common/src/single.rs b/dygma-layer-switcher/src/single.rs
similarity index 76%
rename from common/src/single.rs
rename to dygma-layer-switcher/src/single.rs
index fad0b3a..ad8ad7a 100644
--- a/common/src/single.rs
+++ b/dygma-layer-switcher/src/single.rs
@@ -1,9 +1,10 @@
+use crate::verbiage;
 use anyhow::Result;
 use single_instance::SingleInstance;
 use tracing::error;
 
 pub fn check() -> Result<()> {
-    let instance = SingleInstance::new("dygma-layer-switcher")?;
+    let instance = SingleInstance::new(verbiage::APP_NAME)?;
 
     if !instance.is_single() {
         error!("Another instance of Dygma Layer Switcher is already running");
diff --git a/dygma-layer-switcher/src/structs.rs b/dygma-layer-switcher/src/structs.rs
new file mode 100644
index 0000000..710af62
--- /dev/null
+++ b/dygma-layer-switcher/src/structs.rs
@@ -0,0 +1,132 @@
+use serde::{Deserialize, Serialize};
+
+const EDIT_TEXT: &str = "Click to edit";
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Layer {
+    pub name: String,
+    pub apps: Vec<App>,
+
+    #[serde(skip)]
+    pub is_editing: bool,
+}
+
+impl Layer {
+    pub fn new(layer: u8) -> Self {
+        Self {
+            name: format!("Layer {}", layer + 1),
+            apps: vec![],
+            is_editing: false,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct App {
+    pub mode: Mode,
+    pub is_enabled: bool,
+}
+
+impl App {
+    pub fn new_window() -> Self {
+        Self {
+            mode: Mode::Window(Window::new()),
+            is_enabled: true,
+        }
+    }
+
+    pub fn new_process() -> Self {
+        Self {
+            mode: Mode::Process(Process::new()),
+            is_enabled: true,
+        }
+    }
+
+    pub fn new_parent() -> Self {
+        Self {
+            mode: Mode::Parent(Parent::new()),
+            is_enabled: true,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub enum Mode {
+    Window(Window),
+    Process(Process),
+    Parent(Parent),
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Window {
+    pub name: String,
+    pub is_editing: bool,
+}
+
+impl Window {
+    pub fn new() -> Self {
+        Self {
+            name: EDIT_TEXT.to_string(),
+            is_editing: false,
+        }
+    }
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Process {
+    pub name: String,
+    pub is_editing: bool,
+}
+
+impl Process {
+    pub fn new() -> Self {
+        Self {
+            name: EDIT_TEXT.to_string(),
+            is_editing: false,
+        }
+    }
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Parent {
+    pub name: String,
+    pub excludes: Vec<Exclude>,
+
+    #[serde(skip)]
+    pub is_editing: bool,
+}
+
+impl Parent {
+    pub fn new() -> Self {
+        Self {
+            name: EDIT_TEXT.to_string(),
+            excludes: vec![],
+            is_editing: false,
+        }
+    }
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct Exclude {
+    pub name: String,
+    pub is_enabled: bool,
+
+    #[serde(skip)]
+    pub is_editing: bool,
+}
+
+impl Exclude {
+    pub fn new() -> Self {
+        Self {
+            name: EDIT_TEXT.to_string(),
+            is_enabled: true,
+            is_editing: false,
+        }
+    }
+}
+
+#[derive(Default, Debug, Clone, Deserialize, Serialize)]
+pub struct AppDetails {
+    pub window: String,
+    pub process: String,
+}
diff --git a/dygma-layer-switcher/src/templates.rs b/dygma-layer-switcher/src/templates.rs
new file mode 100644
index 0000000..c56fe98
--- /dev/null
+++ b/dygma-layer-switcher/src/templates.rs
@@ -0,0 +1,40 @@
+use crate::verbiage;
+use eframe::egui;
+use eframe::egui::CollapsingHeader;
+
+pub fn editable_label(ui: &mut egui::Ui, value: &mut String, editing: &mut bool) {
+    if *editing {
+        if ui.text_edit_singleline(value).lost_focus() {
+            *editing = false;
+        }
+    } else if ui.button(value.as_str()).clicked() {
+        *editing = true;
+    }
+}
+
+pub fn editable_collapsing<F: FnMut(&mut egui::Ui)>(
+    ui: &mut egui::Ui,
+    value: &mut String,
+    editing: &mut bool,
+    mut content: F,
+) {
+    if *editing {
+        if ui.text_edit_singleline(value).lost_focus() {
+            *editing = false;
+        }
+    } else {
+        let header_response = CollapsingHeader::new(value.clone())
+            .default_open(false)
+            .show(ui, |ui| {
+                content(ui);
+            })
+            .header_response;
+
+        if header_response
+            .on_hover_text(verbiage::RENAME_HINT)
+            .secondary_clicked()
+        {
+            *editing = true;
+        }
+    }
+}
diff --git a/dygma-layer-switcher/src/verbiage.rs b/dygma-layer-switcher/src/verbiage.rs
new file mode 100644
index 0000000..f12ed55
--- /dev/null
+++ b/dygma-layer-switcher/src/verbiage.rs
@@ -0,0 +1,34 @@
+pub const NO_KEYBOARD_MESSAGE: &str = "Connect a Dygma keyboard and restart the application.";
+pub const APP_NAME: &str = "Dygma Layer Switcher";
+pub const SETTINGS_HEADING: &str = "Settings";
+pub const BUTTON_ADD_WINDOW: &str = "Add window";
+pub const BUTTON_ADD_PROCESS: &str = "Add process";
+pub const BUTTON_ADD_PARENT: &str = "Add parent";
+pub const BUTTON_ADD_EXCLUDE: &str = "Add exclude";
+pub const MODE_WINDOWS_HEADING: &str = "Windows";
+pub const MODE_WINDOWS_HINT: &str = "Remove this window.";
+pub const MODE_PROCESSES_HEADING: &str = "Processes";
+pub const MODE_PROCESSES_HINT: &str = "Remove this process.";
+pub const MODE_PARENT_HEADING: &str = "Parents";
+pub const MODE_PARENT_HINT: &str = "Remove this parent.";
+pub const MODE_PARENT_EXCLUDES_HEADING: &str = "Excludes";
+pub const MODE_PARENT_EXCLUDES_HINT: &str = "Remove this exclude.";
+pub const LOGGING_SETTING_HEADING: &str = "Logging";
+pub const LOGGING_SETTING_HINT: &str = "Enables logging to file.";
+pub const PORT_SETTING_HEADING: &str = "Port";
+pub const PORT_SETTING_HINT: &str = "The serial port to communicate with.";
+pub const PORT_SETTING_REFRESH_HEADING: &str = "↻";
+pub const PORT_SETTING_REFRESH_HINT: &str = "Rescan for the communication port.";
+pub const BASE_LAYER_SETTING_HEADING: &str = "Base Layer";
+pub const BASE_LAYER_SETTING_HINT: &str = "The layer to return to.";
+pub const BASE_LAYER_VALUE_HINT: &str = "Click and drag to change the base layer.";
+pub const HIDDEN_LAYERS_HEADING: &str = "Hidden Layers";
+pub const HIDDEN_LAYERS_UNHIDE_HINT: &str = "Unhide layer";
+pub const BUTTON_REMOVE: &str = " - ";
+pub const WINDOW: &str = "Partial match of window title.";
+pub const PROCESS: &str = "The executable name including extension.";
+pub const PARENT: &str = "The parent executable name, and optional excludes of child processes.";
+pub const EXCLUDES_HINT: &str = "Exclude a child process.";
+pub const RENAME_HINT: &str = "Right click to rename.";
+pub const TRAY_QUIT: &str = "Quit";
+pub const LAYER: &str = "Layer";
diff --git a/dygma-layer-switcher/src/windows.rs b/dygma-layer-switcher/src/windows.rs
new file mode 100644
index 0000000..2d654b2
--- /dev/null
+++ b/dygma-layer-switcher/src/windows.rs
@@ -0,0 +1,165 @@
+use crate::structs::AppDetails;
+use std::path::Path;
+use std::sync::atomic::AtomicU32;
+use std::sync::atomic::Ordering;
+use tracing::{debug, error, trace};
+use windows::core::PCWSTR;
+use windows::Win32::{
+    Foundation::{HWND, MAX_PATH},
+    System::{
+        LibraryLoader::GetModuleHandleW,
+        ProcessStatus::K32GetModuleFileNameExW,
+        Threading::{OpenProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ},
+    },
+    UI::{
+        Accessibility::{SetWinEventHook, HWINEVENTHOOK},
+        WindowsAndMessaging::{
+            GetMessageW, GetWindowTextLengthW, GetWindowTextW, GetWindowThreadProcessId,
+            EVENT_OBJECT_FOCUS, MSG, WINEVENT_OUTOFCONTEXT,
+        },
+    },
+};
+
+/// # Safety
+///
+/// WinAPI.
+pub unsafe fn hydrate(window_handle: HWND) -> AppDetails {
+    let app_details = AppDetails {
+        window: get_window(window_handle),
+        process: get_process(window_handle),
+    };
+
+    debug!("{:?}", app_details);
+
+    app_details
+}
+
+/// # Safety
+///
+/// WinAPI.
+unsafe fn get_process(window_handle: HWND) -> String {
+    let mut process_id: u32 = 0;
+
+    let thread_id = GetWindowThreadProcessId(window_handle, Some(&mut process_id as *mut u32));
+
+    if thread_id == 0 {
+        error!("Failed to retrieve process ID");
+        return String::new();
+    };
+
+    let process_handle = match OpenProcess(
+        PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
+        false,
+        process_id,
+    ) {
+        Ok(handle) => handle,
+        Err(e) => {
+            error!("Failed to open process: {:?}", e);
+            return String::new();
+        }
+    };
+
+    trace!("Process handle: {:?}", process_handle.0);
+
+    let mut exe_path_bytes: Vec<u16> = vec![0; MAX_PATH as usize];
+    let exe_path_length = K32GetModuleFileNameExW(process_handle, None, &mut exe_path_bytes);
+    let exe_path = String::from_utf16_lossy(&exe_path_bytes[..exe_path_length as usize]);
+
+    trace!("Process: {:?}", exe_path);
+
+    let process = if let Some(file_name) = Path::new(&exe_path).file_name() {
+        if let Some(file_name_str) = file_name.to_str() {
+            file_name_str.to_owned()
+        } else {
+            error!("Failed to convert the executable name to string");
+            return String::new();
+        }
+    } else {
+        error!("Failed to extract the executable name from the path");
+        return String::new();
+    };
+    trace!("Executable name: {:?}", process);
+
+    process
+}
+
+/// # Safety
+///
+/// WinAPI.
+unsafe fn get_window(h_wnd: HWND) -> String {
+    let title_length = GetWindowTextLengthW(h_wnd) + 1;
+    let mut window: Vec<u16> = vec![0; title_length as usize];
+    let _ = GetWindowTextW(h_wnd, window.as_mut_slice());
+    let window = String::from_utf16_lossy(&window[..title_length as usize - 1]);
+    trace!("Window: {:?}", window);
+
+    window
+}
+
+static DEBOUNCER: AtomicU32 = AtomicU32::new(0);
+
+/// # Safety
+///
+/// WinAPI.
+pub unsafe extern "system" fn new_window_focused(
+    _h_win_event_hook: HWINEVENTHOOK,
+    _event: u32,
+    window_handle: HWND,
+    _id_object: i32,
+    _id_child: i32,
+    _id_event_thread: u32,
+    dwms_event_time: u32,
+) {
+    if window_handle.0 == 0 {
+        return;
+    }
+
+    trace!("window_handle: {:?}", window_handle);
+
+    if dwms_event_time == DEBOUNCER.load(Ordering::SeqCst) {
+        return;
+    }
+
+    DEBOUNCER.store(dwms_event_time, Ordering::SeqCst);
+
+    let app_details = hydrate(window_handle);
+    crate::app::CHANNELS
+        .0
+        .send(app_details)
+        .unwrap_or_else(|e| {
+            error!("Failed to send app details: {:?}", e);
+        });
+}
+
+pub fn start() {
+    std::thread::spawn(|| {
+        unsafe {
+            debug!("Hooking");
+
+            let module_handle = GetModuleHandleW(PCWSTR::null()).unwrap_or_else(|e| {
+                error!("Failed to get module handle: {:?}", e);
+                std::process::exit(1);
+            });
+
+            let _event_hook = SetWinEventHook(
+                EVENT_OBJECT_FOCUS,
+                EVENT_OBJECT_FOCUS,
+                module_handle,
+                Some(new_window_focused),
+                0,
+                0,
+                WINEVENT_OUTOFCONTEXT,
+            );
+
+            debug!("Hooked");
+
+            let mut msg = MSG::default();
+
+            loop {
+                // Will wait here for a message, so no sleep is needed in the loop
+                // This is a blocking call, but is required for the hook to work
+                while GetMessageW(&mut msg, HWND(0), 0, 0).as_bool() {}
+            }
+        }
+    });
+}
diff --git a/readme.md b/readme.md
index 4526f2a..7998310 100644
--- a/readme.md
+++ b/readme.md
@@ -1,42 +1,3 @@
 # Dygma Layer Switcher
 
-## Config
-
-On the first run of `dygma-layer-switcher` the `config.yml` will be generated.
-
-```yaml
----
-# Toggle logging.
-logging: false
-
-# Port of the keyboard for RF and USB, can be seen when selecting the keyboard in bazecor.
-comm_port: "COM4"
-
-# Layer to return to when no matching window is found.
-base_layer: 1
-
-# The mappings, each mapping has a layer and a choice of `window`, `process`, and `parent`, ordered in respect to performance.
-# The settings aren't mutually exclusive nor are the layers.
-# All setting values are case-insensitive.
-
-# `window` is part of the title of the window.
-# `process` is part of the name of the process.
-# `parent` has a `process` and an optional `excludes` (array) section.
-
-# You can do any combination of the above, mix and match all you want under the layer's `app` section.
-mappings:
-  - layer: 4
-    apps:
-      - parent:
-          process: "EpicGamesLauncher.exe"
-      - parent:
-          process: "steam.exe"
-          excludes:
-            - "steamwebhelper.exe"
-            - "blender.exe"
-  - layer: 5
-    apps:
-      - window: "Autodesk MAYA"
-      - process: "blender.exe"
-
-```
+[Download here](https://github.com/mbwilding/dygma-layer-switcher/releases)
diff --git a/windows/Cargo.toml b/windows/Cargo.toml
deleted file mode 100644
index 6b11721..0000000
--- a/windows/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "windows"
-version = "0.1.0"
-edition = "2021"
-authors = ["Matthew Wilding <mbwilding@gmail.com>"]
-
-[target.'cfg(target_os = "windows")'.dependencies]
-common = { path = "../common" }
-anyhow = "1.0"
-image = "0.24"
-tracing = "0.1"
-tray-icon = "0.11"
-windows = { version = "0.52", features = [
-    "Win32_Foundation",
-    "Win32_UI_Accessibility",
-    "Win32_UI_WindowsAndMessaging",
-    "Win32_System_LibraryLoader",
-    "Win32_System_Threading",
-    "Win32_System_ProcessStatus"
-] }
-winit = "0.29"
diff --git a/windows/src/collection.rs b/windows/src/collection.rs
deleted file mode 100644
index e143ed3..0000000
--- a/windows/src/collection.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-use common::app::AppDetails;
-use std::path::Path;
-use tracing::{error, trace};
-use windows::Win32::{
-    Foundation::{HWND, MAX_PATH},
-    System::{
-        ProcessStatus::K32GetModuleFileNameExW,
-        Threading::{OpenProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ},
-    },
-    UI::WindowsAndMessaging::{GetWindowTextLengthW, GetWindowTextW, GetWindowThreadProcessId},
-};
-
-/// # Safety
-///
-/// WinAPI.
-pub unsafe fn hydrate(window_handle: HWND) -> AppDetails {
-    AppDetails {
-        window: get_window(window_handle),
-        process: get_process(window_handle),
-    }
-}
-
-/// # Safety
-///
-/// WinAPI.
-unsafe fn get_process(window_handle: HWND) -> Option<String> {
-    let mut process_id: u32 = 0;
-
-    let thread_id = GetWindowThreadProcessId(window_handle, Some(&mut process_id as *mut u32));
-
-    if thread_id == 0 {
-        error!("Failed to retrieve process ID");
-        return None;
-    };
-
-    let process_handle = match OpenProcess(
-        PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
-        false,
-        process_id,
-    ) {
-        Ok(handle) => handle,
-        Err(e) => {
-            error!("Failed to open process: {:?}", e);
-            return None;
-        }
-    };
-
-    trace!("Process handle: {:?}", process_handle.0);
-
-    let mut exe_path_bytes: Vec<u16> = vec![0; MAX_PATH as usize];
-    let exe_path_length = K32GetModuleFileNameExW(process_handle, None, &mut exe_path_bytes);
-    let exe_path = String::from_utf16_lossy(&exe_path_bytes[..exe_path_length as usize]);
-
-    trace!("Process: {:?}", exe_path);
-
-    let process = if let Some(file_name) = Path::new(&exe_path).file_name() {
-        if let Some(file_name_str) = file_name.to_str() {
-            file_name_str.to_owned()
-        } else {
-            error!("Failed to convert the executable name to string");
-            return None;
-        }
-    } else {
-        error!("Failed to extract the executable name from the path");
-        return None;
-    };
-    trace!("Executable name: {:?}", process);
-
-    if process.is_empty() {
-        return None;
-    }
-
-    Some(process)
-}
-
-/// # Safety
-///
-/// WinAPI.
-unsafe fn get_window(h_wnd: HWND) -> Option<String> {
-    let title_length = GetWindowTextLengthW(h_wnd) + 1;
-    let mut window: Vec<u16> = vec![0; title_length as usize];
-    let _ = GetWindowTextW(h_wnd, window.as_mut_slice());
-    let window = String::from_utf16_lossy(&window[..title_length as usize - 1]);
-    trace!("Window: {:?}", window);
-
-    if window.is_empty() {
-        return None;
-    }
-
-    Some(window)
-}
diff --git a/windows/src/init.rs b/windows/src/init.rs
deleted file mode 100644
index 850bd6b..0000000
--- a/windows/src/init.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-use crate::message_loop::get_focused_window_details;
-use tracing::{error, info};
-use windows::{
-    core::PCWSTR,
-    Win32::{
-        Foundation::HWND,
-        System::LibraryLoader::GetModuleHandleW,
-        UI::{
-            Accessibility::SetWinEventHook,
-            WindowsAndMessaging::{GetMessageW, EVENT_OBJECT_FOCUS, MSG, WINEVENT_OUTOFCONTEXT},
-        },
-    },
-};
-
-pub fn start() {
-    std::thread::spawn(|| {
-        unsafe {
-            info!("Attempting Hook");
-
-            let module_handle = GetModuleHandleW(PCWSTR::null()).unwrap_or_else(|e| {
-                error!("Failed to get module handle: {:?}", e);
-                std::process::exit(1);
-            });
-
-            let _event_hook = SetWinEventHook(
-                EVENT_OBJECT_FOCUS,
-                EVENT_OBJECT_FOCUS,
-                module_handle,
-                Some(get_focused_window_details),
-                0,
-                0,
-                WINEVENT_OUTOFCONTEXT,
-            );
-
-            info!("Hooked");
-
-            let mut msg = MSG::default();
-
-            loop {
-                // Will wait here for a message, so no sleep is needed in the loop
-                // This is a blocking call, but is required for the hook to work
-                while GetMessageW(&mut msg, HWND(0), 0, 0).as_bool() {}
-            }
-        }
-    });
-}
diff --git a/windows/src/lib.rs b/windows/src/lib.rs
deleted file mode 100644
index d5a295c..0000000
--- a/windows/src/lib.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#[cfg(target_os = "windows")]
-pub mod collection;
-
-#[cfg(target_os = "windows")]
-pub mod init;
-
-#[cfg(target_os = "windows")]
-pub mod message_loop;
-
-#[cfg(target_os = "windows")]
-pub mod tray;
diff --git a/windows/src/message_loop.rs b/windows/src/message_loop.rs
deleted file mode 100644
index e810eb9..0000000
--- a/windows/src/message_loop.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use crate::collection;
-use std::sync::atomic::AtomicU32;
-use std::sync::atomic::Ordering;
-use windows::Win32::Foundation::HWND;
-use windows::Win32::UI::Accessibility::HWINEVENTHOOK;
-
-static DEBOUNCER: AtomicU32 = AtomicU32::new(0);
-
-/// # Safety
-///
-/// WinAPI.
-pub unsafe extern "system" fn get_focused_window_details(
-    _h_win_event_hook: HWINEVENTHOOK,
-    _event: u32,
-    window_handle: HWND,
-    _id_object: i32,
-    _id_child: i32,
-    _id_event_thread: u32,
-    dwms_event_time: u32,
-) {
-    if window_handle.0 == 0 {
-        return;
-    }
-
-    if dwms_event_time == DEBOUNCER.load(Ordering::SeqCst) {
-        return;
-    }
-
-    DEBOUNCER.store(dwms_event_time, Ordering::SeqCst);
-
-    let app_details = collection::hydrate(window_handle);
-    common::layer::process(&app_details);
-}
diff --git a/windows/src/tray.rs b/windows/src/tray.rs
deleted file mode 100644
index 1b17c2e..0000000
--- a/windows/src/tray.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-use anyhow::{Context, Result};
-use std::path::Path;
-use tracing::trace;
-use tray_icon::menu::{Menu, MenuEvent, MenuItem};
-use tray_icon::{Icon, TrayIconBuilder, TrayIconEvent};
-use winit::event_loop::{ControlFlow, EventLoopBuilder};
-
-const TITLE: &str = "Dygma Layer Switcher";
-
-fn load_icon(path: &Path) -> Result<Icon> {
-    let (icon_rgba, icon_width, icon_height) = {
-        let image = image::open(path)?.into_rgba8();
-        let (width, height) = image.dimensions();
-        let rgba = image.into_raw();
-        (rgba, width, height)
-    };
-    let icon = Icon::from_rgba(icon_rgba, icon_width, icon_height)?;
-
-    Ok(icon)
-}
-
-pub fn load() -> Result<()> {
-    let icon_path = "assets/icons/icon.ico";
-    let icon =
-        load_icon(Path::new(&icon_path)).context(format!("Could not find icon: {}", &icon_path))?;
-
-    let event_loop = EventLoopBuilder::new().build()?;
-
-    let menu_channel = MenuEvent::receiver();
-    let tray_channel = TrayIconEvent::receiver();
-
-    let item_quit = MenuItem::new("Quit", true, None);
-
-    let tray_menu = Menu::new();
-    tray_menu
-        .append(&item_quit)
-        .context("Failed to append menu item")?;
-
-    let _tray_icon = TrayIconBuilder::new()
-        .with_menu(Box::new(tray_menu))
-        .with_tooltip(TITLE)
-        .with_icon(icon)
-        .build()?;
-
-    event_loop.run(move |_event, event_loop| {
-        event_loop.set_control_flow(ControlFlow::Wait);
-
-        if let Ok(event) = tray_channel.try_recv() {
-            trace!("{:#?}", event);
-        }
-
-        if let Ok(event) = menu_channel.try_recv() {
-            trace!("{:#?}", event);
-
-            if event.id == item_quit.id() {
-                event_loop.exit();
-            }
-        }
-    })?;
-
-    Ok(())
-}