deps: update cargo-sources.json

Removing audio_thread_priority v0.35.1
    Updating cpal v0.18.0 (https://github.com/RustAudio/cpal#2c7acf8e) -> #81b4d659
    Removing dbus v0.6.5
    Updating either v1.15.0 -> v1.16.0
    Removing libdbus-sys v0.2.7
    Removing mach2 v0.4.3
    Updating peniko v0.6.0 -> v0.6.1
    Updating serde_json v1.0.149 -> v1.0.150
    Updating winnow v1.0.2 -> v1.0.3

Cargo.lock

@@ -298,20 +298,6 @@ version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
-[[package]]
-name = "audio_thread_priority"
-version = "0.35.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b1b4a0adbf971420cca66a75361a1190f34a6762d66361e5cde03dda35d1ed3"
-dependencies = [
- "cfg-if",
- "dbus",
- "libc",
- "log",
- "mach2 0.4.3",
- "windows-sys 0.61.2",
-]
-
 [[package]]
 name = "autocfg"
 version = "1.5.0"
@@ -686,15 +672,6 @@ dependencies = [
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "convert_case"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baaaa0ecca5b51987b9423ccdc971514dd8b0bb7b4060b983d3664dad3f1f89f"
-dependencies = [
- "unicode-segmentation",
-]
-
 [[package]]
 name = "cookie-factory"
 version = "0.3.3"
@@ -777,17 +754,16 @@ dependencies = [
 [[package]]
 name = "cpal"
 version = "0.18.0"
-source = "git+https://github.com/RustAudio/cpal#2c7acf8ed42b6523f319145a8be256c446df5939"
+source = "git+https://github.com/RustAudio/cpal#81b4d65902aef99dadc24c7a42bed9c704751bbf"
 dependencies = [
  "alsa",
- "audio_thread_priority",
  "block2 0.6.2",
  "coreaudio-rs",
  "dasp_sample",
  "jni 0.21.1",
  "js-sys",
  "libc",
- "mach2 0.6.0",
+ "mach2",
  "ndk",
  "ndk-context",
  "num-derive",
@@ -862,16 +838,6 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
 
-[[package]]
-name = "dbus"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48b5f0f36f1eebe901b0e6bee369a77ed3396334bf3f09abd46454a576f71819"
-dependencies = [
- "libc",
- "libdbus-sys",
-]
-
 [[package]]
 name = "dirs"
 version = "6.0.0"
@@ -1122,9 +1088,9 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.15.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
 
 [[package]]
 name = "emath"
@@ -1260,7 +1226,7 @@ dependencies = [
  "bitvec",
  "cfg-if",
  "libc",
- "nix 0.29.0",
+ "nix",
  "tokio",
 ]
 
@@ -2052,15 +2018,6 @@ version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
-[[package]]
-name = "libdbus-sys"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "328c4789d42200f1eeec05bd86c9c13c7f091d2ba9a6ea35acdf51f31bc0f043"
-dependencies = [
- "pkg-config",
-]
-
 [[package]]
 name = "libflate"
 version = "2.3.0"
@@ -2115,26 +2072,25 @@ dependencies = [
 
 [[package]]
 name = "libspa"
-version = "0.9.2"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6b8cfa2a7656627b4c92c6b9ef929433acd673d5ab3708cda1b18478ac00df4"
+checksum = "2909f3be29d674e7f10604aff18d1bbe1bb03c4cd61c8a8ba19c0b1d162f7d4e"
 dependencies = [
  "bitflags 2.11.1",
  "cc",
- "convert_case",
  "cookie-factory",
  "libc",
  "libspa-sys",
- "nix 0.30.1",
  "nom 8.0.0",
+ "rustix 1.1.4",
  "system-deps",
 ]
 
 [[package]]
 name = "libspa-sys"
-version = "0.9.2"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "901049455d2eb6decf9058235d745237952f4804bc584c5fcb41412e6adcc6e0"
+checksum = "69ad52764fca54818486f3cf75afec844d1f1a1568c24dcee25d41b1ab007dda"
 dependencies = [
  "bindgen",
  "cc",
@@ -2186,15 +2142,6 @@ version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
-[[package]]
-name = "mach2"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "mach2"
 version = "0.6.0"
@@ -2347,18 +2294,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "nix"
-version = "0.30.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
-dependencies = [
- "bitflags 2.11.1",
- "cfg-if",
- "cfg_aliases",
- "libc",
-]
-
 [[package]]
 name = "no_std_io2"
 version = "0.9.4"
@@ -2897,9 +2832,9 @@ dependencies = [
 
 [[package]]
 name = "peniko"
-version = "0.6.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2b6aadb221872732e87d465213e9be5af2849b0e8cc5300a8ba98fffa2e00a"
+checksum = "839c8299360d2e998bdb106dc0a6cd71dcc5f4df51df1b620361bf50e283cca6"
 dependencies = [
  "bytemuck",
  "color",
@@ -2997,26 +2932,23 @@ dependencies = [
 
 [[package]]
 name = "pipewire"
-version = "0.9.2"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9688b89abf11d756499f7c6190711d6dbe5a3acdb30c8fbf001d6596d06a8d44"
+checksum = "8585aba8a52ad74ccc633b8e293c1dc4277976bd5d510b925533f34fd6685f38"
 dependencies = [
- "anyhow",
  "bitflags 2.11.1",
  "libc",
  "libspa",
  "libspa-sys",
- "nix 0.30.1",
- "once_cell",
  "pipewire-sys",
- "thiserror 2.0.18",
+ "rustix 1.1.4",
 ]
 
 [[package]]
 name = "pipewire-sys"
-version = "0.9.2"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb028afee0d6ca17020b090e3b8fa2d7de23305aef975c7e5192a5050246ea36"
+checksum = "f2089f245b548723e60325773c27f586b7a2372c79ea941b246cd0d654706adc"
 dependencies = [
  "bindgen",
  "libspa-sys",
@@ -3159,7 +3091,7 @@ checksum = "3d595e54a326bc53c1c197b32d295e14b169e3cfeaa8dc82b529f947fba6bcf5"
 
 [[package]]
 name = "pwsp"
-version = "1.9.0"
+version = "1.9.1"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -3177,6 +3109,7 @@ dependencies = [
  "rfd",
  "rodio",
  "rust-i18n",
+ "rustix 1.1.4",
  "serde",
  "serde_json",
  "sys-locale",
@@ -3580,9 +3513,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.149"
+version = "1.0.150"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
 dependencies = [
  "itoa",
  "memchr",
@@ -4180,9 +4113,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.52.1"
+version = "1.52.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b67dee974fe86fd92cc45b7a95fdd2f99a36a6d7b0d431a231178d3d670bbcc6"
+checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
 dependencies = [
  "bytes",
  "libc",
@@ -4230,7 +4163,7 @@ dependencies = [
  "toml_datetime 1.1.1+spec-1.1.0",
  "toml_parser",
  "toml_writer",
- "winnow 1.0.2",
+ "winnow 1.0.3",
 ]
 
 [[package]]
@@ -4274,7 +4207,7 @@ dependencies = [
  "indexmap",
  "toml_datetime 1.1.1+spec-1.1.0",
  "toml_parser",
- "winnow 1.0.2",
+ "winnow 1.0.3",
 ]
 
 [[package]]
@@ -4283,7 +4216,7 @@ version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
 dependencies = [
- "winnow 1.0.2",
+ "winnow 1.0.3",
 ]
 
 [[package]]
@@ -5299,9 +5232,9 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ee1708bef14716a11bae175f579062d4554d95be2c6829f518df847b7b3fdd0"
+checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1"
 dependencies = [
  "memchr",
 ]
@@ -5530,7 +5463,7 @@ dependencies = [
  "uds_windows",
  "uuid",
  "windows-sys 0.61.2",
- "winnow 1.0.2",
+ "winnow 1.0.3",
  "zbus_macros",
  "zbus_names",
  "zvariant",
@@ -5558,7 +5491,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7074f3e50b894eac91750142016d30d0a89be8e67dbfd9704fb875825760e52d"
 dependencies = [
  "serde",
- "winnow 1.0.2",
+ "winnow 1.0.3",
  "zvariant",
 ]
 
@@ -5695,7 +5628,7 @@ dependencies = [
  "enumflags2",
  "serde",
  "url",
- "winnow 1.0.2",
+ "winnow 1.0.3",
  "zvariant_derive",
  "zvariant_utils",
 ]
@@ -5723,5 +5656,5 @@ dependencies = [
  "quote",
  "serde",
  "syn",
- "winnow 1.0.2",
+ "winnow 1.0.3",
 ]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pwsp"
-version = "1.9.0"
+version = "1.9.1"
 edition = "2024"
 authors = ["arabian"]
 description = "PWSP lets you play audio files through your microphone. Has both CLI and GUI clients."
@@ -12,7 +12,7 @@ keywords = ["soundpad", "pipewire", "linux", "cli", "gui"]
 
 
 [dependencies]
-tokio = { version = "1.52.1", features = ["full"] }
+tokio = { version = "1.52.3", features = ["full"] }
 async-trait = "0.1.89"
 
 serde = { version = "1.0.228", features = ["derive"] }
@@ -38,6 +38,7 @@ rfd = { version = "0.17.2", default-features = false, features = [
 opener = { version = "0.8.4", features = ["reveal"] }
 system-fonts = "0.1.0"
 anyhow = "1.0.102"
+rustix = { version = "1.1.4", features = ["process"] }
 
 rust-i18n = "4.0.0"
 sys-locale = "0.3.2"
@@ -47,7 +48,7 @@ rodio = { git = "https://github.com/arabianq/rodio.git", rev = "1a08f281c352622b
     "symphonia-libopus",
     "playback",
 ] }
-pipewire = "0.9.2"
+pipewire = "0.10.0"
 
 egui = { version = "0.34.2", default-features = false, features = [
     "default_fonts",

packages/aur/bin/.SRCINFO

@@ -1,6 +1,6 @@
 pkgbase = pwsp-bin
 pkgdesc = Lets you play audio files through your microphone (Pre-built binaries)
-pkgver = 1.9.0
+pkgver = 1.9.1
 pkgrel = 1
 url = https://github.com/arabianq/pipewire-soundpad
 arch = x86_64
@@ -9,8 +9,8 @@ depends = pipewire
 depends = alsa-lib
 provides = pwsp
 conflicts = pwsp
-source = pwsp-bin-1.9.0.zip :: https://github.com/arabianq/pipewire-soundpad/releases/download/v1.9.0/pwsp-v1.9.0-linux-x64.zip
+source = pwsp-bin-1.9.1.zip :: https://github.com/arabianq/pipewire-soundpad/releases/download/v1.9.1/pwsp-v1.9.1-linux-x64.zip
-source = pipewire-soundpad-1.9.0.tar.gz :: https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.9.0.tar.gz
+source = pipewire-soundpad-1.9.1.tar.gz :: https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.9.1.tar.gz
 sha256sums = SKIP
 sha256sums = SKIP
 

packages/aur/bin/PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: Alexander Tarasov <a.tevg@ya.ru>
 pkgname=pwsp-bin
 _pkgname=pipewire-soundpad
-pkgver=1.9.0
+pkgver=1.9.1
 pkgrel=1
 pkgdesc="Lets you play audio files through your microphone (Pre-built binaries)"
 arch=('x86_64')

packages/aur/standart/.SRCINFO

@@ -1,6 +1,6 @@
 pkgbase = pwsp
 	pkgdesc = Lets you play audio files through your microphone
-	pkgver = 1.9.0
+	pkgver = 1.9.1
 	pkgrel = 1
 	url = https://github.com/arabianq/pipewire-soundpad
 	arch = any
@@ -11,7 +11,7 @@ pkgbase = pwsp
 	makedepends = cmake
 	makedepends = pipewire
 	makedepends = alsa-lib
-	source = https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.9.0.tar.gz
+	source = https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.9.1.tar.gz
 	sha256sums = SKIP
 
 pkgname = pwsp

packages/aur/standart/PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: Alexander Tarasov <a.tevg@ya.ru>
 pkgsubn=pwsp
 pkgname=pwsp
-pkgver=1.9.0
+pkgver=1.9.1
 pkgrel=1
 pkgdesc="Lets you play audio files through your microphone"
 arch=('any')

packages/flatpak/ru.arabianq.pwsp.metainfo.xml

@@ -25,7 +25,7 @@
         <name>arabian</name>
     </developer>
     <releases>
-        <release version="1.9.0" date="2026-05-15" />
+        <release version="1.9.1" date="2026-05-22" />
     </releases>
     <content_rating type="oars-1.1" />
 </component>

packages/rpm/pwsp.spec

@@ -4,7 +4,7 @@
 %global cargo_install_lib 0
 
 Name:            pwsp
-Version:         1.9.0
+Version:         1.9.1
 Release:         %autorelease
 Summary:         Lets you play audio files through your microphone
 

src/bin/daemon.rs

@@ -39,7 +39,11 @@ async fn main() -> Result<()> {
 
     let runtime_dir = get_runtime_dir();
 
-    let lock_file = fs::File::create(runtime_dir.join("daemon.lock"))?;
+    let lock_file = fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .truncate(false)
+        .open(runtime_dir.join("daemon.lock"))?;
     lock_file.lock()?;
 
     let socket_path = runtime_dir.join("daemon.sock");

src/gui/mod.rs

@@ -1,6 +1,6 @@
-mod draw;
 mod input;
 mod update;
+mod views;
 
 use anyhow::{Result, anyhow};
 use eframe::{HardwareAcceleration, NativeOptions, icon_data::from_png_bytes, run_native};

src/gui/views/body.rs

@@ -0,0 +1,432 @@
+use crate::gui::SoundpadGui;
+use egui::{
+    Align, AtomExt, Button, CollapsingHeader, Color32, CursorIcon, Layout, RichText, ScrollArea,
+    Sense, TextEdit, Ui, Vec2,
+};
+use egui_dnd::dnd;
+use egui_material_icons::icons::*;
+use pwsp::types::{gui::AppState, gui::AudioPlayerState};
+use rust_i18n::t;
+use std::{cmp::Ordering, path::Path, path::PathBuf};
+
+pub(crate) enum FileAction {
+    Play(PathBuf, bool),
+    StopAndPlay(u32, PathBuf, bool),
+    AssignHotkey(PathBuf),
+}
+
+impl SoundpadGui {
+    pub fn draw_body(&mut self, ui: &mut Ui) {
+        let left_panel_width = self
+            .config
+            .left_panel_width
+            .max(100.0)
+            .min(ui.available_width() - 100.0);
+        let dirs_size = Vec2::new(left_panel_width, ui.available_height() - 40.0);
+
+        ui.horizontal(|ui| {
+            self.draw_dirs(ui, dirs_size);
+
+            let (rect, response) = ui.allocate_at_least(
+                Vec2::new(ui.spacing().item_spacing.x, ui.available_height()),
+                Sense::click_and_drag(),
+            );
+
+            if ui.is_rect_visible(rect) {
+                let stroke = ui.visuals().widgets.noninteractive.bg_stroke;
+                ui.painter().vline(rect.center().x, rect.y_range(), stroke);
+            }
+
+            let vertical_separator_response =
+                response.on_hover_and_drag_cursor(CursorIcon::ResizeHorizontal);
+
+            if vertical_separator_response.dragged() {
+                self.config.left_panel_width += vertical_separator_response.drag_delta().x;
+                self.config.left_panel_width = self.config.left_panel_width.clamp(100.0, 500.0);
+            }
+
+            if vertical_separator_response.drag_stopped() {
+                self.config.save_to_file().ok();
+            }
+
+            let files_size = Vec2::new(ui.available_width(), ui.available_height() - 40.0);
+            self.draw_files(ui, files_size);
+        });
+    }
+
+    fn draw_dirs(&mut self, ui: &mut Ui, area_size: Vec2) {
+        ui.vertical(|ui| {
+            ui.set_min_width(area_size.x);
+            ui.set_min_height(area_size.y);
+
+            ScrollArea::vertical().id_salt(0).show(ui, |ui| {
+                ui.set_min_width(area_size.x);
+
+                let mut dirs = std::mem::take(&mut self.app_state.dirs);
+                let mut dir_to_open = None;
+
+                dnd(ui, "dnd_directories").show_vec(&mut dirs, |ui, item, handle, _state| {
+                    let path = item;
+                    ui.horizontal(|ui| {
+                        handle.ui(ui, |ui| {
+                            ui.label(ICON_DRAG_INDICATOR.codepoint);
+                        });
+                        let name = path
+                            .file_name()
+                            .map(|s| s.to_string_lossy().to_string())
+                            .unwrap_or_else(|| path.to_string_lossy().to_string());
+
+                        let mut dir_button_text = RichText::new(name.clone());
+                        if let Some(current_dir) = &self.app_state.current_dir
+                            && current_dir.eq(&*path)
+                        {
+                            dir_button_text = dir_button_text.color(Color32::WHITE);
+                        }
+
+                        let dir_button =
+                            Button::new(dir_button_text.atom_max_width(area_size.x)).frame(false);
+
+                        let dir_button_response = ui.add(dir_button);
+                        if dir_button_response.clicked() {
+                            dir_to_open = Some(path.clone());
+                        }
+
+                        let delete_dir_button = Button::new(ICON_DELETE).frame(false);
+                        let delete_dir_button_response =
+                            ui.add_sized([18.0, 18.0], delete_dir_button);
+                        if delete_dir_button_response.clicked() {
+                            self.app_state.dirs_to_remove.insert(path.clone());
+                        }
+
+                        // Context menu
+                        dir_button_response.context_menu(|ui| {
+                            if ui
+                                .button(format!(
+                                    "{} {}",
+                                    ICON_OPEN_IN_NEW.codepoint,
+                                    t!("gui.context.dirs.open")
+                                ))
+                                .clicked()
+                            {
+                                dir_to_open = Some(path.clone());
+                            }
+
+                            if ui
+                                .button(format!(
+                                    "{} {}",
+                                    ICON_OPEN_IN_BROWSER.codepoint,
+                                    t!("gui.context.dirs.open_in_fm")
+                                ))
+                                .clicked()
+                                && let Err(e) = opener::open(&path)
+                            {
+                                eprintln!("Failed to open file manager: {}", e);
+                            }
+
+                            ui.separator();
+
+                            if ui
+                                .button(format!(
+                                    "{} {}",
+                                    ICON_DELETE.codepoint,
+                                    t!("gui.context.dirs.remove")
+                                ))
+                                .clicked()
+                            {
+                                self.app_state.dirs_to_remove.insert(path.clone());
+                            }
+                        });
+                    });
+                });
+                self.app_state.dirs = dirs;
+
+                if let Some(path) = dir_to_open {
+                    self.open_dir(&path);
+                }
+
+                ui.horizontal(|ui| {
+                    let add_dirs_button = Button::new(ICON_ADD).frame(false);
+                    let add_dirs_button_response = ui.add_sized([18.0, 18.0], add_dirs_button);
+                    if add_dirs_button_response.clicked() {
+                        self.add_dirs();
+                    }
+                });
+
+                ui.with_layout(Layout::bottom_up(Align::Min), |ui| {
+                    let play_file_button = Button::new(t!("gui.play_file_button"));
+                    let play_file_button_response = ui.add(play_file_button);
+                    if play_file_button_response.clicked() {
+                        self.open_file();
+                    }
+                });
+            });
+        });
+    }
+
+    fn draw_files_search_field(&mut self, ui: &mut Ui) {
+        ui.horizontal(|ui| {
+            let search_field_response = ui.add_sized(
+                [ui.available_width(), 22.0],
+                TextEdit::singleline(&mut self.app_state.search_query)
+                    .hint_text(t!("gui.search_placeholder")),
+            );
+
+            if self.app_state.force_focus_search {
+                search_field_response.request_focus();
+                self.app_state.force_focus_search = false;
+            }
+
+            self.app_state.search_field_id = Some(search_field_response.id);
+        });
+    }
+
+    fn draw_files_list(&mut self, ui: &mut Ui, area_size: Vec2) {
+        ScrollArea::vertical().id_salt(1).show(ui, |ui| {
+            ui.set_min_width(area_size.x);
+            ui.set_min_height(area_size.y);
+
+            ui.vertical(|ui| {
+                let mut actions = Vec::new();
+                let files = self.get_filtered_files();
+                for entry_path in files {
+                    Self::draw_tree_node(
+                        ui,
+                        entry_path,
+                        &mut self.app_state,
+                        &self.audio_player_state,
+                        &mut actions,
+                    );
+                }
+
+                for action in actions {
+                    match action {
+                        FileAction::Play(path, concurrent) => self.play_file(&path, concurrent),
+                        FileAction::StopAndPlay(id, path, concurrent) => {
+                            self.stop(Some(id));
+                            self.play_file(&path, concurrent);
+                        }
+                        FileAction::AssignHotkey(path) => {
+                            self.app_state.assigning_hotkey_for_file = Some(path);
+                            self.app_state.hotkey_capture_active = true;
+                        }
+                    }
+                }
+            });
+        });
+    }
+
+    fn draw_files(&mut self, ui: &mut Ui, area_size: Vec2) {
+        ui.vertical(|ui| {
+            self.draw_files_search_field(ui);
+            ui.separator();
+            self.draw_files_list(ui, area_size);
+        });
+    }
+
+    fn draw_tree_node_dir(
+        ui: &mut Ui,
+        path: std::path::PathBuf,
+        app_state: &mut AppState,
+        audio_player_state: &AudioPlayerState,
+        actions: &mut Vec<FileAction>,
+    ) {
+        let dir_name = path
+            .file_name()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .to_string();
+        CollapsingHeader::new(dir_name)
+            .id_salt(&path)
+            .show(ui, |ui| {
+                let children = if let Some(cached) = app_state.dir_cache.get(&path) {
+                    cached.clone()
+                } else {
+                    let mut read = Vec::new();
+                    if let Ok(entries) = std::fs::read_dir(&path) {
+                        for entry in entries.filter_map(|e| e.ok()) {
+                            read.push(entry.path());
+                        }
+                    }
+                    read.sort_by(|a, b| {
+                        let a_is_dir = a.is_dir();
+                        let b_is_dir = b.is_dir();
+                        if a_is_dir && !b_is_dir {
+                            Ordering::Less
+                        } else if !a_is_dir && b_is_dir {
+                            Ordering::Greater
+                        } else {
+                            a.cmp(b)
+                        }
+                    });
+                    app_state.dir_cache.insert(path.clone(), read.clone());
+                    read
+                };
+
+                let search_query = app_state.search_query.to_lowercase();
+                let search_query = search_query.trim();
+
+                for child in children {
+                    if !child.is_dir() {
+                        if !crate::gui::SUPPORTED_EXTENSIONS.contains(
+                            &child
+                                .extension()
+                                .unwrap_or_default()
+                                .to_str()
+                                .unwrap_or_default(),
+                        ) {
+                            continue;
+                        }
+                        if !search_query.is_empty() {
+                            let file_name = child
+                                .file_name()
+                                .unwrap_or_default()
+                                .to_string_lossy()
+                                .to_string();
+                            if !file_name.to_lowercase().contains(search_query) {
+                                continue;
+                            }
+                        }
+                    }
+                    Self::draw_tree_node(ui, child, app_state, audio_player_state, actions);
+                }
+            });
+    }
+
+    fn draw_tree_node_file(
+        ui: &mut Ui,
+        path: std::path::PathBuf,
+        app_state: &mut AppState,
+        audio_player_state: &AudioPlayerState,
+        actions: &mut Vec<FileAction>,
+    ) {
+        let file_name = path
+            .file_name()
+            .unwrap_or_default()
+            .to_string_lossy()
+            .to_string();
+
+        ui.horizontal(|ui| {
+            // Hotkey badge
+            let mut hotkey_badge = None;
+            for slot in &app_state.hotkey_config.slots {
+                if slot.action.name == "play"
+                    && let Some(file_path_str) = slot.action.args.get("file_path")
+                    && Path::new(file_path_str) == path
+                {
+                    if let Some(chord) = &slot.key_chord {
+                        hotkey_badge = Some(format!("[{}]", chord));
+                    } else {
+                        hotkey_badge = Some(format!("[{}]", slot.slot));
+                    }
+                    break;
+                }
+            }
+
+            if let Some(badge) = &hotkey_badge {
+                ui.label(
+                    RichText::new(badge)
+                        .small()
+                        .monospace()
+                        .color(Color32::from_rgb(100, 200, 100)),
+                );
+            }
+
+            let file_button_text = RichText::new(&file_name);
+
+            let file_button = Button::new(file_button_text).frame(false).truncate();
+            let file_button_response = ui.add(file_button);
+            if file_button_response.clicked() {
+                ui.input(|i| {
+                    if i.modifiers.ctrl {
+                        actions.push(FileAction::Play(path.clone(), true));
+                    } else if i.modifiers.shift
+                        && let Some(last_track) = audio_player_state.tracks.last()
+                    {
+                        actions.push(FileAction::StopAndPlay(last_track.id, path.clone(), true));
+                    } else {
+                        actions.push(FileAction::Play(path.clone(), false));
+                    }
+                });
+            }
+
+            // Context menu
+            file_button_response.context_menu(|ui| {
+                if ui
+                    .button(format!(
+                        "{} {}",
+                        ICON_BOLT.codepoint,
+                        t!("gui.context.files.play_solo")
+                    ))
+                    .clicked()
+                {
+                    actions.push(FileAction::Play(path.clone(), false));
+                }
+
+                if ui
+                    .button(format!(
+                        "{} {}",
+                        ICON_ADD.codepoint,
+                        t!("gui.context.files.add_new")
+                    ))
+                    .clicked()
+                {
+                    actions.push(FileAction::Play(path.clone(), true));
+                }
+
+                if ui
+                    .button(format!(
+                        "{} {}",
+                        ICON_SWAP_HORIZ.codepoint,
+                        t!("gui.context.files.replace_last")
+                    ))
+                    .clicked()
+                    && let Some(last_track) = audio_player_state.tracks.last()
+                {
+                    actions.push(FileAction::StopAndPlay(last_track.id, path.clone(), true));
+                }
+
+                ui.separator();
+
+                if ui
+                    .button(format!(
+                        "{} {}",
+                        ICON_OPEN_IN_BROWSER.codepoint,
+                        t!("gui.context.files.show_in_fm")
+                    ))
+                    .clicked()
+                    && let Err(e) = opener::reveal(&path)
+                {
+                    eprintln!("Failed to open file manager: {}", e);
+                }
+
+                ui.separator();
+
+                if ui
+                    .button(format!(
+                        "{} {}",
+                        ICON_KEYBOARD.codepoint,
+                        t!("gui.context.files.asign_hotkey")
+                    ))
+                    .clicked()
+                {
+                    actions.push(FileAction::AssignHotkey(path.clone()));
+                    ui.close();
+                }
+            });
+        });
+    }
+
+    fn draw_tree_node(
+        ui: &mut Ui,
+        path: std::path::PathBuf,
+        app_state: &mut AppState,
+        audio_player_state: &AudioPlayerState,
+        actions: &mut Vec<FileAction>,
+    ) {
+        if path.is_dir() {
+            Self::draw_tree_node_dir(ui, path, app_state, audio_player_state, actions);
+        } else {
+            Self::draw_tree_node_file(ui, path, app_state, audio_player_state, actions);
+        }
+    }
+}

src/gui/views/footer.rs

@@ -0,0 +1,86 @@
+use crate::gui::SoundpadGui;
+use egui::{AtomExt, Button, ComboBox, Label, RichText, Slider, Ui, Vec2};
+use egui_material_icons::icons::*;
+use rust_i18n::t;
+use std::time::Instant;
+
+impl SoundpadGui {
+    pub fn draw_footer(&mut self, ui: &mut Ui) {
+        ui.add_space(5.0);
+        ui.horizontal(|ui| {
+            // ---------- Microphone selection ----------
+            let mics = &self.audio_player_state.all_inputs_sorted;
+
+            let mut selected_input = self.audio_player_state.current_input.to_owned();
+            let prev_input = selected_input.to_owned();
+            ComboBox::from_label(t!("gui.choose_mic_select"))
+                .height(30.0)
+                .selected_text(
+                    self.audio_player_state
+                        .all_inputs
+                        .get(&selected_input)
+                        .unwrap_or(&String::new()),
+                )
+                .show_ui(ui, |ui| {
+                    for (name, nick) in mics {
+                        ui.selectable_value(&mut selected_input, name.clone(), nick);
+                    }
+                });
+
+            if selected_input != prev_input {
+                self.set_input(selected_input);
+            }
+            // --------------------------------
+
+            // ---------- Master Volume Slider ----------
+            let volume_icon = Self::get_volume_icon(self.audio_player_state.volume);
+            let volume_label = Label::new(RichText::new(volume_icon).size(18.0));
+            ui.add_sized([18.0, 18.0], volume_label)
+                .on_hover_text(format!(
+                    "Master Volume: {:.0}%",
+                    self.audio_player_state.volume * 100.0
+                ));
+
+            let should_update_volume = !self.app_state.volume_dragged
+                && self
+                    .app_state
+                    .ignore_volume_update_until
+                    .map(|t| Instant::now() > t)
+                    .unwrap_or(true);
+
+            if should_update_volume {
+                self.app_state.volume_slider_value = self.audio_player_state.volume;
+            }
+
+            let volume_slider = Slider::new(&mut self.app_state.volume_slider_value, 0.0..=1.0)
+                .show_value(false)
+                .step_by(0.01);
+            let volume_slider_response = ui.add_sized([150.0, 18.0], volume_slider);
+            if volume_slider_response.drag_stopped() {
+                self.app_state.volume_dragged = true;
+            }
+            // ------------------------------------------
+
+            ui.add_space(ui.available_width() - 18.0 * 2.0 - ui.spacing().item_spacing.x * 2.0);
+
+            // ---------- Hotkeys button ----------
+            let hotkeys_button =
+                Button::new(ICON_KEYBOARD.atom_size(Vec2::new(18.0, 18.0))).frame(false);
+            let hotkeys_button_response = ui.add_sized([18.0, 18.0], hotkeys_button);
+            if hotkeys_button_response.clicked() {
+                self.app_state.show_hotkeys = true;
+            }
+            hotkeys_button_response.on_hover_text("Hotkeys (H)");
+            // --------------------------------
+
+            // ---------- Settings button ----------
+            let settings_button =
+                Button::new(ICON_SETTINGS.atom_size(Vec2::new(18.0, 18.0))).frame(false);
+            let settings_button_response = ui.add_sized([18.0, 18.0], settings_button);
+            if settings_button_response.clicked() {
+                self.app_state.show_settings = true;
+            }
+            // --------------------------------
+        });
+    }
+}

src/gui/views/header.rs

@@ -0,0 +1,196 @@
+use crate::gui::SoundpadGui;
+use egui::{Button, CollapsingHeader, Color32, FontFamily, Label, RichText, Slider, Ui};
+use egui_material_icons::icons::*;
+use pwsp::types::{audio_player::TrackInfo, gui::AppState};
+use pwsp::utils::gui::format_time_pair;
+use std::time::Instant;
+
+pub(crate) enum TrackAction {
+    Pause(u32),
+    Resume(u32),
+    ToggleLoop(u32),
+    Stop(u32),
+}
+
+impl SoundpadGui {
+    pub fn draw_header(&mut self, ui: &mut Ui) {
+        ui.vertical_centered_justified(|ui| {
+            if self.audio_player_state.tracks.is_empty() {
+                ui.label("No tracks playing");
+                return;
+            }
+
+            let mut action = None;
+
+            for track in &self.audio_player_state.tracks {
+                CollapsingHeader::new(
+                    RichText::new(
+                        track
+                            .path
+                            .file_stem()
+                            .unwrap_or_default()
+                            .to_str()
+                            .unwrap_or_default(),
+                    )
+                    .color(Color32::WHITE)
+                    .family(FontFamily::Monospace),
+                )
+                .default_open(true)
+                .show(ui, |ui| {
+                    if let Some(act) = Self::draw_track_control(ui, &mut self.app_state, track) {
+                        action = Some(act);
+                    }
+                });
+                ui.separator();
+            }
+
+            if let Some(action) = action {
+                match action {
+                    TrackAction::Pause(id) => self.pause(Some(id)),
+                    TrackAction::Resume(id) => self.resume(Some(id)),
+                    TrackAction::ToggleLoop(id) => self.toggle_loop(Some(id)),
+                    TrackAction::Stop(id) => self.stop(Some(id)),
+                }
+            }
+        });
+    }
+
+    fn draw_playback_controls(ui: &mut Ui, track: &TrackInfo) -> Option<TrackAction> {
+        let mut action = None;
+
+        let play_button = Button::new(if track.paused {
+            ICON_PLAY_ARROW
+        } else {
+            ICON_PAUSE
+        })
+        .corner_radius(15.0);
+
+        if ui.add_sized([30.0, 30.0], play_button).clicked() {
+            action = Some(if track.paused {
+                TrackAction::Resume(track.id)
+            } else {
+                TrackAction::Pause(track.id)
+            });
+        }
+
+        let loop_button = Button::new(
+            RichText::new(if track.looped {
+                ICON_REPEAT_ONE
+            } else {
+                ICON_REPEAT
+            })
+            .size(18.0),
+        )
+        .frame(false);
+
+        if ui.add_sized([15.0, 30.0], loop_button).clicked() {
+            action = Some(TrackAction::ToggleLoop(track.id));
+        }
+
+        action
+    }
+
+    fn draw_position_control(
+        ui: &mut Ui,
+        ui_state: &mut pwsp::types::gui::TrackUiState,
+        track: &TrackInfo,
+        default_slider_width: f32,
+    ) {
+        let duration = track.duration.unwrap_or(1.0);
+        let position_slider = Slider::new(&mut ui_state.position_slider_value, 0.0..=duration)
+            .show_value(false)
+            .step_by(0.01);
+
+        let position_slider_width = ui.available_width()
+            - (30.0 * 3.0)
+            - default_slider_width
+            - (ui.spacing().item_spacing.x * 6.0);
+
+        ui.spacing_mut().slider_width = position_slider_width;
+        if ui.add_sized([30.0, 30.0], position_slider).drag_stopped() {
+            ui_state.position_dragged = true;
+        }
+
+        let time_label =
+            Label::new(RichText::new(format_time_pair(track.position, duration)).monospace());
+        ui.add_sized([30.0, 30.0], time_label);
+    }
+
+    fn draw_volume_control(
+        ui: &mut Ui,
+        ui_state: &mut pwsp::types::gui::TrackUiState,
+        track: &TrackInfo,
+        default_slider_width: f32,
+    ) {
+        let volume_icon = Self::get_volume_icon(track.volume);
+        let volume_label = Label::new(RichText::new(volume_icon).size(18.0));
+        ui.add_sized([30.0, 30.0], volume_label)
+            .on_hover_text(format!("Volume: {:.0}%", track.volume * 100.0));
+
+        let volume_slider = Slider::new(&mut ui_state.volume_slider_value, 0.0..=1.0)
+            .show_value(false)
+            .step_by(0.01);
+
+        ui.spacing_mut().slider_width = default_slider_width - 30.0;
+        ui.spacing_mut().item_spacing.x = 0.0;
+
+        if ui.add_sized([30.0, 30.0], volume_slider).drag_stopped() {
+            ui_state.volume_dragged = true;
+        }
+    }
+
+    fn draw_stop_control(ui: &mut Ui, track: &TrackInfo) -> Option<TrackAction> {
+        let stop_button = Button::new(ICON_CLOSE).frame(false);
+        if ui.add_sized([30.0, 30.0], stop_button).clicked() {
+            Some(TrackAction::Stop(track.id))
+        } else {
+            None
+        }
+    }
+
+    fn draw_track_control(
+        ui: &mut Ui,
+        app_state: &mut AppState,
+        track: &TrackInfo,
+    ) -> Option<TrackAction> {
+        let ui_state = app_state.track_ui_states.entry(track.id).or_default();
+
+        let should_update_position = !ui_state.position_dragged
+            && ui_state
+                .ignore_position_update_until
+                .map(|t| Instant::now() > t)
+                .unwrap_or(true);
+
+        if should_update_position {
+            ui_state.position_slider_value = track.position;
+        }
+
+        let should_update_volume = !ui_state.volume_dragged
+            && ui_state
+                .ignore_volume_update_until
+                .map(|t| Instant::now() > t)
+                .unwrap_or(true);
+
+        if should_update_volume {
+            ui_state.volume_slider_value = track.volume;
+        }
+
+        let mut action = None;
+
+        ui.horizontal_top(|ui| {
+            if let Some(act) = Self::draw_playback_controls(ui, track) {
+                action = Some(act);
+            }
+
+            let default_slider_width = ui.spacing().slider_width;
+            Self::draw_position_control(ui, ui_state, track, default_slider_width);
+            Self::draw_volume_control(ui, ui_state, track, default_slider_width);
+
+            if let Some(act) = Self::draw_stop_control(ui, track) {
+                action = Some(act);
+            }
+        });
+
+        action
+    }
+}

src/gui/views/hotkey_capture.rs

@@ -0,0 +1,32 @@
+use crate::gui::SoundpadGui;
+use egui::{Color32, RichText, Ui};
+use rust_i18n::t;
+
+impl SoundpadGui {
+    pub fn draw_hotkey_capture(&mut self, ui: &mut Ui) {
+        ui.vertical_centered(|ui| {
+            ui.add_space(ui.available_height() / 3.0);
+            ui.label(
+                RichText::new(t!("gui.hotkeys.capture.header"))
+                    .size(18.0)
+                    .color(Color32::YELLOW)
+                    .monospace(),
+            );
+            ui.add_space(10.0);
+            let target = if let Some(slot) = &self.app_state.assigning_hotkey_slot {
+                format!("{} '{}'", t!("gui.hotkeys.capture.for"), slot)
+            } else if let Some(path) = &self.app_state.assigning_hotkey_for_file {
+                format!(
+                    "{} '{}'",
+                    t!("gui.hotkeys.capture.for"),
+                    path.file_name().unwrap_or_default().to_string_lossy()
+                )
+            } else {
+                String::new()
+            };
+            ui.label(RichText::new(target).size(16.0));
+            ui.add_space(10.0);
+            ui.label(t!("gui.hotkeys.capture.cancel"));
+        });
+    }
+}

src/gui/views/hotkeys.rs

@@ -0,0 +1,311 @@
+use crate::gui::SoundpadGui;
+use egui::{Button, Color32, Label, RichText, TextEdit, Ui};
+use egui_extras::{Column, TableBuilder};
+use egui_material_icons::icons::*;
+use pwsp::types::socket::Request;
+use pwsp::utils::gui::make_request_async;
+use rust_i18n::t;
+use std::path::Path;
+
+pub(crate) enum HotkeyAction {
+    Remove(String),
+    Capture(String),
+    ClearChord(String),
+    Play(String),
+}
+
+impl SoundpadGui {
+    pub fn draw_hotkeys(&mut self, ui: &mut Ui) {
+        ui.vertical(|ui| {
+            ui.spacing_mut().item_spacing.y = 5.0;
+
+            self.draw_hotkeys_header(ui);
+            ui.separator();
+
+            self.draw_hotkeys_search(ui);
+            ui.separator();
+            ui.add_space(5.0);
+
+            let action = self.draw_hotkeys_table(ui);
+
+            if let Some(action) = action {
+                self.handle_hotkey_action(action);
+            }
+        });
+    }
+
+    fn draw_hotkeys_header(&mut self, ui: &mut Ui) {
+        ui.horizontal(|ui| {
+            let back_button = Button::new(ICON_ARROW_BACK).frame(false);
+            if ui.add(back_button).clicked() {
+                self.app_state.show_hotkeys = false;
+            }
+
+            ui.vertical_centered(|ui| {
+                ui.label(
+                    RichText::new(t!("gui.hotkeys.header"))
+                        .color(Color32::WHITE)
+                        .monospace(),
+                );
+            });
+        });
+    }
+
+    fn draw_hotkeys_search(&mut self, ui: &mut Ui) {
+        ui.horizontal(|ui| {
+            ui.menu_button(
+                format!(
+                    "{} {}",
+                    ICON_ADD.codepoint,
+                    t!("gui.hotkeys.add_command_select")
+                ),
+                |ui| {
+                    let mut selected_cmd = None;
+                    if ui.button(t!("gui.hotkeys.toggle_pause_command")).clicked() {
+                        selected_cmd = Some(("cmd_toggle_pause", Request::toggle_pause(None)));
+                    }
+                    if ui.button(t!("gui.hotkeys.stop_playback_command")).clicked() {
+                        selected_cmd = Some(("cmd_stop", Request::stop(None)));
+                    }
+                    if ui
+                        .button(t!("gui.hotkeys.pause_playback_command"))
+                        .clicked()
+                    {
+                        selected_cmd = Some(("cmd_pause", Request::pause(None)));
+                    }
+                    if ui
+                        .button(t!("gui.hotkeys.resume_playback_command"))
+                        .clicked()
+                    {
+                        selected_cmd = Some(("cmd_resume", Request::resume(None)));
+                    }
+                    if ui.button(t!("gui.hotkeys.toggle_loop_command")).clicked() {
+                        selected_cmd = Some(("cmd_toggle_loop", Request::toggle_loop(None)));
+                    }
+
+                    if let Some((slot_name, req)) = selected_cmd {
+                        make_request_async(Request::set_hotkey_action(slot_name, &req));
+                        self.app_state
+                            .hotkey_config
+                            .set_slot(slot_name.to_string(), req);
+                        self.app_state.assigning_hotkey_slot = Some(slot_name.to_string());
+                        self.app_state.hotkey_capture_active = true;
+                        ui.close();
+                    }
+                },
+            );
+
+            ui.add_space(10.0);
+
+            ui.add(
+                TextEdit::singleline(&mut self.app_state.hotkey_search_query)
+                    .hint_text(t!("gui.hotkeys.search_placeholder"))
+                    .desired_width(f32::INFINITY),
+            );
+        });
+    }
+
+    fn draw_hotkeys_table(&mut self, ui: &mut Ui) -> Option<HotkeyAction> {
+        let conflicts = self.app_state.hotkey_config.find_conflicts();
+        let conflict_slots: std::collections::HashSet<&str> =
+            conflicts.into_iter().flat_map(|(a, b)| [a, b]).collect();
+
+        let search = self.app_state.hotkey_search_query.to_lowercase();
+        let mut action: Option<HotkeyAction> = None;
+
+        let slots: Vec<_> = self
+            .app_state
+            .hotkey_config
+            .slots
+            .iter()
+            .filter(|s| {
+                if search.is_empty() {
+                    return true;
+                }
+                s.slot.to_lowercase().contains(&search)
+                    || format!("{:?}", s.action).to_lowercase().contains(&search)
+                    || s.key_chord
+                        .as_deref()
+                        .unwrap_or("")
+                        .to_lowercase()
+                        .contains(&search)
+            })
+            .collect();
+
+        let available_width = ui.available_width();
+        let col_width = (available_width / 4.0).max(80.0);
+
+        TableBuilder::new(ui)
+            .striped(true)
+            .column(Column::exact(col_width).clip(true)) // Slot
+            .column(Column::exact(col_width).clip(true)) // Sound / Action name
+            .column(Column::exact(col_width).clip(true)) // Key Chord
+            .column(Column::exact(col_width).clip(true)) // Actions
+            .header(30.0, |mut header| {
+                header.col(|ui| {
+                    ui.label(
+                        RichText::new(t!("gui.hotkeys.column_slot"))
+                            .strong()
+                            .monospace()
+                            .color(Color32::LIGHT_GRAY),
+                    );
+                });
+                header.col(|ui| {
+                    ui.label(
+                        RichText::new(t!("gui.hotkeys.column_sound"))
+                            .strong()
+                            .monospace()
+                            .color(Color32::LIGHT_GRAY),
+                    );
+                });
+                header.col(|ui| {
+                    ui.label(
+                        RichText::new(t!("gui.hotkeys.column_key_chord"))
+                            .strong()
+                            .monospace()
+                            .color(Color32::LIGHT_GRAY),
+                    );
+                });
+                header.col(|ui| {
+                    ui.label(
+                        RichText::new(t!("gui.hotkeys.column_actions"))
+                            .strong()
+                            .monospace()
+                            .color(Color32::LIGHT_GRAY),
+                    );
+                });
+            })
+            .body(|mut body| {
+                if slots.is_empty() {
+                    body.row(30.0, |mut row| {
+                        row.col(|_| {});
+                        row.col(|ui| {
+                            ui.label(
+                                RichText::new(t!("gui.hotkeys.no_hotkeys_configured"))
+                                    .color(Color32::GRAY),
+                            );
+                        });
+                        row.col(|_| {});
+                        row.col(|_| {});
+                    });
+                    return;
+                }
+
+                for slot in &slots {
+                    body.row(30.0, |mut row| {
+                        // Column 1: Slot
+                        row.col(|ui| {
+                            ui.horizontal(|ui| {
+                                if conflict_slots.contains(slot.slot.as_str()) {
+                                    ui.label(
+                                        RichText::new(ICON_WARNING.codepoint)
+                                            .color(Color32::from_rgb(255, 165, 0)),
+                                    )
+                                    .on_hover_text("Key chord conflict");
+                                }
+                                ui.add(
+                                    Label::new(RichText::new(&slot.slot).monospace()).truncate(),
+                                );
+                            });
+                        });
+
+                        // Column 2: Sound / Action name
+                        row.col(|ui| {
+                            let action_name = match slot.action.name.as_str() {
+                                "play" => {
+                                    if let Some(file_path_str) = slot.action.args.get("file_path") {
+                                        Path::new(file_path_str)
+                                            .file_name()
+                                            .unwrap_or_default()
+                                            .to_string_lossy()
+                                            .to_string()
+                                    } else {
+                                        "Play".to_string()
+                                    }
+                                }
+                                "toggle_pause" => "Toggle Pause".to_string(),
+                                "pause" => "Pause Playback".to_string(),
+                                "resume" => "Resume Playback".to_string(),
+                                "stop" => "Stop Playback".to_string(),
+                                "toggle_loop" => "Toggle Loop".to_string(),
+                                other => other.to_string(),
+                            };
+                            ui.add(Label::new(RichText::new(action_name).monospace()).truncate());
+                        });
+
+                        // Column 3: Key Chord
+                        row.col(|ui| {
+                            let chord_text = slot.key_chord.as_deref().unwrap_or("(none)");
+                            ui.add(
+                                Label::new(RichText::new(chord_text).monospace().color(
+                                    if slot.key_chord.is_some() {
+                                        Color32::from_rgb(100, 200, 100)
+                                    } else {
+                                        Color32::GRAY
+                                    },
+                                ))
+                                .truncate(),
+                            );
+                        });
+
+                        // Column 4: Actions
+                        row.col(|ui| {
+                            ui.horizontal(|ui| {
+                                if ui
+                                    .add(Button::new(ICON_DELETE).frame(false))
+                                    .on_hover_text("Remove slot")
+                                    .clicked()
+                                {
+                                    action = Some(HotkeyAction::Remove(slot.slot.clone()));
+                                }
+                                if ui
+                                    .add(Button::new(ICON_KEYBOARD).frame(false))
+                                    .on_hover_text("Set key chord")
+                                    .clicked()
+                                {
+                                    action = Some(HotkeyAction::Capture(slot.slot.clone()));
+                                }
+                                if slot.key_chord.is_some()
+                                    && ui
+                                        .add(Button::new(ICON_BACKSPACE).frame(false))
+                                        .on_hover_text("Clear key chord")
+                                        .clicked()
+                                {
+                                    action = Some(HotkeyAction::ClearChord(slot.slot.clone()));
+                                }
+                                if ui
+                                    .add(Button::new(ICON_PLAY_ARROW).frame(false))
+                                    .on_hover_text("Play")
+                                    .clicked()
+                                {
+                                    action = Some(HotkeyAction::Play(slot.slot.clone()));
+                                }
+                            });
+                        });
+                    });
+                }
+            });
+
+        action
+    }
+
+    fn handle_hotkey_action(&mut self, action: HotkeyAction) {
+        match action {
+            HotkeyAction::Remove(slot) => {
+                make_request_async(Request::clear_hotkey(&slot));
+                self.app_state.hotkey_config.remove_slot(&slot);
+            }
+            HotkeyAction::Capture(slot) => {
+                self.app_state.assigning_hotkey_slot = Some(slot);
+                self.app_state.hotkey_capture_active = true;
+            }
+            HotkeyAction::ClearChord(slot) => {
+                make_request_async(Request::clear_hotkey_key(&slot));
+                self.app_state.hotkey_config.set_key_chord(&slot, None);
+            }
+            HotkeyAction::Play(slot) => {
+                self.play_hotkey_slot(&slot);
+            }
+        }
+    }
+}

src/gui/views/mod.rs

@@ -0,0 +1,32 @@
+use crate::gui::SoundpadGui;
+use egui::Ui;
+use egui_material_icons::icons::*;
+
+mod body;
+mod footer;
+mod header;
+mod hotkey_capture;
+mod hotkeys;
+mod settings;
+mod waiting_for_daemon;
+
+impl SoundpadGui {
+    pub(crate) fn get_volume_icon(volume: f32) -> &'static str {
+        if volume > 0.7 {
+            ICON_VOLUME_UP.codepoint
+        } else if volume <= 0.0 {
+            ICON_VOLUME_OFF.codepoint
+        } else if volume < 0.3 {
+            ICON_VOLUME_MUTE.codepoint
+        } else {
+            ICON_VOLUME_DOWN.codepoint
+        }
+    }
+
+    pub fn draw(&mut self, ui: &mut Ui) {
+        self.draw_header(ui);
+        self.draw_body(ui);
+        ui.separator();
+        self.draw_footer(ui);
+    }
+}

src/gui/views/settings.rs

@@ -0,0 +1,64 @@
+use crate::gui::SoundpadGui;
+use egui::{Align, Button, Color32, Layout, RichText, Ui};
+use egui_material_icons::icons::ICON_ARROW_BACK;
+use rust_i18n::t;
+
+impl SoundpadGui {
+    pub fn draw_settings(&mut self, ui: &mut Ui) {
+        ui.vertical(|ui| {
+            ui.spacing_mut().item_spacing.y = 5.0;
+            // --------- Back Button and Title ----------
+            ui.horizontal_top(|ui| {
+                let back_button = Button::new(ICON_ARROW_BACK).frame(false);
+                let back_button_response = ui.add(back_button);
+                if back_button_response.clicked() {
+                    self.app_state.show_settings = false;
+                }
+
+                ui.add_space(ui.available_width() / 2.0 - 40.0);
+
+                ui.label(
+                    RichText::new(t!("gui.settings.header"))
+                        .color(Color32::WHITE)
+                        .monospace(),
+                );
+            });
+            // --------------------------------
+
+            ui.separator();
+            ui.add_space(20.0);
+
+            // --------- Checkboxes ----------
+            let save_volume_response = ui.checkbox(
+                &mut self.config.save_volume,
+                t!("gui.settings.remember_volume"),
+            );
+            let save_input_response =
+                ui.checkbox(&mut self.config.save_input, t!("gui.settings.remember_mic"));
+            let save_scale_response = ui.checkbox(
+                &mut self.config.save_scale_factor,
+                t!("gui.settings.remember_ui_scale"),
+            );
+            let pause_on_exit_response = ui.checkbox(
+                &mut self.config.pause_on_exit,
+                t!("gui.settings.pause_on_window_close"),
+            );
+
+            if save_volume_response.changed()
+                || save_input_response.changed()
+                || save_scale_response.changed()
+                || pause_on_exit_response.changed()
+            {
+                self.config.save_to_file().ok();
+            }
+            // --------------------------------
+
+            ui.with_layout(Layout::bottom_up(Align::Min), |ui| {
+                ui.label(t!(
+                    "gui.settings.version",
+                    version = env!("CARGO_PKG_VERSION")
+                ));
+            });
+        });
+    }
+}

src/gui/views/waiting_for_daemon.rs

@@ -0,0 +1,14 @@
+use crate::gui::SoundpadGui;
+use egui::{RichText, Ui};
+
+impl SoundpadGui {
+    pub fn draw_waiting_for_daemon(&mut self, ui: &mut Ui) {
+        ui.centered_and_justified(|ui| {
+            ui.label(
+                RichText::new("Waiting for PWSP daemon to start...")
+                    .size(34.0)
+                    .monospace(),
+            );
+        });
+    }
+}

src/utils/daemon.rs

@@ -5,9 +5,9 @@ use crate::types::{
 };
 
 use anyhow::Result;
-use std::os::unix::fs::PermissionsExt;
+use std::os::unix::fs::{DirBuilderExt, MetadataExt, PermissionsExt};
 use std::path::PathBuf;
-use std::{error::Error, fs};
+use std::{env, error::Error, fs};
 use tokio::{
     io::{AsyncReadExt, AsyncWriteExt},
     net::UnixStream,
@@ -37,22 +37,52 @@ pub fn get_daemon_config() -> DaemonConfig {
     })
 }
 
+fn get_current_uid() -> u32 {
+    rustix::process::geteuid().as_raw()
+}
+
 pub fn get_runtime_dir() -> PathBuf {
-    dirs::runtime_dir().unwrap_or(PathBuf::from("/run/pwsp"))
+    dirs::runtime_dir().unwrap_or_else(|| {
+        let uid = get_current_uid();
+        env::temp_dir().join(format!("pwsp-{}", uid))
+    })
 }
 
 pub fn create_runtime_dir() -> Result<()> {
     let runtime_dir = get_runtime_dir();
-    if !runtime_dir.exists() {
+
-        fs::create_dir_all(&runtime_dir)?;
+    if runtime_dir.exists() {
+        let meta = fs::symlink_metadata(&runtime_dir)?;
+        if meta.is_symlink() {
+            return Err(anyhow::anyhow!("Runtime directory is a symlink"));
+        }
+        let uid = get_current_uid();
+        if meta.uid() != uid {
+            return Err(anyhow::anyhow!(
+                "Runtime directory is owned by another user"
+            ));
+        }
+        if meta.permissions().mode() & 0o777 != 0o700 {
+            return Err(anyhow::anyhow!(
+                "Runtime directory has incorrect permissions"
+            ));
+        }
+    } else {
+        fs::DirBuilder::new()
+            .recursive(true)
+            .mode(0o700)
+            .create(&runtime_dir)?;
     }
-    fs::set_permissions(&runtime_dir, fs::Permissions::from_mode(0o700))?;
 
     Ok(())
 }
 
 pub fn is_daemon_running() -> Result<bool> {
-    let lock_file = fs::File::create(get_runtime_dir().join("daemon.lock"))?;
+    let lock_file = fs::OpenOptions::new()
+        .create(true)
+        .write(true)
+        .truncate(false)
+        .open(get_runtime_dir().join("daemon.lock"))?;
     match lock_file.try_lock() {
         Ok(_) => Ok(false),
         Err(_) => Ok(true),

src/utils/pipewire.rs

@@ -86,7 +86,7 @@ fn parse_global_object(
 async fn pw_get_global_objects_thread(
     main_sender: mpsc::Sender<(Option<AudioDevice>, Option<Port>)>,
     pw_receiver: pipewire::channel::Receiver<Terminate>,
-    init_sender: std::sync::mpsc::SyncSender<Result<(), String>>,
+    init_sender: tokio::sync::oneshot::Sender<Result<(), String>>,
 ) {
     let (main_loop, context) = match setup_pipewire_context() {
         Ok(res) => res,
@@ -147,7 +147,7 @@ pub async fn get_all_devices() -> Result<(Vec<AudioDevice>, Vec<AudioDevice>)> {
     // Channels to communicate with pipewire thread
     let (main_sender, mut main_receiver) = mpsc::channel(10);
     let (pw_sender, pw_receiver) = pipewire::channel::channel();
-    let (init_sender, init_receiver) = std::sync::mpsc::sync_channel(0);
+    let (init_sender, init_receiver) = tokio::sync::oneshot::channel();
 
     // Spawn pipewire thread in background
     let _pw_thread = tokio::spawn(async move {
@@ -155,7 +155,7 @@ pub async fn get_all_devices() -> Result<(Vec<AudioDevice>, Vec<AudioDevice>)> {
     });
 
     // Wait for initialization to complete
-    if let Err(e) = init_receiver.recv()? {
+    if let Err(e) = init_receiver.await {
         return Err(anyhow!(e));
     }