update deps and change version to 1.7.6 (#92 )

* change version to 1.7.6 * cargo update cpal v0.18.0 #e5d618c6 -> #f938e338 fax v0.2.6 -> v0.2.7 fax_derive - idna_adapter v1.2.1 -> v1.2.2 js-sys v0.3.95 -> v0.3.97 wasm-bindgen v0.2.118 -> v0.2.120 wasm-bindgen-futures v0.4.68 -> v0.4.70 wasm-bindgen-macro v0.2.118 -> v0.2.120 wasm-bindgen-macro-support v0.2.118 -> v0.2.120 wasm-bindgen-shared v0.2.118 -> v0.2.120 web-sys v0.3.95 -> v0.3.97 winnow - zbus v5.14.0 -> v5.15.0 zbus_macros v5.14.0 -> v5.15.0 zbus_names v4.3.1 -> v4.3.2 zvariant v5.10.0 -> v5.10.1 zvariant_derive v5.10.0 -> v5.10.1 zvariant_utils v3.3.0 -> v3.3.1 * deps: update cargo-sources.json
fix clippy lints under rust 1.95 (#90 )
2026-04-28 14:31:23 +00:00 · 2026-04-28 14:31:27 +03:00 · 2026-04-28 14:13:11 +03:00 · 2026-04-28 14:10:17 +03:00 · 2026-04-27 23:07:13 +03:00 · 2026-04-27 23:05:39 +03:00
33 changed files with 9360 additions and 796 deletions
@@ -0,0 +1,88 @@
+name: Flatter
+
+on:
+  push:
+    branches: [ main, master ]
+  release:
+    types: [ published ]
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: "TAG (empty to build from current branch)"
+        required: false
+        type: string
+      build_branch:
+        description: "Flatpak branch to build (stable/nightly)"
+        required: true
+        type: choice
+        options:
+          - stable
+          - nightly
+        default: "stable"
+
+jobs:
+  flatter:
+    name: Flatter
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    container:
+      image: ghcr.io/andyholmes/flatter/freedesktop:25.08
+      options: --privileged
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.tag_name || github.ref }}
+
+      - name: Setup GPG
+        id: gpg
+        uses: crazy-max/ghaction-import-gpg@v6
+        with:
+          gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
+          passphrase: ${{ secrets.GPG_PASSPHRASE }}
+
+      - name: Set Default Branch
+        id: set_branch
+        run: |
+          if [ "${{ github.event_name }}" == "release" ]; then
+            echo "branch=stable" >> $GITHUB_OUTPUT
+          elif [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
+            echo "branch=${{ inputs.build_branch }}" >> $GITHUB_OUTPUT
+          else
+            echo "branch=nightly" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Modify Manifest
+        run: |
+          echo "branch: ${{ steps.set_branch.outputs.branch }}" >> packages/flatpak/ru.arabianq.pwsp.yaml
+          echo "default-branch: ${{ steps.set_branch.outputs.branch }}" >> packages/flatpak/ru.arabianq.pwsp.yaml
+
+      - name: Install SDK Extensions
+        run: flatpak install -y flathub org.freedesktop.Sdk.Extension.rust-stable//25.08
+          org.freedesktop.Sdk.Extension.llvm20//25.08
+
+      - name: Build Flatpak
+        uses: andyholmes/flatter@main
+        with:
+          files: packages/flatpak/ru.arabianq.pwsp.yaml
+          gpg-sign: ${{ steps.gpg.outputs.fingerprint }}
+          upload-bundles: false
+          upload-pages-artifact: true
+
+  deploy:
+    name: Deploy to GitHub Pages
+    runs-on: ubuntu-latest
+    needs: flatter
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+
+    steps:
+      - name: GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
@@ -174,10 +174,3 @@ jobs:
          cache: true
          branch: master
          build-bundle: true
-
-      - name: Upload Flatpak to release
-        uses: softprops/action-gh-release@v2
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          tag_name: ${{ needs.prepare.outputs.tag }}
-          files: ru.arabianq.pwsp.flatpak
@@ -1,6 +1,6 @@
 [package]
 name = "pwsp"
-version = "1.6.3"
+version = "1.7.6"
 edition = "2024"
 authors = ["arabian"]
 description = "PWSP lets you play audio files through your microphone. Has both CLI and GUI clients."
@@ -12,13 +12,13 @@ keywords = ["soundpad", "pipewire", "linux", "cli", "gui"]


 [dependencies]
-tokio = { version = "1.50.0", features = ["full"] }
+tokio = { version = "1.52.1", features = ["full"] }
 async-trait = "0.1.89"

 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"

-clap = { version = "4.6.0", default-features = false, features = [
+clap = { version = "4.6.1", default-features = false, features = [
    "std",
    "suggestions",
    "help",
@@ -29,11 +29,13 @@ clap = { version = "4.6.0", default-features = false, features = [
 dirs = "6.0.0"
 itertools = "0.14.0"

-rodio = { version = "0.22.2", default-features = false, features = [
+rodio = { git = "https://github.com/RustAudio/rodio.git", rev = "57ad9d8a9f30398f634fbf8e4e1d53dde7243c21", default-features = false, features = [
    "symphonia-all",
+    "symphonia-libopus",
    "playback",
 ] }
 pipewire = "0.9.2"
+evdev = { version = "0.13.2", features = ["tokio"] }
 rfd = { version = "0.17.2", default-features = false, features = [
    "xdg-portal",
 ] }
@@ -49,6 +51,7 @@ eframe = { version = "0.34.1", default-features = false, features = [
    "x11",
    "wayland",
 ] }
+egui_extras = "0.34.1"
 egui_material_icons = "0.6.0"
 egui_dnd = "0.15.0"

@@ -27,6 +27,8 @@ chats on platforms like **Discord, Zoom, or Teamspeak**.
 * **Collapsible Audio Tracks**: You can collapse every audio track to save space.
 * **Drag and Drop Directories**: Reorder your sound directories easily using drag and drop.
 * **Automatic Device Detection**: PWSP automatically detects when an input device is connected or disconnected and handles linking/unlinking.
+* **Global Hotkeys**: Assign custom keyboard shortcuts to any sound file (or action) to trigger playback instantly, even when the application is not in focus.
+

 # **⚙️ How It Works**

@@ -38,8 +40,8 @@ three main components:
    * Creating and managing virtual audio devices.
    * Linking these devices within the PipeWire graph.
    * Handling all audio playback.
+* **UnixSocket**. This is how you interact with your sound collection, control playback, and configure settings.
 * **pwsp-gui**: This is the graphical user interface. It acts as a client that communicates with pwsp-daemon via a
-  **UnixSocket**. This is how you interact with your sound collection, control playback, and configure settings.
 * **pwsp-cli**: This is the command-line interface, also acting as a client. It provides a way to control the daemon
  without a GUI, allowing for scripting or quick command-based actions.

@@ -50,6 +52,28 @@ three main components:
 You can download pre-built binaries and .deb packages from
 the [releases page](https://github.com/arabianq/pipewire-soundpad/releases).

+## **Flatpak**
+
+You can install PWSP via Flatpak from our custom repository hosted on GitHub Pages.
+
+Add the repository:
+
+```bash
+flatpak remote-add --user --if-not-exists arabianq-repo https://arabianq.github.io/pipewire-soundpad/index.flatpakrepo
+```
+
+Install the stable version:
+
+```bash
+flatpak install --user arabianq-repo ru.arabianq.pwsp//stable
+```
+
+Or install the nightly version (latest commit to `main`):
+
+```bash
+flatpak install --user arabianq-repo ru.arabianq.pwsp//nightly
+```
+
 ## **Fedora Linux (and derivatives)**

 If you're using Fedora, you can install PWSP from a dedicated repository using DNF.
@@ -1,7 +1,7 @@
 pkgbase = pwsp-bin
 pkgdesc = Lets you play audio files through your microphone (Pre-built binaries)
-pkgver = 1.6.3
-pkgrel = 2
+pkgver = 1.7.6
+pkgrel = 1
 url = https://github.com/arabianq/pipewire-soundpad
 arch = x86_64
 license = MIT
@@ -9,8 +9,8 @@ depends = pipewire
 depends = alsa-lib
 provides = pwsp
 conflicts = pwsp
-source = pwsp-bin-1.6.3.zip :: https://github.com/arabianq/pipewire-soundpad/releases/download/v1.6.3/pwsp-v1.6.3-linux-x64.zip
-source = pipewire-soundpad-1.6.3.tar.gz :: https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.6.3.tar.gz
+source = pwsp-bin-1.7.6.zip :: https://github.com/arabianq/pipewire-soundpad/releases/download/v1.7.6/pwsp-v1.7.6-linux-x64.zip
+source = pipewire-soundpad-1.7.6.tar.gz :: https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.7.6.tar.gz
 sha256sums = SKIP
 sha256sums = SKIP

@@ -1,8 +1,8 @@
 # Maintainer: Alexander Tarasov <a.tevg@ya.ru>
 pkgname=pwsp-bin
 _pkgname=pipewire-soundpad
-pkgver=1.6.3
-pkgrel=2
+pkgver=1.7.6
+pkgrel=1
 pkgdesc="Lets you play audio files through your microphone (Pre-built binaries)"
 arch=('x86_64')
 url="https://github.com/arabianq/pipewire-soundpad"
@@ -1,6 +1,6 @@
 pkgbase = pwsp
 	pkgdesc = Lets you play audio files through your microphone
-	pkgver = 1.6.3
+	pkgver = 1.7.6
 	pkgrel = 1
 	url = https://github.com/arabianq/pipewire-soundpad
 	arch = any
@@ -8,9 +8,10 @@ pkgbase = pwsp
 	makedepends = clang
 	makedepends = rust
 	makedepends = cargo
+	makedepends = cmake
 	makedepends = pipewire
 	makedepends = alsa-lib
-	source = https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.6.3.tar.gz
+	source = https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.7.6.tar.gz
 	sha256sums = SKIP

 pkgname = pwsp
@@ -1,13 +1,13 @@
 # Maintainer: Alexander Tarasov <a.tevg@ya.ru>
 pkgsubn=pwsp
 pkgname=pwsp
-pkgver=1.6.3
+pkgver=1.7.6
 pkgrel=1
 pkgdesc="Lets you play audio files through your microphone"
 arch=('any')
 url="https://github.com/arabianq/pipewire-soundpad"
 license=('MIT')
-makedepends=(clang rust cargo pipewire alsa-lib)
+makedepends=(clang rust cargo cmake pipewire alsa-lib)
 source=("$url/archive/refs/tags/v$pkgver.tar.gz")
 sha256sums=('SKIP')

@@ -0,0 +1,19 @@
+#!/bin/bash
+set -e
+
+if [ ! -f "Cargo.lock" ]; then
+    echo "Error: Cargo.lock not found. Please run this script from the project root."
+    return 1
+fi
+
+echo "Downloading flatpak-cargo-generator.py..."
+curl -sLO https://raw.githubusercontent.com/flatpak/flatpak-builder-tools/master/cargo/flatpak-cargo-generator.py
+chmod +x flatpak-cargo-generator.py
+
+echo "Generating cargo-sources.json..."
+python3 flatpak-cargo-generator.py Cargo.lock -o packages/flatpak/cargo-sources.json
+
+echo "Cleaning up..."
+rm flatpak-cargo-generator.py
+
+echo "Successfully generated packages/flatpak/cargo-sources.json"
@@ -5,5 +5,5 @@ Exec=pwsp-wrapper.py %u
 Icon=ru.arabianq.pwsp
 Terminal=false
 Type=Application
-Categories=Audio;Utility;
+Categories=AudioVideo;Audio;
 Keywords=soundpad;pipewire;audio;
@@ -15,11 +15,17 @@
    <launchable type="desktop-id">ru.arabianq.pwsp.desktop</launchable>
    <screenshots>
        <screenshot type="default">
-            <image>
-                https://raw.githubusercontent.com/arabianq/pipewire-soundpad/master/assets/screenshot.png</image>
+            <image>https://raw.githubusercontent.com/arabianq/pipewire-soundpad/master/assets/screenshot.png</image>
        </screenshot>
    </screenshots>
    <url type="homepage">https://pwsp.arabianq.ru</url>
-    <developer_name>arabian</developer_name>
+    <url type="bugtracker">https://github.com/arabianq/pipewire-soundpad/issues</url>
+    <url type="vcs-browser">https://github.com/arabianq/pipewire-soundpad</url>
+    <developer id="ru.arabianq">
+        <name>arabian</name>
+    </developer>
+    <releases>
+        <release version="1.7.6" date="2026-04-28" />
+    </releases>
    <content_rating type="oars-1.1" />
 </component>
@@ -14,10 +14,9 @@ finish-args:
  - --filesystem=xdg-run/pipewire-0
  - --filesystem=xdg-run/pwsp:create
  - --filesystem=xdg-run/app/ru.arabianq.pwsp:create
-  - --filesystem=host
+  - --filesystem=home
  - --device=all
  - --device=dri
-  - --share=network
  - --talk-name=org.freedesktop.portal.Desktop
  - --talk-name=org.freedesktop.portal.Documents

@@ -30,11 +29,8 @@ build-options:
 modules:
  - name: pwsp
    buildsystem: simple
-    build-options:
-      build-args:
-        - --share=network
    build-commands:
-      - cargo build --release
+      - export CARGO_HOME=$PWD/cargo && cargo build --release --offline
      - install -Dm755 target/release/pwsp-daemon /app/bin/pwsp-daemon
      - install -Dm755 target/release/pwsp-cli /app/bin/pwsp-cli
      - install -Dm755 target/release/pwsp-gui /app/bin/pwsp-gui
@@ -45,3 +41,4 @@ modules:
    sources:
      - type: dir
        path: ../../
+      - cargo-sources.json
@@ -4,7 +4,7 @@
 %global cargo_install_lib 0

 Name:            pwsp
-Version:         1.6.3
+Version:         1.7.6
 Release:         %autorelease
 Summary:         Lets you play audio files through your microphone

@@ -18,6 +18,7 @@ BuildRequires: cargo
 BuildRequires: pipewire-devel
 BuildRequires: alsa-lib-devel
 BuildRequires: clang-devel
+BuildRequires: cmake

 %global _description %{expand:
 PWSP lets you play audio files through your microphone. Has both CLI and
@@ -68,6 +68,12 @@ enum Actions {
        #[clap(short, long)]
        id: Option<u32>,
    },
+    /// Play a sound by hotkey slot name
+    PlayHotkey { slot: String },
+    /// Remove the hotkey slot
+    ClearHotkey { slot: String },
+    /// Clear the key chord for a hotkey slot
+    ClearHotkeyKey { slot: String },
 }

 #[derive(Subcommand, Debug)]
@@ -101,6 +107,8 @@ enum GetCommands {
    DaemonVersion,
    /// Full player state
    FullState,
+    /// All hotkey slots
+    Hotkeys,
 }

 #[derive(Subcommand, Debug)]
@@ -125,6 +133,16 @@ enum SetCommands {
        #[clap(short, long)]
        id: Option<u32>,
    },
+    /// Assign a sound file to a hotkey slot
+    Hotkey { slot: String, file_path: PathBuf },
+    /// Set the key chord for a hotkey slot (e.g. "Ctrl+Alt+1")
+    HotkeyKey { slot: String, key_chord: String },
+    /// Atomically set the action and key chord for a hotkey slot
+    HotkeyActionAndKey {
+        slot: String,
+        action: String,
+        key_chord: String,
+    },
 }

 #[tokio::main]
@@ -146,6 +164,9 @@ async fn main() -> Result<(), Box<dyn Error>> {
                concurrent,
            } => Request::play(&file_path.to_string_lossy(), concurrent),
            Actions::ToggleLoop { id } => Request::toggle_loop(id),
+            Actions::PlayHotkey { slot } => Request::play_hotkey(&slot),
+            Actions::ClearHotkey { slot } => Request::clear_hotkey(&slot),
+            Actions::ClearHotkeyKey { slot } => Request::clear_hotkey_key(&slot),
        },
        Commands::Get { parameter } => match parameter {
            GetCommands::IsPaused => Request::get_is_paused(),
@@ -158,12 +179,28 @@ async fn main() -> Result<(), Box<dyn Error>> {
            GetCommands::Inputs => Request::get_inputs(),
            GetCommands::DaemonVersion => Request::get_daemon_version(),
            GetCommands::FullState => Request::get_full_state(),
+            GetCommands::Hotkeys => Request::get_hotkeys(),
        },
        Commands::Set { parameter } => match parameter {
            SetCommands::Volume { volume, id } => Request::set_volume(volume, id),
            SetCommands::Position { position, id } => Request::seek(position, id),
            SetCommands::Input { name } => Request::set_input(&name),
            SetCommands::Loop { enabled, id } => Request::set_loop(&enabled, id),
+            SetCommands::Hotkey { slot, file_path } => {
+                Request::set_hotkey(&slot, &file_path.to_string_lossy())
+            }
+            SetCommands::HotkeyKey { slot, key_chord } => {
+                Request::set_hotkey_key(&slot, &key_chord)
+            }
+            SetCommands::HotkeyActionAndKey {
+                slot,
+                action,
+                key_chord,
+            } => Request::set_hotkey_action_and_key(
+                &slot,
+                &serde_json::from_str::<Request>(&action)?,
+                &key_chord,
+            ),
        },
    };

@@ -1,11 +1,12 @@
 use pwsp::{
-    types::socket::{Request, Response},
+    types::socket::{MAX_MESSAGE_SIZE, Request, Response},
    utils::{
        commands::parse_command,
        daemon::{
            create_runtime_dir, get_audio_player, get_daemon_config, get_runtime_dir,
-            is_daemon_running, link_player_to_virtual_mic,
+            is_daemon_running,
        },
+        global_hotkeys::start_global_hotkey_listener,
        pipewire::create_virtual_mic,
    },
 };
@@ -32,18 +33,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
    } // Initialize audio player

    tokio::spawn(async {
-        let max_retries = 60;
-        for i in 0..=max_retries {
-            match link_player_to_virtual_mic().await {
-                Ok(_) => {
-                    println!("Successfully linked player to virtual mic.");
-                    break;
-                }
-                Err(e) => println!("{e}\t{i}/{max_retries}"),
-            }
-
-            sleep(Duration::from_millis(1000)).await;
-        }
+        start_global_hotkey_listener().await;
    });

    let runtime_dir = get_runtime_dir();
@@ -52,11 +42,11 @@ async fn main() -> Result<(), Box<dyn Error>> {
    lock_file.lock()?;

    let socket_path = runtime_dir.join("daemon.sock");
-    if let Err(e) = fs::remove_file(&socket_path) {
-        if e.kind() != std::io::ErrorKind::NotFound {
+    if let Err(e) = fs::remove_file(&socket_path)
+        && e.kind() != std::io::ErrorKind::NotFound
+    {
        return Err(e.into());
    }
-    }

    let listener = UnixListener::bind(&socket_path)?;
    fs::set_permissions(&socket_path, fs::Permissions::from_mode(0o600))?;
@@ -100,7 +90,7 @@ async fn commands_loop(listener: UnixListener) -> Result<(), Box<dyn Error>> {

            let request_len = u32::from_le_bytes(len_bytes) as usize;

-            if request_len > 10 * 1024 * 1024 {
+            if request_len > MAX_MESSAGE_SIZE {
                eprintln!(
                    "Failed to read message from client: request too large ({} bytes)!",
                    request_len
@@ -169,19 +159,25 @@ async fn commands_loop(listener: UnixListener) -> Result<(), Box<dyn Error>> {
 }

 async fn player_loop() {
+    let mut device_check_counter: u32 = 0;
    loop {
-        match get_audio_player().await {
+        let is_idle = match get_audio_player().await {
            Ok(player_mutex) => {
                let mut audio_player = player_mutex.lock().await;
-                audio_player.update().await;
-            }
-            Err(_err) => {
-                // To avoid spamming logs every 100ms when audio player fails to init
-                // we can just sleep, or you might prefer to print the error.
-                // Assuming it failed to initialize, no player update is possible.
-            }
+                let check_devices = device_check_counter == 0;
+                audio_player.update(check_devices).await;
+                audio_player.tracks.is_empty()
            }
+            Err(_err) => true,
+        };

+        if is_idle {
+            device_check_counter = 0;
+            sleep(Duration::from_secs(2)).await;
+        } else {
+            // Check devices every ~5 seconds (50 * 100ms) while playing
+            device_check_counter = (device_check_counter + 1) % 50;
            sleep(Duration::from_millis(100)).await;
        }
+    }
 }
@@ -4,10 +4,15 @@ use egui::{
    Layout, RichText, ScrollArea, Sense, Slider, TextEdit, Ui, Vec2,
 };
 use egui_dnd::dnd;
+use egui_extras::{Column, TableBuilder};
 use egui_material_icons::icons::*;
+use pwsp::types::socket::Request;
 use pwsp::types::{audio_player::TrackInfo, gui::AppState};
-use pwsp::utils::gui::format_time_pair;
-use std::{error::Error, time::Instant};
+use pwsp::utils::gui::{format_time_pair, make_request_async};
+use std::{
+    path::Path,
+    time::Instant,
+};

 enum TrackAction {
    Pause(u32),
@@ -16,6 +21,13 @@ enum TrackAction {
    Stop(u32),
 }

+enum HotkeyAction {
+    Remove(String),
+    Capture(String),
+    ClearChord(String),
+    Play(String),
+}
+
 impl SoundpadGui {
    fn get_volume_icon(volume: f32) -> &'static str {
        if volume > 0.7 {
@@ -29,6 +41,13 @@ impl SoundpadGui {
        }
    }

+    pub fn draw(&mut self, ui: &mut Ui) {
+        self.draw_header(ui);
+        self.draw_body(ui);
+        ui.separator();
+        self.draw_footer(ui);
+    }
+
    pub fn draw_waiting_for_daemon(&mut self, ui: &mut Ui) {
        ui.centered_and_justified(|ui| {
            ui.label(
@@ -39,6 +58,32 @@ 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("Press a key combination (e.g. Ctrl+Alt+1)")
+                    .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!("for slot '{}'", slot)
+            } else if let Some(path) = &self.app_state.assigning_hotkey_for_file {
+                format!(
+                    "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("Press Escape to cancel");
+        });
+    }
+
    pub fn draw_settings(&mut self, ui: &mut Ui) {
        ui.vertical(|ui| {
            ui.spacing_mut().item_spacing.y = 5.0;
@@ -88,12 +133,287 @@ impl SoundpadGui {
        });
    }

-    pub fn draw(&mut self, ui: &mut Ui) -> Result<(), Box<dyn Error>> {
-        self.draw_header(ui);
-        self.draw_body(ui);
+    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_footer(ui);
-        Ok(())
+
+            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("Hotkeys").color(Color32::WHITE).monospace());
+            });
+        });
+    }
+
+    fn draw_hotkeys_search(&mut self, ui: &mut Ui) {
+        ui.horizontal(|ui| {
+            ui.menu_button(format!("{} Add Command", ICON_ADD.codepoint), |ui| {
+                let mut selected_cmd = None;
+                if ui.button("Toggle Pause").clicked() {
+                    selected_cmd = Some(("cmd_toggle_pause", Request::toggle_pause(None)));
+                }
+                if ui.button("Stop Playback").clicked() {
+                    selected_cmd = Some(("cmd_stop", Request::stop(None)));
+                }
+                if ui.button("Pause Playback").clicked() {
+                    selected_cmd = Some(("cmd_pause", Request::pause(None)));
+                }
+                if ui.button("Resume Playback").clicked() {
+                    selected_cmd = Some(("cmd_resume", Request::resume(None)));
+                }
+                if ui.button("Toggle Loop").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("Search hotkeys...")
+                    .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)
+            })
+            .cloned()
+            .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("Slot")
+                            .strong()
+                            .monospace()
+                            .color(Color32::LIGHT_GRAY),
+                    );
+                });
+                header.col(|ui| {
+                    ui.label(
+                        RichText::new("Sound")
+                            .strong()
+                            .monospace()
+                            .color(Color32::LIGHT_GRAY),
+                    );
+                });
+                header.col(|ui| {
+                    ui.label(
+                        RichText::new("Key Chord")
+                            .strong()
+                            .monospace()
+                            .color(Color32::LIGHT_GRAY),
+                    );
+                });
+                header.col(|ui| {
+                    ui.label(
+                        RichText::new("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("No hotkey slots 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);
+            }
+        }
    }

    fn draw_header(&mut self, ui: &mut Ui) {
@@ -103,10 +423,9 @@ impl SoundpadGui {
                return;
            }

-            let tracks = self.audio_player_state.tracks.clone();
            let mut action = None;

-            for track in tracks {
+            for track in &self.audio_player_state.tracks {
                CollapsingHeader::new(
                    RichText::new(
                        track
@@ -121,7 +440,7 @@ impl SoundpadGui {
                )
                .default_open(true)
                .show(ui, |ui| {
-                    if let Some(act) = Self::draw_track_control(ui, &mut self.app_state, &track) {
+                    if let Some(act) = Self::draw_track_control(ui, &mut self.app_state, track) {
                        action = Some(act);
                    }
                });
@@ -139,6 +458,99 @@ impl SoundpadGui {
        });
    }

+    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,
@@ -169,93 +581,17 @@ impl SoundpadGui {
        let mut action = None;

        ui.horizontal_top(|ui| {
-            // ---------- Play Button ----------
-            let play_button = Button::new(if track.paused {
-                ICON_PLAY_ARROW
-            } else {
-                ICON_PAUSE
-            })
-            .corner_radius(15.0);
-
-            let play_button_response = ui.add_sized([30.0, 30.0], play_button);
-            if play_button_response.clicked() {
-                if track.paused {
-                    action = Some(TrackAction::Resume(track.id));
-                } else {
-                    action = Some(TrackAction::Pause(track.id));
+            if let Some(act) = Self::draw_playback_controls(ui, track) {
+                action = Some(act);
            }
-            }
-            // --------------------------------
-
-            // ---------- Loop Button ----------
-            let loop_button = Button::new(
-                RichText::new(if track.looped {
-                    ICON_REPEAT_ONE
-                } else {
-                    ICON_REPEAT
-                })
-                .size(18.0),
-            )
-            .frame(false);
-
-            let loop_button_response = ui.add_sized([15.0, 30.0], loop_button);
-            if loop_button_response.clicked() {
-                action = Some(TrackAction::ToggleLoop(track.id));
-            }
-            // --------------------------------
-
-            // ---------- Position Slider ----------
-            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 default_slider_width = ui.spacing().slider_width;
-            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;
-            let position_slider_response = ui.add_sized([30.0, 30.0], position_slider);
-            if position_slider_response.drag_stopped() {
-                ui_state.position_dragged = true;
+            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);
            }
-            // --------------------------------
-
-            // ---------- Time Label ----------
-            let time_label =
-                Label::new(RichText::new(format_time_pair(track.position, duration)).monospace());
-            ui.add_sized([30.0, 30.0], time_label);
-            // --------------------------------
-
-            // ---------- Volume Icon ----------
-            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));
-            // --------------------------------
-
-            // ---------- Volume Slider ----------
-            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;
-
-            let volume_slider_response = ui.add_sized([30.0, 30.0], volume_slider);
-            if volume_slider_response.drag_stopped() {
-                ui_state.volume_dragged = true;
-            }
-            // --------------------------------
-
-            // ---------- Stop Button ---------
-            let stop_button = Button::new(ICON_CLOSE).frame(false);
-            let stop_button_response = ui.add_sized([30.0, 30.0], stop_button);
-            if stop_button_response.clicked() {
-                action = Some(TrackAction::Stop(track.id));
-            }
-            // --------------------------------
        });

        action
@@ -321,11 +657,11 @@ impl SoundpadGui {
                            .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 {
-                            if current_dir.eq(&path) {
+                        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);
@@ -357,11 +693,10 @@ impl SoundpadGui {
                                    ICON_OPEN_IN_BROWSER.codepoint, "Open in File Manager"
                                ))
                                .clicked()
+                                && let Err(e) = opener::open(&path)
                            {
-                                if let Err(e) = opener::open(&path) {
                                eprintln!("Failed to open file manager: {}", e);
                            }
-                            }

                            ui.separator();

@@ -423,25 +758,38 @@ impl SoundpadGui {
                    for entry_path in files {
                        let file_name = entry_path
                            .file_name()
-                            .unwrap()
+                            .unwrap_or_default()
                            .to_string_lossy()
                            .to_string();

-                        let mut file_button_text = RichText::new(file_name);
-                        if let Some(current_file) = &self.app_state.selected_file {
-                            if current_file.eq(&entry_path) {
-                                file_button_text = file_button_text.color(Color32::WHITE);
-                            }
+                        ui.horizontal(|ui| {
+                            // Hotkey badge
+                            let hotkey_badge = self.get_hotkey_badge(&entry_path);
+                            if let Some(badge) = &hotkey_badge {
+                                ui.label(
+                                    RichText::new(badge)
+                                        .small()
+                                        .monospace()
+                                        .color(Color32::from_rgb(100, 200, 100)),
+                                );
                            }

-                        let file_button = Button::new(file_button_text).frame(false);
+                            let mut file_button_text = RichText::new(&file_name);
+                            if let Some(current_file) = &self.app_state.selected_file
+                                && current_file.eq(&entry_path)
+                            {
+                                file_button_text = file_button_text.color(Color32::WHITE);
+                            }
+
+                            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 {
                                        self.play_file(&entry_path, true);
                                    } else if i.modifiers.shift
-                                    && let Some(last_track) = self.audio_player_state.tracks.last()
+                                        && let Some(last_track) =
+                                            self.audio_player_state.tracks.last()
                                    {
                                        self.stop(Some(last_track.id));
                                        self.play_file(&entry_path, true);
@@ -471,7 +819,10 @@ impl SoundpadGui {
                                }

                                if ui
-                                .button(format!("{} {}", ICON_SWAP_HORIZ.codepoint, "Replace Last"))
+                                    .button(format!(
+                                        "{} {}",
+                                        ICON_SWAP_HORIZ.codepoint, "Replace Last"
+                                    ))
                                    .clicked()
                                    && let Some(last_track) = self.audio_player_state.tracks.last()
                                {
@@ -488,18 +839,49 @@ impl SoundpadGui {
                                        ICON_OPEN_IN_BROWSER.codepoint, "Show in File Manager"
                                    ))
                                    .clicked()
+                                    && let Err(e) = opener::reveal(&entry_path)
                                {
-                                if let Err(e) = opener::reveal(&entry_path) {
                                    eprintln!("Failed to open file manager: {}", e);
                                }
+
+                                ui.separator();
+
+                                if ui
+                                    .button(format!(
+                                        "{} {}",
+                                        ICON_KEYBOARD.codepoint, "Assign Hotkey"
+                                    ))
+                                    .clicked()
+                                {
+                                    self.app_state.assigning_hotkey_for_file =
+                                        Some(entry_path.clone());
+                                    self.app_state.hotkey_capture_active = true;
+                                    ui.close();
                                }
                            });
+                        });
                    }
                });
            });
        });
    }

+    fn get_hotkey_badge(&self, path: &Path) -> Option<String> {
+        for slot in &self.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 {
+                    return Some(format!("[{}]", chord));
+                } else {
+                    return Some(format!("[{}]", slot.slot));
+                }
+            }
+        }
+        None
+    }
+
    fn draw_footer(&mut self, ui: &mut Ui) {
        ui.add_space(5.0);
        ui.horizontal(|ui| {
@@ -556,7 +938,17 @@ impl SoundpadGui {
            }
            // ------------------------------------------

-            ui.add_space(ui.available_width() - 18.0 - ui.spacing().item_spacing.x);
+            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 =
@@ -1,8 +1,85 @@
 use crate::gui::SoundpadGui;
 use egui::{Context, Id, Key, Modifiers};
+use pwsp::types::socket::Request;
+use pwsp::utils::gui::make_request_async;

 use std::path::PathBuf;

+/// Convert an egui Key + Modifiers to a normalized chord string like "Ctrl+Shift+A".
+fn chord_from_event(modifiers: &Modifiers, key: &Key) -> Option<String> {
+    let key_name = key.name();
+    let is_valid = (key_name.len() == 1
+        && key_name
+            .chars()
+            .next()
+            .is_some_and(|c| c.is_ascii_alphanumeric()))
+        || (key_name.starts_with('F')
+            && key_name.len() > 1
+            && key_name[1..].chars().all(|c| c.is_ascii_digit()));
+    if !is_valid {
+        return None;
+    }
+
+    // Require at least one modifier for hotkey chords (ignoring command/Super due to Wayland/Niri bug)
+    if !modifiers.ctrl && !modifiers.alt && !modifiers.shift {
+        return None;
+    }
+
+    let mut parts = vec![];
+    if modifiers.ctrl {
+        parts.push("Ctrl");
+    }
+    if modifiers.alt {
+        parts.push("Alt");
+    }
+    if modifiers.shift {
+        parts.push("Shift");
+    }
+    // We intentionally ignore modifiers.command (Super) here to bypass a Wayland/Niri bug
+    // where the Super key modifier is constantly active.
+
+    parts.push(key_name);
+
+    Some(parts.join("+"))
+}
+
+/// Parse a chord string back to (Modifiers, Key) for matching.
+pub fn parse_chord(chord: &str) -> Option<(Modifiers, Key)> {
+    let parts: Vec<&str> = chord.split('+').collect();
+    if parts.is_empty() {
+        return None;
+    }
+
+    let mut modifiers = Modifiers::NONE;
+    for &part in &parts[..parts.len() - 1] {
+        match part {
+            "Ctrl" => modifiers.ctrl = true,
+            "Alt" => modifiers.alt = true,
+            "Shift" => modifiers.shift = true,
+            "Super" => modifiers.command = true,
+            _ => return None,
+        }
+    }
+
+    let key_name = parts[parts.len() - 1];
+    let is_valid = (key_name.len() == 1
+        && key_name
+            .chars()
+            .next()
+            .is_some_and(|c| c.is_ascii_alphanumeric()))
+        || (key_name.starts_with('F')
+            && key_name.len() > 1
+            && key_name[1..].chars().all(|c| c.is_ascii_digit()));
+
+    if !is_valid {
+        return None;
+    }
+
+    let key = Key::from_name(key_name)?;
+
+    Some((modifiers, key))
+}
+
 impl SoundpadGui {
    fn key_pressed(&self, ctx: &Context, key: Key) -> bool {
        ctx.input(|i| i.key_pressed(key))
@@ -29,12 +106,76 @@ impl SoundpadGui {
            }
        };

+        // Handle hotkey capture mode: listen for a key chord to assign
+        if self.app_state.hotkey_capture_active {
+            if self.key_pressed(ctx, Key::Escape) {
+                self.app_state.hotkey_capture_active = false;
+                self.app_state.assigning_hotkey_slot = None;
+                self.app_state.assigning_hotkey_for_file = None;
+                return;
+            }
+
+            // Try to capture a chord from any key press
+            let captured = ctx.input(|i| {
+                for event in &i.events {
+                    if let egui::Event::Key {
+                        key,
+                        pressed: true,
+                        modifiers: mods,
+                        ..
+                    } = event
+                        && let Some(chord) = chord_from_event(mods, key)
+                    {
+                        return Some(chord);
+                    }
+                }
+                None
+            });
+
+            if let Some(chord) = captured {
+                if let Some(slot) = self.app_state.assigning_hotkey_slot.take() {
+                    make_request_async(Request::set_hotkey_key(&slot, &chord));
+                    self.app_state
+                        .hotkey_config
+                        .set_key_chord(&slot, Some(chord));
+                } else if let Some(file_path) = self.app_state.assigning_hotkey_for_file.take() {
+                    // Auto-create a slot from the file name
+                    let slot_name = file_path
+                        .file_stem()
+                        .unwrap_or_default()
+                        .to_string_lossy()
+                        .to_string();
+                    let action = Request::play(&file_path.to_string_lossy(), false);
+
+                    make_request_async(Request::set_hotkey_action_and_key(
+                        &slot_name, &action, &chord,
+                    ));
+
+                    self.app_state
+                        .hotkey_config
+                        .set_slot(slot_name.clone(), action);
+                    self.app_state
+                        .hotkey_config
+                        .set_key_chord(&slot_name, Some(chord.clone()));
+                }
+                self.app_state.hotkey_capture_active = false;
+                self.app_state.assigning_hotkey_slot = None;
+                self.app_state.assigning_hotkey_for_file = None;
+            }
+            return;
+        }
+
        // Open/close settings
        if !search_focused && self.key_pressed(ctx, Key::I) {
            self.app_state.show_settings = !self.app_state.show_settings;
        }

-        if !self.app_state.show_settings {
+        // Toggle hotkeys view
+        if !search_focused && self.key_pressed(ctx, Key::H) {
+            self.app_state.show_hotkeys = !self.app_state.show_hotkeys;
+        }
+
+        if !self.app_state.show_settings && !self.app_state.show_hotkeys {
            // Pause / resume audio on space
            if !search_focused && self.key_pressed(ctx, Key::Space) {
                self.play_toggle();
@@ -57,8 +198,9 @@ impl SoundpadGui {
            }

            // Play selected file on Enter
-            if self.key_pressed(ctx, Key::Enter) {
-                if let Some(path) = self.app_state.selected_file.clone() {
+            if self.key_pressed(ctx, Key::Enter)
+                && let Some(path) = self.app_state.selected_file.clone()
+            {
                if modifiers.ctrl {
                    self.play_file(&path, true);
                } else if modifiers.shift
@@ -70,14 +212,13 @@ impl SoundpadGui {
                    self.play_file(&path, false);
                }
            }
-            }

            // Iterate through dirs and files with Ctrl + Up/Down
            let arrow_up_pressed = self.key_pressed(ctx, Key::ArrowUp);
            let arrow_down_pressed = self.key_pressed(ctx, Key::ArrowDown);
            if modifiers.ctrl && (arrow_up_pressed || arrow_down_pressed) {
                if modifiers.shift && !self.app_state.dirs.is_empty() {
-                    let mut dirs: Vec<PathBuf> = self.app_state.dirs.iter().cloned().collect();
+                    let mut dirs: Vec<PathBuf> = self.app_state.dirs.to_vec();
                    dirs.sort();

                    let current_dir_index = self
@@ -123,6 +264,25 @@ impl SoundpadGui {
                    self.app_state.selected_file = Some(files[new_files_index].clone());
                }
            }
+
+            // Check for hotkey chord triggers
+            let slots_to_play: Vec<String> = ctx.input(|i| {
+                let mut result = vec![];
+                for slot in &self.app_state.hotkey_config.slots {
+                    if let Some(chord) = &slot.key_chord
+                        && let Some((mods, key)) = parse_chord(chord)
+                        && i.modifiers == mods
+                        && i.key_pressed(key)
+                    {
+                        result.push(slot.slot.clone());
+                    }
+                }
+                result
+            });
+
+            for slot in slots_to_play {
+                self.play_hotkey_slot(&slot);
+            }
        }
        // });
    }
@@ -9,6 +9,7 @@ use pwsp::{
    types::{
        audio_player::PlayerState,
        config::GuiConfig,
+        config::HotkeyConfig,
        gui::{AppState, AudioPlayerState},
        socket::Request,
    },
@@ -20,12 +21,12 @@ use pwsp::{
 use rfd::FileDialog;
 use std::{
    error::Error,
-    path::PathBuf,
+    path::{Path, PathBuf},
    sync::{Arc, Mutex},
 };

-const SUPPORTED_EXTENSIONS: [&str; 11] = [
-    "mp3", "wav", "ogg", "flac", "mp4", "m4a", "aac", "mov", "mkv", "webm", "avi",
+const SUPPORTED_EXTENSIONS: [&str; 13] = [
+    "mp3", "wav", "ogg", "flac", "mp4", "m4a", "aac", "mov", "mkv", "mka", "webm", "avi", "opus",
 ];

 struct SoundpadGui {
@@ -52,6 +53,7 @@ impl SoundpadGui {
        };

        soundpad_gui.app_state.dirs = config.dirs;
+        soundpad_gui.app_state.hotkey_config = HotkeyConfig::load().unwrap_or_default();

        soundpad_gui
    }
@@ -118,7 +120,7 @@ impl SoundpadGui {
        }
    }

-    pub fn play_file(&mut self, path: &PathBuf, concurrent: bool) {
+    pub fn play_file(&mut self, path: &Path, concurrent: bool) {
        make_request_async(Request::play(&path.to_string_lossy(), concurrent));
    }

@@ -148,6 +150,10 @@ impl SoundpadGui {
        make_request_async(Request::stop(id));
    }

+    pub fn play_hotkey_slot(&mut self, slot: &str) {
+        make_request_async(Request::play_hotkey(slot));
+    }
+
    pub fn get_filtered_files(&self) -> Vec<PathBuf> {
        let mut files: Vec<PathBuf> = self.app_state.files.iter().cloned().collect();
        files.sort();
@@ -77,10 +77,13 @@ impl App for SoundpadGui {

        // Sync audio player state
        {
-            let guard = self
+            let mut guard = self
                .audio_player_state_shared
                .lock()
                .unwrap_or_else(|e| e.into_inner());
+            if let Some(config) = guard.hotkey_config.take() {
+                self.app_state.hotkey_config = config;
+            }
            self.audio_player_state = guard.clone();
        }

@@ -107,12 +110,22 @@ impl App for SoundpadGui {
                return;
            }

+            if self.app_state.hotkey_capture_active {
+                self.draw_hotkey_capture(ui);
+                return;
+            }
+
            if self.app_state.show_settings {
                self.draw_settings(ui);
                return;
            }

-            self.draw(ui).ok();
+            if self.app_state.show_hotkeys {
+                self.draw_hotkeys(ui);
+                return;
+            }
+
+            self.draw(ui);
        });

        // Request repaint
@@ -2,7 +2,7 @@ use crate::{
    types::pipewire::{DeviceType, Terminate},
    utils::{
        daemon::get_daemon_config,
-        pipewire::{create_link, get_device},
+        pipewire::{create_link, get_device, link_player_to_virtual_mic},
    },
 };
 use rodio::{Decoder, DeviceSinkBuilder, MixerDeviceSink, Player, Source};
@@ -53,11 +53,12 @@ pub struct PlayingSound {
 }

 pub struct AudioPlayer {
-    pub stream_handle: MixerDeviceSink,
+    stream_handle: Option<MixerDeviceSink>,
    pub tracks: HashMap<u32, PlayingSound>,
    pub next_id: u32,

    input_link_sender: Option<pipewire::channel::Sender<Terminate>>,
+    player_link_sender: Option<pipewire::channel::Sender<Terminate>>,
    pub input_device_name: Option<String>,

    pub volume: f32, // Master volume
@@ -68,14 +69,13 @@ impl AudioPlayer {
        let daemon_config = get_daemon_config();
        let default_volume = daemon_config.default_volume.unwrap_or(1.0);

-        let stream_handle = DeviceSinkBuilder::open_default_sink()?;
-
        let mut audio_player = AudioPlayer {
-            stream_handle,
+            stream_handle: None,
            tracks: HashMap::new(),
            next_id: 1,

            input_link_sender: None,
+            player_link_sender: None,
            input_device_name: daemon_config.default_input_name.clone(),

            volume: default_volume,
@@ -88,16 +88,56 @@ impl AudioPlayer {
        Ok(audio_player)
    }

+    fn ensure_stream(&mut self) -> Result<&MixerDeviceSink, Box<dyn Error>> {
+        if self.stream_handle.is_none() {
+            let mut sink = DeviceSinkBuilder::open_default_sink()?;
+            sink.log_on_drop(false);
+            self.stream_handle = Some(sink);
+        }
+        Ok(self.stream_handle.as_ref().unwrap())
+    }
+
+    fn drop_stream(&mut self) {
+        if self.stream_handle.is_some() {
+            self.stream_handle = None;
+            self.abort_player_link_thread();
+        }
+    }
+
    fn abort_link_thread(&mut self) {
        if let Some(sender) = &self.input_link_sender {
-            match sender.send(Terminate {}) {
-                Ok(_) => {
-                    println!("Sent terminate signal to link thread");
+            if sender.send(Terminate {}).is_ok() {
+                println!("Sent terminate signal to input link thread");
                self.input_link_sender = None;
+            } else {
+                eprintln!("Failed to send terminate signal to input link thread");
            }
-                Err(_) => eprintln!("Failed to send terminate signal to link thread"),
        }
    }
+
+    fn abort_player_link_thread(&mut self) {
+        if let Some(sender) = &self.player_link_sender {
+            if sender.send(Terminate {}).is_ok() {
+                println!("Sent terminate signal to player link thread");
+                self.player_link_sender = None;
+            } else {
+                eprintln!("Failed to send terminate signal to player link thread");
+            }
+        }
+    }
+
+    async fn link_player(&mut self) -> Result<(), Box<dyn Error>> {
+        if self.player_link_sender.is_some() {
+            return Ok(());
+        }
+
+        match link_player_to_virtual_mic().await {
+            Ok(sender) => {
+                self.player_link_sender = Some(sender);
+                Ok(())
+            }
+            Err(_) => Ok(()),
+        }
    }

    async fn link_devices(&mut self) -> Result<(), Box<dyn Error>> {
@@ -179,6 +219,9 @@ impl AudioPlayer {
        } else {
            self.tracks.clear();
        }
+        if self.tracks.is_empty() {
+            self.drop_stream();
+        }
    }

    pub fn is_paused(&self) -> bool {
@@ -211,12 +254,12 @@ impl AudioPlayer {
    pub fn get_volume(&mut self, id: Option<u32>) -> Option<f32> {
        if let Some(id) = id {
            if let Some(sound) = self.tracks.get_mut(&id) {
-                return Some(sound.sink.volume());
+                Some(sound.sink.volume())
            } else {
-                return None;
+                None
            }
        } else {
-            return Some(self.volume);
+            Some(self.volume)
        }
    }

@@ -299,12 +342,16 @@ impl AudioPlayer {
                    self.tracks.clear();
                }

+                self.ensure_stream()?;
+                self.link_player().await.ok();
+
                let id = self.next_id;
                self.next_id += 1;

                let duration = source.total_duration().map(|d| d.as_secs_f32());

-                let sink = Player::connect_new(self.stream_handle.mixer());
+                let mixer = self.stream_handle.as_ref().unwrap().mixer();
+                let sink = Player::connect_new(mixer);
                sink.set_volume(self.volume); // Default volume is 1.0 * master
                sink.append(source);
                sink.play();
@@ -358,11 +405,12 @@ impl AudioPlayer {
        tracks
    }

-    pub async fn update(&mut self) {
+    pub async fn update(&mut self, check_devices: bool) {
+        if check_devices {
            if let Some(input_device_name) = &self.input_device_name {
                // Unlink devices if selected input device was removed
-            if self.input_link_sender.is_some() && get_device(input_device_name).await.is_err() {
-                // Selected input device was removed
+                if self.input_link_sender.is_some() && get_device(input_device_name).await.is_err()
+                {
                    eprintln!(
                        "Selected input device {} was removed, unlinking devices",
                        input_device_name
@@ -375,6 +423,11 @@ impl AudioPlayer {
                }
            }

+            if self.stream_handle.is_some() && self.player_link_sender.is_none() {
+                self.link_player().await.ok();
+            }
+        }
+
        // Handle looped sounds
        let mut restarts = vec![];

@@ -390,11 +443,11 @@ impl AudioPlayer {
            if let Some(sound) = self.tracks.get(&id) {
                let path = sound.path.clone();
                let handle = tokio::task::spawn_blocking(move || {
-                    if let Ok(file) = fs::File::open(&path) {
-                        if let Ok(source) = Decoder::try_from(file) {
+                    if let Ok(file) = fs::File::open(&path)
+                        && let Ok(source) = Decoder::try_from(file)
+                    {
                        return Some((id, source));
                    }
-                    }
                    None
                });
                restart_futures.push(handle);
@@ -402,16 +455,21 @@ impl AudioPlayer {
        }

        for handle in restart_futures {
-            if let Ok(Some((id, source))) = handle.await {
-                if let Some(sound) = self.tracks.get_mut(&id) {
+            if let Ok(res) = handle.await
+                && let Some((id, source)) = res
+                && let Some(sound) = self.tracks.get_mut(&id)
+            {
                sound.sink.append(source);
                sound.sink.play();
            }
        }
-        }

        self.tracks
            .retain(|_, sound| !sound.sink.empty() || sound.looped);
+
+        if self.tracks.is_empty() {
+            self.drop_stream();
+        }
    }

    pub async fn set_current_input_device(&mut self, name: &str) -> Result<(), Box<dyn Error>> {
@@ -1,9 +1,11 @@
 use crate::{
    types::{
        audio_player::{FullState, PlayerState},
-        socket::Response,
+        config::HotkeyConfig,
+        socket::{Request, Response},
    },
    utils::{
+        commands::parse_command,
        daemon::get_audio_player,
        pipewire::{get_all_devices, get_device},
    },
@@ -90,6 +92,41 @@ pub struct GetDaemonVersionCommand {}

 pub struct GetFullStateCommand {}

+pub struct GetHotkeysCommand {}
+
+pub struct SetHotkeyCommand {
+    pub slot: Option<String>,
+    pub file_path: Option<PathBuf>,
+}
+
+pub struct SetHotkeyActionCommand {
+    pub slot: Option<String>,
+    pub action: Option<Request>,
+}
+
+pub struct SetHotkeyKeyCommand {
+    pub slot: Option<String>,
+    pub key_chord: Option<String>,
+}
+
+pub struct SetHotkeyActionAndKeyCommand {
+    pub slot: Option<String>,
+    pub action: Option<Request>,
+    pub key_chord: Option<String>,
+}
+
+pub struct PlayHotkeyCommand {
+    pub slot: Option<String>,
+}
+
+pub struct ClearHotkeyCommand {
+    pub slot: Option<String>,
+}
+
+pub struct ClearHotkeyKeyCommand {
+    pub slot: Option<String>,
+}
+
 #[async_trait]
 impl Executable for PingCommand {
    async fn execute(&self) -> Response {
@@ -481,3 +518,208 @@ impl Executable for GetFullStateCommand {
        }
    }
 }
+
+#[async_trait]
+impl Executable for GetHotkeysCommand {
+    async fn execute(&self) -> Response {
+        match HotkeyConfig::load() {
+            Ok(config) => match serde_json::to_string(&config) {
+                Ok(json) => Response::new(true, json),
+                Err(err) => Response::new(false, format!("Failed to serialize hotkeys: {}", err)),
+            },
+            Err(err) => Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for SetHotkeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+        let Some(file_path) = &self.file_path else {
+            return Response::new(false, "Missing file path");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        config.set_slot(
+            slot.clone(),
+            Request::play(&file_path.to_string_lossy(), false),
+        );
+
+        match config.save() {
+            Ok(_) => Response::new(true, format!("Hotkey slot '{}' set", slot)),
+            Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for SetHotkeyActionCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+        let Some(action) = &self.action else {
+            return Response::new(false, "Missing or invalid action");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        config.set_slot(slot.clone(), action.clone());
+
+        match config.save() {
+            Ok(_) => Response::new(true, format!("Hotkey slot '{}' set", slot)),
+            Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for SetHotkeyKeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+        let Some(key_chord) = &self.key_chord else {
+            return Response::new(false, "Missing key chord");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        if !config.set_key_chord(slot, Some(key_chord.clone())) {
+            return Response::new(false, format!("Slot '{}' not found", slot));
+        }
+
+        match config.save() {
+            Ok(_) => Response::new(
+                true,
+                format!("Key chord for slot '{}' set to '{}'", slot, key_chord),
+            ),
+            Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for SetHotkeyActionAndKeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+        let Some(action) = &self.action else {
+            return Response::new(false, "Missing or invalid action");
+        };
+        let Some(key_chord) = &self.key_chord else {
+            return Response::new(false, "Missing key chord");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        // Set the action and then the key chord
+        config.set_slot(slot.clone(), action.clone());
+        if !config.set_key_chord(slot, Some(key_chord.clone())) {
+            return Response::new(
+                false,
+                format!("Slot '{}' not found after setting action", slot),
+            );
+        }
+
+        match config.save() {
+            Ok(_) => Response::new(
+                true,
+                format!(
+                    "Hotkey slot '{}' set with action and key chord '{}'",
+                    slot, key_chord
+                ),
+            ),
+            Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for PlayHotkeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+
+        let config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        let Some(hotkey_slot) = config.find_slot(slot) else {
+            return Response::new(false, format!("Slot '{}' not found", slot));
+        };
+
+        let action = hotkey_slot.action.clone();
+
+        if let Some(cmd) = parse_command(&action) {
+            cmd.execute().await
+        } else {
+            Response::new(false, "Unknown command in hotkey slot")
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for ClearHotkeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        if config.remove_slot(slot) {
+            match config.save() {
+                Ok(_) => Response::new(true, format!("Hotkey slot '{}' cleared", slot)),
+                Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+            }
+        } else {
+            Response::new(false, format!("Slot '{}' not found", slot))
+        }
+    }
+}
+
+#[async_trait]
+impl Executable for ClearHotkeyKeyCommand {
+    async fn execute(&self) -> Response {
+        let Some(slot) = &self.slot else {
+            return Response::new(false, "Missing slot name");
+        };
+
+        let mut config = match HotkeyConfig::load() {
+            Ok(c) => c,
+            Err(err) => return Response::new(false, format!("Failed to load hotkeys: {}", err)),
+        };
+
+        if !config.set_key_chord(slot, None) {
+            return Response::new(false, format!("Slot '{}' not found", slot));
+        }
+
+        match config.save() {
+            Ok(_) => Response::new(true, format!("Key chord for slot '{}' cleared", slot)),
+            Err(err) => Response::new(false, format!("Failed to save hotkeys: {}", err)),
+        }
+    }
+}
@@ -1,6 +1,6 @@
-use crate::utils::config::get_config_path;
+use crate::{types::socket::Request, utils::config::get_config_path};
 use serde::{Deserialize, Serialize};
-use std::{error::Error, fs, path::PathBuf};
+use std::{collections::HashMap, error::Error, fs, path::PathBuf};

 #[derive(Default, Clone, Serialize, Deserialize)]
 #[serde(default)]
@@ -13,11 +13,11 @@ impl DaemonConfig {
    pub fn save_to_file(&self) -> Result<(), Box<dyn Error>> {
        let config_path = get_config_path()?.join("daemon.json");

-        if let Some(config_dir) = config_path.parent() {
-            if !config_path.exists() {
+        if let Some(config_dir) = config_path.parent()
+            && !config_path.exists()
+        {
            fs::create_dir_all(config_dir)?;
        }
-        }

        let config_json = serde_json::to_string_pretty(self)?;
        fs::write(config_path, config_json.as_bytes())?;
@@ -68,11 +68,11 @@ impl GuiConfig {
    pub fn save_to_file(&mut self) -> Result<(), Box<dyn Error>> {
        let config_path = get_config_path()?.join("gui.json");

-        if let Some(config_dir) = config_path.parent() {
-            if !config_path.exists() {
+        if let Some(config_dir) = config_path.parent()
+            && !config_path.exists()
+        {
            fs::create_dir_all(config_dir)?;
        }
-        }

        // Do not save scale factor if user does not want to
        if !self.save_scale_factor {
@@ -93,3 +93,113 @@ impl GuiConfig {
        }
    }
 }
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct HotkeySlot {
+    pub slot: String,
+    pub action: Request,
+    pub key_chord: Option<String>,
+}
+
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct HotkeyConfig {
+    #[serde(default)]
+    pub slots: Vec<HotkeySlot>,
+}
+
+impl HotkeyConfig {
+    pub fn config_path() -> Result<PathBuf, Box<dyn Error>> {
+        Ok(get_config_path()?.join("hotkeys.json"))
+    }
+
+    pub fn load() -> Result<HotkeyConfig, Box<dyn Error>> {
+        let path = Self::config_path()?;
+        if !path.exists() {
+            return Ok(HotkeyConfig::default());
+        }
+        let bytes = fs::read(&path)?;
+        match serde_json::from_slice::<HotkeyConfig>(&bytes) {
+            Ok(config) => Ok(config),
+            Err(e) => Err(e.into()),
+        }
+    }
+
+    pub fn save(&self) -> Result<(), Box<dyn Error>> {
+        let path = Self::config_path()?;
+        if let Some(dir) = path.parent()
+            && !dir.exists()
+        {
+            fs::create_dir_all(dir)?;
+        }
+        let json = serde_json::to_string_pretty(self)?;
+        fs::write(path, json.as_bytes())?;
+        Ok(())
+    }
+
+    pub fn find_slot(&self, slot: &str) -> Option<&HotkeySlot> {
+        self.slots.iter().find(|s| s.slot == slot)
+    }
+
+    pub fn find_slot_mut(&mut self, slot: &str) -> Option<&mut HotkeySlot> {
+        self.slots.iter_mut().find(|s| s.slot == slot)
+    }
+
+    pub fn set_slot(&mut self, slot: String, action: Request) {
+        if let Some(existing) = self.find_slot_mut(&slot) {
+            existing.action = action;
+        } else {
+            self.slots.push(HotkeySlot {
+                slot,
+                action,
+                key_chord: None,
+            });
+        }
+    }
+
+    pub fn set_key_chord(&mut self, slot: &str, key_chord: Option<String>) -> bool {
+        if let Some(existing) = self.find_slot_mut(slot) {
+            existing.key_chord = key_chord;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn remove_slot(&mut self, slot: &str) -> bool {
+        let len = self.slots.len();
+        self.slots.retain(|s| s.slot != slot);
+        self.slots.len() != len
+    }
+
+    /// Returns pairs of slot names that share the same key chord.
+    pub fn find_conflicts(&self) -> Vec<(&str, &str)> {
+        let mut conflicts = vec![];
+        let mut chord_map: HashMap<&str, Vec<&str>> = HashMap::new();
+
+        for s in &self.slots {
+            if let Some(chord) = &s.key_chord {
+                chord_map.entry(chord.as_str()).or_default().push(&s.slot);
+            }
+        }
+
+        for slots in chord_map.values() {
+            if slots.len() > 1 {
+                for i in 0..slots.len() {
+                    for j in (i + 1)..slots.len() {
+                        conflicts.push((slots[i], slots[j]));
+                    }
+                }
+            }
+        }
+
+        conflicts
+    }
+
+    /// Find which slot(s) have the given key chord.
+    pub fn slots_for_chord(&self, chord: &str) -> Vec<&HotkeySlot> {
+        self.slots
+            .iter()
+            .filter(|s| s.key_chord.as_deref() == Some(chord))
+            .collect()
+    }
+}
@@ -1,4 +1,7 @@
-use crate::types::audio_player::{PlayerState, TrackInfo};
+use crate::types::{
+    audio_player::{PlayerState, TrackInfo},
+    config::HotkeyConfig,
+};

 use egui::Id;

@@ -42,6 +45,13 @@ pub struct AppState {

    pub selected_file: Option<PathBuf>,
    pub files: HashSet<PathBuf>,
+
+    pub show_hotkeys: bool,
+    pub hotkey_config: HotkeyConfig,
+    pub hotkey_search_query: String,
+    pub assigning_hotkey_slot: Option<String>,
+    pub assigning_hotkey_for_file: Option<PathBuf>,
+    pub hotkey_capture_active: bool,
 }

 #[derive(Default, Debug, Clone)]
@@ -58,4 +68,6 @@ pub struct AudioPlayerState {
    pub all_inputs_sorted: Vec<(String, String)>,

    pub is_daemon_running: bool,
+
+    pub hotkey_config: Option<HotkeyConfig>,
 }
@@ -1,7 +1,9 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;

-#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+pub const MAX_MESSAGE_SIZE: usize = 128 * 1024;
+
+#[derive(Default, Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Request {
    pub name: String,
    pub args: HashMap<String, String>,
@@ -173,6 +175,53 @@ impl Request {
    pub fn get_full_state() -> Self {
        Request::new("get_full_state", vec![])
    }
+
+    pub fn get_hotkeys() -> Self {
+        Request::new("get_hotkeys", vec![])
+    }
+
+    pub fn set_hotkey(slot: &str, file_path: &str) -> Self {
+        Request::new("set_hotkey", vec![("slot", slot), ("file_path", file_path)])
+    }
+
+    pub fn set_hotkey_key(slot: &str, key_chord: &str) -> Self {
+        Request::new(
+            "set_hotkey_key",
+            vec![("slot", slot), ("key_chord", key_chord)],
+        )
+    }
+
+    pub fn clear_hotkey(slot: &str) -> Self {
+        Request::new("clear_hotkey", vec![("slot", slot)])
+    }
+
+    pub fn play_hotkey(slot: &str) -> Self {
+        Request::new("play_hotkey", vec![("slot", slot)])
+    }
+
+    pub fn set_hotkey_action(slot: &str, action: &Request) -> Self {
+        let action_json = serde_json::to_string(action).unwrap_or_default();
+        Request::new(
+            "set_hotkey_action",
+            vec![("slot", slot), ("action", &action_json)],
+        )
+    }
+
+    pub fn clear_hotkey_key(slot: &str) -> Self {
+        Request::new("clear_hotkey_key", vec![("slot", slot)])
+    }
+
+    pub fn set_hotkey_action_and_key(slot: &str, action: &Request, key_chord: &str) -> Self {
+        let action_json = serde_json::to_string(action).unwrap_or_default();
+        Request::new(
+            "set_hotkey_action_and_key",
+            vec![
+                ("slot", slot),
+                ("action", &action_json),
+                ("key_chord", key_chord),
+            ],
+        )
+    }
 }

 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
@@ -72,6 +72,138 @@ pub fn parse_command(request: &Request) -> Option<Box<dyn Executable + Send>> {
        "toggle_loop" => Some(Box::new(ToggleLoopCommand { id })),
        "get_daemon_version" => Some(Box::new(GetDaemonVersionCommand {})),
        "get_full_state" => Some(Box::new(GetFullStateCommand {})),
+        "get_hotkeys" => Some(Box::new(GetHotkeysCommand {})),
+        "set_hotkey" => {
+            let slot = request.args.get("slot").cloned();
+            let file_path = request
+                .args
+                .get("file_path")
+                .and_then(|s| s.parse::<PathBuf>().ok());
+            Some(Box::new(SetHotkeyCommand { slot, file_path }))
+        }
+        "set_hotkey_key" => {
+            let slot = request.args.get("slot").cloned();
+            let key_chord = request.args.get("key_chord").cloned();
+            Some(Box::new(SetHotkeyKeyCommand { slot, key_chord }))
+        }
+        "clear_hotkey" => {
+            let slot = request.args.get("slot").cloned();
+            Some(Box::new(ClearHotkeyCommand { slot }))
+        }
+        "play_hotkey" => {
+            let slot = request.args.get("slot").cloned();
+            Some(Box::new(PlayHotkeyCommand { slot }))
+        }
+        "set_hotkey_action" => {
+            let slot = request.args.get("slot").cloned();
+            let action = request
+                .args
+                .get("action")
+                .and_then(|s| serde_json::from_str::<Request>(s).ok());
+            Some(Box::new(SetHotkeyActionCommand { slot, action }))
+        }
+        "clear_hotkey_key" => {
+            let slot = request.args.get("slot").cloned();
+            Some(Box::new(ClearHotkeyKeyCommand { slot }))
+        }
+        "set_hotkey_action_and_key" => {
+            let slot = request.args.get("slot").cloned();
+            let action = request
+                .args
+                .get("action")
+                .and_then(|s| serde_json::from_str::<Request>(s).ok());
+            let key_chord = request.args.get("key_chord").cloned();
+            Some(Box::new(SetHotkeyActionAndKeyCommand {
+                slot,
+                action,
+                key_chord,
+            }))
+        }
        _ => None,
    }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::socket::Request;
+    use std::collections::HashMap;
+
+    #[test]
+    fn test_parse_set_volume_valid() {
+        let mut args = HashMap::new();
+        args.insert("volume".to_string(), "0.5".to_string());
+        args.insert("id".to_string(), "1".to_string());
+        let request = Request {
+            name: "set_volume".to_string(),
+            args,
+        };
+
+        let cmd = parse_command(&request);
+        assert!(cmd.is_some());
+    }
+
+    #[test]
+    fn test_parse_set_volume_missing_volume() {
+        let mut args = HashMap::new();
+        args.insert("id".to_string(), "1".to_string());
+        let request = Request {
+            name: "set_volume".to_string(),
+            args,
+        };
+
+        let cmd = parse_command(&request);
+        assert!(cmd.is_some());
+    }
+
+    #[test]
+    fn test_parse_set_volume_invalid_volume() {
+        let mut args = HashMap::new();
+        args.insert("volume".to_string(), "not-a-float".to_string());
+        let request = Request {
+            name: "set_volume".to_string(),
+            args,
+        };
+
+        let cmd = parse_command(&request);
+        assert!(cmd.is_some());
+    }
+
+    #[test]
+    fn test_parse_set_volume_missing_id() {
+        let mut args = HashMap::new();
+        args.insert("volume".to_string(), "0.5".to_string());
+        let request = Request {
+            name: "set_volume".to_string(),
+            args,
+        };
+
+        let cmd = parse_command(&request);
+        assert!(cmd.is_some());
+    }
+
+    #[test]
+    fn test_parse_set_volume_invalid_id() {
+        let mut args = HashMap::new();
+        args.insert("id".to_string(), "not-an-int".to_string());
+        args.insert("volume".to_string(), "0.5".to_string());
+        let request = Request {
+            name: "set_volume".to_string(),
+            args,
+        };
+
+        let cmd = parse_command(&request);
+        assert!(cmd.is_some());
+    }
+
+    #[test]
+    fn test_parse_set_volume_empty_args() {
+        let request = Request {
+            name: "set_volume".to_string(),
+            args: HashMap::new(),
+        };
+
+        let cmd = parse_command(&request);
+        assert!(cmd.is_some());
+    }
+}
@@ -1,11 +1,9 @@
-use crate::{
-    types::{
+use crate::types::{
    audio_player::AudioPlayer,
    config::DaemonConfig,
-        socket::{Request, Response},
-    },
-    utils::pipewire::{create_link, get_device},
+    socket::{MAX_MESSAGE_SIZE, Request, Response},
 };
+
 use std::os::unix::fs::PermissionsExt;
 use std::path::PathBuf;
 use std::{error::Error, fs};
@@ -38,44 +36,6 @@ pub fn get_daemon_config() -> DaemonConfig {
    })
 }

-pub async fn link_player_to_virtual_mic() -> Result<(), Box<dyn Error>> {
-    let pwsp_daemon_output;
-    if let Ok(device) = get_device("pwsp-daemon").await {
-        pwsp_daemon_output = device;
-    } else {
-        return Err(
-            "Could not find alsa_playback.pwsp-daemon device, skipping device linking".into(),
-        );
-    }
-
-    let pwsp_daemon_input;
-    if let Ok(device) = get_device("pwsp-virtual-mic").await {
-        pwsp_daemon_input = device;
-    } else {
-        return Err("Could not find pwsp-virtual-mic device, skipping device linking".into());
-    }
-
-    let output_fl = pwsp_daemon_output
-        .clone()
-        .output_fl
-        .expect("Failed to get pwsp-daemon output_fl");
-    let output_fr = pwsp_daemon_output
-        .clone()
-        .output_fr
-        .expect("Failed to get pwsp-daemon output_fl");
-    let input_fl = pwsp_daemon_input
-        .clone()
-        .input_fl
-        .expect("Failed to get pwsp-daemon input_fl");
-    let input_fr = pwsp_daemon_input
-        .clone()
-        .input_fr
-        .expect("Failed to get pwsp-daemon input_fr");
-    create_link(output_fl, output_fr, input_fl, input_fr)?;
-
-    Ok(())
-}
-
 pub fn get_runtime_dir() -> PathBuf {
    dirs::runtime_dir().unwrap_or(PathBuf::from("/run/pwsp"))
 }
@@ -135,6 +95,14 @@ pub async fn make_request(request: Request) -> Result<Response, Box<dyn Error +
    }
    let response_len = u32::from_le_bytes(len_bytes) as usize;

+    if response_len > MAX_MESSAGE_SIZE {
+        eprintln!(
+            "Failed to read response from daemon: response too large ({} bytes)!",
+            response_len
+        );
+        return Err("Response too large".into());
+    }
+
    let mut buffer = vec![0u8; response_len];
    if stream.read_exact(&mut buffer).await.is_err() {
        return Err("Failed to read response".into());
@@ -0,0 +1,201 @@
+use crate::{types::config::HotkeyConfig, utils::commands::parse_command};
+use evdev::{Device, EventStream, EventSummary, KeyCode};
+
+struct ModifierState {
+    ctrl: bool,
+    alt: bool,
+    shift: bool,
+    meta: bool,
+}
+
+impl ModifierState {
+    fn new() -> Self {
+        Self {
+            ctrl: false,
+            alt: false,
+            shift: false,
+            meta: false,
+        }
+    }
+
+    fn update(&mut self, key: KeyCode, pressed: bool) {
+        match key {
+            KeyCode::KEY_LEFTCTRL | KeyCode::KEY_RIGHTCTRL => self.ctrl = pressed,
+            KeyCode::KEY_LEFTALT | KeyCode::KEY_RIGHTALT => self.alt = pressed,
+            KeyCode::KEY_LEFTSHIFT | KeyCode::KEY_RIGHTSHIFT => self.shift = pressed,
+            KeyCode::KEY_LEFTMETA | KeyCode::KEY_RIGHTMETA => self.meta = pressed,
+            _ => {}
+        }
+    }
+
+    fn any_active(&self) -> bool {
+        self.ctrl || self.alt || self.shift || self.meta
+    }
+
+    fn is_modifier(key: KeyCode) -> bool {
+        matches!(
+            key,
+            KeyCode::KEY_LEFTCTRL
+                | KeyCode::KEY_RIGHTCTRL
+                | KeyCode::KEY_LEFTALT
+                | KeyCode::KEY_RIGHTALT
+                | KeyCode::KEY_LEFTSHIFT
+                | KeyCode::KEY_RIGHTSHIFT
+                | KeyCode::KEY_LEFTMETA
+                | KeyCode::KEY_RIGHTMETA
+        )
+    }
+}
+
+fn evdev_key_name(key: KeyCode) -> Option<&'static str> {
+    match key {
+        KeyCode::KEY_A => Some("A"),
+        KeyCode::KEY_B => Some("B"),
+        KeyCode::KEY_C => Some("C"),
+        KeyCode::KEY_D => Some("D"),
+        KeyCode::KEY_E => Some("E"),
+        KeyCode::KEY_F => Some("F"),
+        KeyCode::KEY_G => Some("G"),
+        KeyCode::KEY_H => Some("H"),
+        KeyCode::KEY_I => Some("I"),
+        KeyCode::KEY_J => Some("J"),
+        KeyCode::KEY_K => Some("K"),
+        KeyCode::KEY_L => Some("L"),
+        KeyCode::KEY_M => Some("M"),
+        KeyCode::KEY_N => Some("N"),
+        KeyCode::KEY_O => Some("O"),
+        KeyCode::KEY_P => Some("P"),
+        KeyCode::KEY_Q => Some("Q"),
+        KeyCode::KEY_R => Some("R"),
+        KeyCode::KEY_S => Some("S"),
+        KeyCode::KEY_T => Some("T"),
+        KeyCode::KEY_U => Some("U"),
+        KeyCode::KEY_V => Some("V"),
+        KeyCode::KEY_W => Some("W"),
+        KeyCode::KEY_X => Some("X"),
+        KeyCode::KEY_Y => Some("Y"),
+        KeyCode::KEY_Z => Some("Z"),
+        KeyCode::KEY_1 => Some("1"),
+        KeyCode::KEY_2 => Some("2"),
+        KeyCode::KEY_3 => Some("3"),
+        KeyCode::KEY_4 => Some("4"),
+        KeyCode::KEY_5 => Some("5"),
+        KeyCode::KEY_6 => Some("6"),
+        KeyCode::KEY_7 => Some("7"),
+        KeyCode::KEY_8 => Some("8"),
+        KeyCode::KEY_9 => Some("9"),
+        KeyCode::KEY_0 => Some("0"),
+        KeyCode::KEY_F1 => Some("F1"),
+        KeyCode::KEY_F2 => Some("F2"),
+        KeyCode::KEY_F3 => Some("F3"),
+        KeyCode::KEY_F4 => Some("F4"),
+        KeyCode::KEY_F5 => Some("F5"),
+        KeyCode::KEY_F6 => Some("F6"),
+        KeyCode::KEY_F7 => Some("F7"),
+        KeyCode::KEY_F8 => Some("F8"),
+        KeyCode::KEY_F9 => Some("F9"),
+        KeyCode::KEY_F10 => Some("F10"),
+        KeyCode::KEY_F11 => Some("F11"),
+        KeyCode::KEY_F12 => Some("F12"),
+        _ => None,
+    }
+}
+
+fn build_chord(modifiers: &ModifierState, key_name: &str) -> String {
+    let mut parts = Vec::with_capacity(5);
+    if modifiers.ctrl {
+        parts.push("Ctrl");
+    }
+    if modifiers.alt {
+        parts.push("Alt");
+    }
+    if modifiers.shift {
+        parts.push("Shift");
+    }
+    if modifiers.meta {
+        parts.push("Super");
+    }
+    parts.push(key_name);
+    parts.join("+")
+}
+
+fn is_keyboard(device: &Device) -> bool {
+    device
+        .supported_keys()
+        .is_some_and(|keys| keys.contains(KeyCode::KEY_A) && keys.contains(KeyCode::KEY_Z))
+}
+
+async fn handle_device_events(mut stream: EventStream) {
+    let mut modifiers = ModifierState::new();
+
+    loop {
+        match stream.next_event().await {
+            Ok(event) => {
+                if let EventSummary::Key(_, key, value) = event.destructure() {
+                    // 0 = released, 1 = pressed, 2 = repeat
+                    if value == 0 || value == 1 {
+                        modifiers.update(key, value == 1);
+                    }
+
+                    // Only trigger on press, skip modifiers and bare keys
+                    if value != 1 || ModifierState::is_modifier(key) || !modifiers.any_active() {
+                        continue;
+                    }
+
+                    let Some(key_name) = evdev_key_name(key) else {
+                        continue;
+                    };
+
+                    let chord = build_chord(&modifiers, key_name);
+
+                    let config = match HotkeyConfig::load() {
+                        Ok(c) => c,
+                        Err(_) => continue,
+                    };
+
+                    let slots = config.slots_for_chord(&chord);
+                    for slot in slots {
+                        if let Some(cmd) = parse_command(&slot.action) {
+                            cmd.execute().await;
+                        }
+                    }
+                }
+            }
+            Err(e) => {
+                eprintln!("Global hotkeys: device read error: {e}");
+                break;
+            }
+        }
+    }
+}
+
+pub async fn start_global_hotkey_listener() {
+    let keyboards: Vec<_> = evdev::enumerate()
+        .filter(|(_, dev)| is_keyboard(dev))
+        .collect();
+
+    if keyboards.is_empty() {
+        eprintln!(
+            "Global hotkeys: no keyboard devices found. \
+             Make sure your user is in the 'input' group."
+        );
+        return;
+    }
+
+    println!(
+        "Global hotkeys: found {} keyboard device(s)",
+        keyboards.len()
+    );
+
+    for (path, device) in keyboards {
+        match device.into_event_stream() {
+            Ok(stream) => {
+                println!("Global hotkeys: listening on {}", path.display());
+                tokio::spawn(handle_device_events(stream));
+            }
+            Err(e) => {
+                eprintln!("Global hotkeys: failed to open {}: {}", path.display(), e);
+            }
+        }
+    }
+}
@@ -1,7 +1,7 @@
 use crate::{
    types::{
        audio_player::FullState,
-        config::GuiConfig,
+        config::{GuiConfig, HotkeyConfig},
        gui::AudioPlayerState,
        socket::{Request, Response},
    },
@@ -10,6 +10,7 @@ use crate::{
 use std::{
    error::Error,
    sync::{Arc, Mutex},
+    time::Instant,
 };
 use tokio::time::{Duration, sleep};

@@ -49,6 +50,7 @@ pub fn format_time_pair(position: f32, duration: f32) -> String {
 pub fn start_app_state_thread(audio_player_state_shared: Arc<Mutex<AudioPlayerState>>) {
    tokio::spawn(async move {
        let sleep_duration = Duration::from_secs_f32(1.0 / 60.0);
+        let mut last_hotkey_poll = Instant::now();

        loop {
            let is_running = is_daemon_running().unwrap_or(false);
@@ -105,6 +107,22 @@ pub fn start_app_state_thread(audio_player_state_shared: Arc<Mutex<AudioPlayerSt
                guard.is_daemon_running = true;
            }

+            // Poll hotkey config at a lower frequency (~every 2 seconds)
+            if last_hotkey_poll.elapsed() >= Duration::from_secs(2) {
+                let hotkey_res = make_request(Request::get_hotkeys())
+                    .await
+                    .unwrap_or_default();
+                if hotkey_res.status
+                    && let Ok(config) = serde_json::from_str::<HotkeyConfig>(&hotkey_res.message)
+                {
+                    let mut guard = audio_player_state_shared
+                        .lock()
+                        .unwrap_or_else(|e| e.into_inner());
+                    guard.hotkey_config = Some(config);
+                }
+                last_hotkey_poll = Instant::now();
+            }
+
            sleep(sleep_duration).await;
        }
    });
@@ -1,5 +1,6 @@
 pub mod commands;
 pub mod config;
 pub mod daemon;
+pub mod global_hotkeys;
 pub mod gui;
 pub mod pipewire;
@@ -9,6 +9,13 @@ use tokio::{
    time::{Duration, timeout},
 };

+pub fn setup_pipewire_context() -> Result<(MainLoopRc, ContextRc), String> {
+    pipewire::init();
+    let main_loop = MainLoopRc::new(None).map_err(|e| e.to_string())?;
+    let context = ContextRc::new(&main_loop, None).map_err(|e| e.to_string())?;
+    Ok((main_loop, context))
+}
+
 fn parse_global_object(
    global_object: &GlobalObject<&DictRef>,
 ) -> (Option<AudioDevice>, Option<Port>) {
@@ -56,12 +63,13 @@ fn parse_global_object(
                (None, None)
            };
            // Check if the object is a port
-        } else if props.get("port.direction").is_some() {
-            if let (Some(node_id), Some(port_id), Some(port_name)) = (
+        } else if props.get("port.direction").is_some()
+            && let (Some(node_id), Some(port_id), Some(port_name)) = (
                props.get("node.id").and_then(|id| id.parse::<u32>().ok()),
                props.get("port.id").and_then(|id| id.parse::<u32>().ok()),
                props.get("port.name"),
-            ) {
+            )
+        {
            let port = Port {
                node_id,
                port_id,
@@ -71,17 +79,21 @@ fn parse_global_object(
            return (None, Some(port));
        }
    }
-    }
    (None, None)
 }

 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>>,
 ) {
-    pipewire::init();
-
-    let main_loop = MainLoopRc::new(None).expect("Failed to initialize pipewire main loop");
+    let (main_loop, context) = match setup_pipewire_context() {
+        Ok(res) => res,
+        Err(e) => {
+            let _ = init_sender.send(Err(e));
+            return;
+        }
+    };

    // Stop main loop on Terminate message
    let _receiver = pw_receiver.attach(main_loop.loop_(), {
@@ -89,13 +101,24 @@ async fn pw_get_global_objects_thread(
        move |_| _main_loop.quit()
    });

-    let context = ContextRc::new(&main_loop, None).expect("Failed to create pipewire context");
-    let core = context
-        .connect(None)
-        .expect("Failed to connect to pipewire context");
-    let registry = core
-        .get_registry()
-        .expect("Failed to get registry from pipewire context");
+    let core = match context.connect(None) {
+        Ok(core) => core,
+        Err(e) => {
+            let _ = init_sender.send(Err(format!("Failed to connect to pipewire context: {}", e)));
+            return;
+        }
+    };
+
+    let registry = match core.get_registry() {
+        Ok(registry) => registry,
+        Err(e) => {
+            let _ = init_sender.send(Err(format!(
+                "Failed to get registry from pipewire context: {}",
+                e
+            )));
+            return;
+        }
+    };

    let _listener = registry
        .add_listener_local()
@@ -111,6 +134,11 @@ async fn pw_get_global_objects_thread(
        })
        .register();

+    // Signal successful initialization
+    if init_sender.send(Ok(())).is_err() {
+        return;
+    }
+
    main_loop.run();
 }

@@ -118,10 +146,17 @@ pub async fn get_all_devices() -> Result<(Vec<AudioDevice>, Vec<AudioDevice>), B
    // 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);

    // Spawn pipewire thread in background
-    let _pw_thread =
-        tokio::spawn(async move { pw_get_global_objects_thread(main_sender, pw_receiver).await });
+    let _pw_thread = tokio::spawn(async move {
+        pw_get_global_objects_thread(main_sender, pw_receiver, init_sender).await
+    });
+
+    // Wait for initialization to complete
+    if let Err(e) = init_receiver.recv()? {
+        return Err(e.into());
+    }

    let mut input_devices: HashMap<u32, AudioDevice> = HashMap::new();
    let mut output_devices: HashMap<u32, AudioDevice> = HashMap::new();
@@ -146,9 +181,7 @@ pub async fn get_all_devices() -> Result<(Vec<AudioDevice>, Vec<AudioDevice>), B
            }
            Ok(None) | Err(_) => {
                // Pipewire thread is finished and we can collect our devices
-                pw_sender
-                    .send(Terminate {})
-                    .expect("Failed to terminate pipewire thread");
+                let _ = pw_sender.send(Terminate {});

                for port in ports {
                    let node_id = port.node_id;
@@ -196,8 +229,8 @@ pub async fn get_all_devices() -> Result<(Vec<AudioDevice>, Vec<AudioDevice>), B
                let mut output_devices: Vec<AudioDevice> =
                    output_devices.values().cloned().collect();

-                input_devices.sort_by(|a, b| a.id.cmp(&b.id));
-                output_devices.sort_by(|a, b| a.id.cmp(&b.id));
+                input_devices.sort_by_key(|a| a.id);
+                output_devices.sort_by_key(|a| a.id);

                return Ok((input_devices, output_devices));
            }
@@ -222,15 +255,24 @@ pub async fn get_device(device_name: &str) -> Result<AudioDevice, Box<dyn Error>

 pub fn create_virtual_mic() -> Result<pipewire::channel::Sender<Terminate>, Box<dyn Error>> {
    let (pw_sender, pw_receiver) = pipewire::channel::channel::<Terminate>();
+    let (init_sender, init_receiver) = std::sync::mpsc::sync_channel(0);

    let _pw_thread = thread::spawn(move || {
-        pipewire::init();
-
-        let main_loop = MainLoopRc::new(None).expect("Failed to initialize pipewire main loop");
-        let context = ContextRc::new(&main_loop, None).expect("Failed to create pipewire context");
-        let core = context
-            .connect(None)
-            .expect("Failed to connect to pipewire context");
+        let (main_loop, context) = match setup_pipewire_context() {
+            Ok(res) => res,
+            Err(e) => {
+                let _ = init_sender.send(Err(e));
+                return;
+            }
+        };
+        let core = match context.connect(None) {
+            Ok(core) => core,
+            Err(e) => {
+                let _ =
+                    init_sender.send(Err(format!("Failed to connect to pipewire context: {}", e)));
+                return;
+            }
+        };

        let props = properties!(
            "factory.name" => "support.null-audio-sink",
@@ -242,9 +284,13 @@ pub fn create_virtual_mic() -> Result<pipewire::channel::Sender<Terminate>, Box<
            "object.linger" => "false", // Destroy the node on app exit
        );

-        let _node = core
-            .create_object::<pipewire::node::Node>("adapter", &props)
-            .expect("Failed to create virtual mic");
+        let _node = match core.create_object::<pipewire::node::Node>("adapter", &props) {
+            Ok(node) => node,
+            Err(e) => {
+                let _ = init_sender.send(Err(format!("Failed to create virtual mic: {}", e)));
+                return;
+            }
+        };

        let _receiver = pw_receiver.attach(main_loop.loop_(), {
            let _main_loop = main_loop.clone();
@@ -252,12 +298,57 @@ pub fn create_virtual_mic() -> Result<pipewire::channel::Sender<Terminate>, Box<
        });

        println!("Virtual mic created");
+        if init_sender.send(Ok(())).is_err() {
+            return;
+        }
        main_loop.run();
    });

+    if let Err(e) = init_receiver.recv()? {
+        return Err(e.into());
+    }
+
    Ok(pw_sender)
 }

+pub async fn link_player_to_virtual_mic()
+-> Result<pipewire::channel::Sender<Terminate>, Box<dyn Error>> {
+    let pwsp_daemon_output = match get_device("pwsp-daemon").await {
+        Ok(device) => device,
+        Err(_) => {
+            return Err(
+                "Could not find alsa_playback.pwsp-daemon device, skipping device linking".into(),
+            );
+        }
+    };
+
+    let pwsp_daemon_input = match get_device("pwsp-virtual-mic").await {
+        Ok(device) => device,
+        Err(_) => {
+            return Err("Could not find pwsp-virtual-mic device, skipping device linking".into());
+        }
+    };
+
+    let output_fl = match pwsp_daemon_output.output_fl {
+        Some(port) => port,
+        None => return Err("Failed to get pwsp-daemon output_fl".into()),
+    };
+    let output_fr = match pwsp_daemon_output.output_fr {
+        Some(port) => port,
+        None => return Err("Failed to get pwsp-daemon output_fr".into()),
+    };
+    let input_fl = match pwsp_daemon_input.input_fl {
+        Some(port) => port,
+        None => return Err("Failed to get pwsp-virtual-mic input_fl".into()),
+    };
+    let input_fr = match pwsp_daemon_input.input_fr {
+        Some(port) => port,
+        None => return Err("Failed to get pwsp-virtual-mic input_fr".into()),
+    };
+
+    create_link(output_fl, output_fr, input_fl, input_fr)
+}
+
 pub fn create_link(
    output_fl: Port,
    output_fr: Port,
@@ -265,15 +356,24 @@ pub fn create_link(
    input_fr: Port,
 ) -> Result<pipewire::channel::Sender<Terminate>, Box<dyn Error>> {
    let (pw_sender, pw_receiver) = pipewire::channel::channel::<Terminate>();
+    let (init_sender, init_receiver) = std::sync::mpsc::sync_channel(0);

    let _pw_thread = thread::spawn(move || {
-        pipewire::init();
-
-        let main_loop = MainLoopRc::new(None).expect("Failed to initialize pipewire main loop");
-        let context = ContextRc::new(&main_loop, None).expect("Failed to create pipewire context");
-        let core = context
-            .connect(None)
-            .expect("Failed to connect to pipewire context");
+        let (main_loop, context) = match setup_pipewire_context() {
+            Ok(res) => res,
+            Err(e) => {
+                let _ = init_sender.send(Err(e));
+                return;
+            }
+        };
+        let core = match context.connect(None) {
+            Ok(core) => core,
+            Err(e) => {
+                let _ =
+                    init_sender.send(Err(format!("Failed to connect to pipewire context: {}", e)));
+                return;
+            }
+        };

        let props_fl = properties! {
            "link.output.node" => format!("{}", output_fl.node_id).as_str(),
@@ -288,12 +388,20 @@ pub fn create_link(
            "link.input.port"  => format!("{}", input_fr.port_id).as_str(),
        };

-        let _link_fl = core
-            .create_object::<Link>("link-factory", &props_fl)
-            .expect("Failed to create link FL");
-        let _link_fr = core
-            .create_object::<Link>("link-factory", &props_fr)
-            .expect("Failed to create link FR");
+        let _link_fl = match core.create_object::<Link>("link-factory", &props_fl) {
+            Ok(link) => link,
+            Err(e) => {
+                let _ = init_sender.send(Err(format!("Failed to create link FL: {}", e)));
+                return;
+            }
+        };
+        let _link_fr = match core.create_object::<Link>("link-factory", &props_fr) {
+            Ok(link) => link,
+            Err(e) => {
+                let _ = init_sender.send(Err(format!("Failed to create link FR: {}", e)));
+                return;
+            }
+        };

        let _receiver = pw_receiver.attach(main_loop.loop_(), {
            let _main_loop = main_loop.clone();
@@ -304,8 +412,15 @@ pub fn create_link(
            "Link created: FL: {}-{} FR: {}-{}",
            output_fl.node_id, input_fl.node_id, output_fr.node_id, input_fr.node_id
        );
+        if init_sender.send(Ok(())).is_err() {
+            return;
+        }
        main_loop.run();
    });

+    if let Err(e) = init_receiver.recv()? {
+        return Err(e.into());
+    }
+
    Ok(pw_sender)
 }
@@ -1,113 +0,0 @@
-use rodio::{DeviceSinkBuilder, MixerDeviceSink};
-use std::fs;
-use std::path::Path;
-use std::sync::Arc;
-use std::time::Instant;
-use tokio::sync::Mutex;
-
-// A mock of AudioPlayer to isolate the play method's blocking behavior.
-// We only implement the relevant part of the logic that needs optimizing.
-pub struct AudioPlayerMock {
-    pub tracks: std::collections::HashMap<u32, ()>,
-    pub next_id: u32,
-    pub volume: f32,
-}
-
-impl AudioPlayerMock {
-    pub fn new() -> Self {
-        AudioPlayerMock {
-            tracks: std::collections::HashMap::new(),
-            next_id: 1,
-            volume: 1.0,
-        }
-    }
-
-    pub async fn play(
-        &mut self,
-        file_path: &Path,
-        concurrent: bool,
-    ) -> Result<u32, Box<dyn std::error::Error + Send + Sync>> {
-        if !file_path.exists() {
-            return Err(format!("File does not exist: {}", file_path.display()).into());
-        }
-
-        let path_buf = file_path.to_path_buf();
-        let _file = tokio::task::spawn_blocking(move || {
-            // Simulate some blocking work like Decoder::try_from which reads file headers
-            let _f = fs::File::open(&path_buf).unwrap();
-
-            // Emulate the actual time spent reading file and decoding header (which is what Decoder::try_from does)
-            std::thread::sleep(std::time::Duration::from_millis(100)); // Simulate slow disk/decode
-            _f
-        })
-        .await?;
-
-        if !concurrent {
-            self.tracks.clear();
-        }
-
-        let id = self.next_id;
-        self.next_id += 1;
-        self.tracks.insert(id, ());
-
-        Ok(id)
-    }
-}
-
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn test_performance_blocking() {
-    println!("Setting up mock environment...");
-
-    // Create a dummy file to read
-    let test_file = Path::new("test_dummy.wav");
-    fs::write(test_file, "dummy content").unwrap();
-
-    let player = Arc::new(Mutex::new(AudioPlayerMock::new()));
-
-    println!("Starting benchmark for synchronous behavior in async fn...");
-
-    // We launch a background task that measures event loop latency.
-    // If the main tasks block the executor, this task will suffer high latency.
-    let latency_task = tokio::spawn(async {
-        let mut max_latency = std::time::Duration::from_secs(0);
-        for _ in 0..50 {
-            let start = Instant::now();
-            tokio::task::yield_now().await;
-            let elapsed = start.elapsed();
-            if elapsed > max_latency {
-                max_latency = elapsed;
-            }
-            tokio::time::sleep(std::time::Duration::from_millis(5)).await;
-        }
-        max_latency
-    });
-
-    // Launch multiple play operations
-    let mut tasks = vec![];
-    let start_time = Instant::now();
-    for _ in 0..10 {
-        let player_clone = Arc::clone(&player);
-        let file_path = test_file.to_path_buf();
-        tasks.push(tokio::spawn(async move {
-            let mut p = player_clone.lock().await;
-            let _ = p.play(&file_path, true).await;
-        }));
-    }
-
-    // Wait for all tasks to finish
-    for t in tasks {
-        let _ = t.await;
-    }
-    let total_time = start_time.elapsed();
-
-    let max_latency = latency_task.await.unwrap();
-
-    println!("Total execution time: {:?}", total_time);
-    println!(
-        "Max event loop latency (blocking indicator): {:?}",
-        max_latency
-    );
-
-    // Cleanup
-    fs::remove_file(test_file).unwrap();
-}
Author	SHA1	Message	Date
Tarasov Aleksandr	e6c8d720d5	update deps and change version to 1.7.6 (#92 ) * change version to 1.7.6 * cargo update cpal v0.18.0 #e5d618c6 -> #f938e338 fax v0.2.6 -> v0.2.7 fax_derive - idna_adapter v1.2.1 -> v1.2.2 js-sys v0.3.95 -> v0.3.97 wasm-bindgen v0.2.118 -> v0.2.120 wasm-bindgen-futures v0.4.68 -> v0.4.70 wasm-bindgen-macro v0.2.118 -> v0.2.120 wasm-bindgen-macro-support v0.2.118 -> v0.2.120 wasm-bindgen-shared v0.2.118 -> v0.2.120 web-sys v0.3.95 -> v0.3.97 winnow - zbus v5.14.0 -> v5.15.0 zbus_macros v5.14.0 -> v5.15.0 zbus_names v4.3.1 -> v4.3.2 zvariant v5.10.0 -> v5.10.1 zvariant_derive v5.10.0 -> v5.10.1 zvariant_utils v3.3.0 -> v3.3.1 * deps: update cargo-sources.json	2026-04-28 14:31:27 +03:00
RiDDiX	a6d93ff528	fix clippy lints under rust 1.95 (#90 )	2026-04-28 14:13:11 +03:00
RiDDiX	bcf791d84c	fix(packages): add cmake makedepend to aur source pkgbuild (#91 )	2026-04-28 14:10:17 +03:00
Tarasov Aleksandr	e4b0b10393	refactor(gui): refactor draw_hotkeys to improve code health (#86 ) - Break down the monolithic `draw_hotkeys` method into smaller, focused component functions: `draw_hotkeys_header`, `draw_hotkeys_search`, `draw_hotkeys_table`, and `handle_hotkey_action`. - Improve readability and maintainability of the `src/gui/draw.rs` file while preserving identical behavior. Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-27 23:07:13 +03:00
Tarasov Aleksandr	11de96db58	refactor: simplify `draw_track_control` by extracting helper functions (#87 ) Extracted distinct UI sections (playback controls, position slider, volume controls, stop button) into their own well-scoped helper functions within `SoundpadGui`. This significantly improves the maintainability and readability of `draw_track_control` while preserving the existing layout structure and state mutation behavior. Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-27 23:05:39 +03:00
Tarasov Aleksandr	7396c0aef8	perf(gui): Optimize UI rendering loop by iterating over tracks by reference (#88 ) * perf: optimize UI rendering loop by removing unnecessary Vec clone\n\n- Removed `clone()` on `self.audio_player_state.tracks` in `draw_header`\n- Iterated by reference instead of using an owned collection\n- Benchmarked and showed a significant performance improvement (7us -> 87ns) Co-authored-by: arabianq <55220741+arabianq@users.noreply.github.com> * build(flatpak): update cargo-sources.json to include criterion\n\nThe CI failed during the offline flatpak build because the newly added `criterion` dev-dependency was missing from `cargo-sources.json`. Regenerated `packages/flatpak/cargo-sources.json` to fix it. Co-authored-by: arabianq <55220741+arabianq@users.noreply.github.com> * Delete benches/ui_benchmark.rs * refactor: remove garbage --------- Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-27 23:03:37 +03:00
Tarasov Aleksandr	fc2cd5e2da	fix(daemon): Remove `.expect()` panics from PipeWire initialization (#89 ) This commit addresses a security and stability vulnerability where failures in PipeWire context setup, connection, or registry acquisition would crash the entire thread (or daemon) via `.expect()` panics. We now gracefully capture and propagate initialization errors up the call stack. A `sync_channel(0)` is used to signal the success or failure of the initial pipewire setup back to the calling functions (`get_all_devices`, `create_virtual_mic`, `create_link`). This prevents unexpected crashes and improves error resilience. Also removed unneeded `pw_sender` panics on channel termination by simply dropping/ignoring the result. Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-27 22:54:17 +03:00
Tarasov Aleksandr	1a37729cf1	fix: rpm builds Added cmake as a build requirement for the package.	2026-04-26 19:52:03 +03:00
Tarasov Aleksandr	86b38a250e	change version to 1.7.5 (#83 ) * deps: rodio v0.22.2 -> 57ad9d8a9f30398f634fbf8e4e1d53dde7243c21 with symphonia-libopus * change version to 1.7.5 * deps: update cargo-sources.json	2026-04-26 19:32:12 +03:00
Tarasov Aleksandr	54fa278cea	feat: opus support (#82 ) * deps: rodio v0.22.2 -> 57ad9d8a9f30398f634fbf8e4e1d53dde7243c21 with symphonia-libopus * deps: update cargo-sources.json * feat(gui): add .opus file extension support	2026-04-26 19:27:36 +03:00
Tarasov Aleksandr	db040aa820	fix(ci): update input descriptions in workflow for clarity (#81 )	2026-04-25 19:31:20 +03:00
Tarasov Aleksandr	04449e7525	fix(ci): update workflow inputs for tag and build branch selection (#80 )	2026-04-25 19:28:48 +03:00
Tarasov Aleksandr	9f50809a99	fix(ci): add SDK extensions installation step (#79 )	2026-04-25 16:57:01 +03:00
Tarasov Aleksandr	7dda4bc2b1	fix(ci): update Flatter container image to version 25.08 (#77 )	2026-04-25 16:46:56 +03:00
Tarasov Aleksandr	1569955e12	chore(ci): Add flatter to host Flatpak repo on GitHub Pages (#76 ) * chore(ci): Add flatter to host Flatpak repo on GitHub Pages - Update release.yml to not upload .flatpak file to releases - Create flatter.yml to automate building and hosting of Flatpak via GitHub pages using andyholmes/flatter - Add nightly branch for main pushes and stable branch for releases - Update README.md with the new Flatpak installation instructions Co-authored-by: arabianq <55220741+arabianq@users.noreply.github.com> * Potential fix for pull request finding 'CodeQL / Workflow does not contain permissions' Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com> --------- Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com> Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com>	2026-04-25 16:38:34 +03:00
Tarasov Aleksandr	9adc6cfbda	update dependencies and change version to 1.7.4 (#75 ) * deps: cargo update cc v1.2.60 -> v1.2.61 libc v0.2.185 -> v0.2.186 winnow v1.0.1 -> v1.0.2 * deps: update cargo-sources.json for flatpak * change version to 1.7.4	2026-04-25 15:58:49 +03:00
Tarasov Aleksandr	76b1d4f345	fix(gui): footer and hotkeys table are no longer clipped because of long filenames (#74 ) * fix: truncate file button text in draw function so footer is no clipped * fix(gui): fix hotkeys table clipping with egui_extras::TableBuilder fully reworked hotkeys page * deps: update flatpak cargo-sources.json	2026-04-25 15:44:50 +03:00
Tarasov Aleksandr	10f9937dc3	tests: parse_command set_volume edge cases (#73 ) Add unit tests for parse_command in src/utils/commands.rs to ensure robust handling of set_volume edge cases including missing or invalid volume and id arguments. Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-25 14:37:55 +03:00
Tarasov Aleksandr	498c09eb50	fix(gui): remove unwrap() calls in input handling to prevent potential panics (#72 ) Replaced `.chars().next().unwrap()` with `.chars().next().is_some_and(...)` in `chord_from_event` and `parse_chord` functions in `src/gui/input.rs`. This ensures that even if the string is empty, the application will not panic, adhering to the project's safety guidelines and resolving a potential security vulnerability. Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-25 14:36:46 +03:00
Tarasov Aleksandr	78e0a133b6	Bump version to 1.7.3 and update dependencies (#70 ) * change version to 1.7.3 * deps: cargo update orbclient -> v0.3.53 wasip2 -> v1.0.3+wasi-0.2.9 wit-bindgen + v0.57.1 * deps: update cargo-sources.json for flatpak	2026-04-21 19:41:19 +03:00
Tarasov Aleksandr	7f8b7194b6	refactor: move PipeWire initialization into a reusable helper function (#69 ) Extract duplicated `pipewire::init()`, `MainLoopRc::new()`, and `ContextRc::new()` setup code from `pw_get_global_objects_thread`, `create_virtual_mic`, and `create_link` into a shared `setup_pipewire_context` helper in `src/utils/pipewire.rs`. Also ran codebase-wide linters to improve code quality. Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-20 19:22:50 +03:00
Tarasov Aleksandr	302f153b91	refactor: break down handle_input into smaller methods in src/gui/input.rs (#67 ) Extract sections from the long `handle_input` function into smaller, context-specific helper methods such as `handle_hotkey_assignment`, `handle_toggles`, `handle_playback_and_focus`, `handle_file_playback`, `handle_navigation`, and `handle_hotkey_triggers`. This significantly improves the maintainability and readability of `src/gui/input.rs` while preserving original functionality. In addition, ran `cargo clippy --fix` on the project to resolve a few other minor health issues, like collapsing nested `if` statements and reducing unnecessary allocations. Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-20 19:21:59 +03:00
Tarasov Aleksandr	f87dcb1564	refactor: remove unnecessary string cloning when finding hotkey conflicts (#68 ) Changed `HotkeyConfig::find_conflicts` to return a `Vec<(&str, &str)>` rather than allocating owned `Strings`. In `src/gui/draw.rs`, the code now builds a `HashSet<&str>` directly from the borrowed strings using array-based flat-mapping, avoiding intermediate `Vec` allocations and redundant clones. Benchmarked to be approximately 3.5x faster in scenarios involving many configured slots. Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-20 19:20:54 +03:00
Tarasov Aleksandr	d4d16f6ce7	Prepare Application for Flathub Submission (#64 ) * chore(flatpak): prepare application for Flathub submission - Change Flatpak filesystem permissions from `host` to `home` to comply with Flathub sandbox rules - Remove `--share=network` build argument and implement offline Rust building using `flatpak-cargo-generator.py` - Add generated `cargo-sources.json` to the Flatpak manifest to download dependencies - Update `CARGO_HOME` environment variable to ensure vendored dependencies are found by `cargo build --offline` - Update `.desktop` categories to meet Flathub specs (`AudioVideo` requirement) - Add required `<releases>`, `bugtracker`, `vcs-browser` URLs, and valid `<developer>` tags to `metainfo.xml` Co-authored-by: arabianq <55220741+arabianq@users.noreply.github.com> * chore(flatpak): prepare application for Flathub submission - Change Flatpak filesystem permissions from `host` to `home` to comply with Flathub sandbox rules - Remove `--share=network` build argument and implement offline Rust building using `flatpak-cargo-generator.py` - Add generated `cargo-sources.json` to the Flatpak manifest to download dependencies - Explicitly set `CARGO_HOME=$PWD/cargo` in build-commands to ensure vendored dependencies are found by `cargo build --offline` - Update `.desktop` categories to meet Flathub specs (`AudioVideo` requirement) - Add required `<releases>`, `bugtracker`, `vcs-browser` URLs, and valid `<developer>` tags to `metainfo.xml` Co-authored-by: arabianq <55220741+arabianq@users.noreply.github.com> * chore(flatpak): add script to generate cargo sources - Added `packages/flatpak/generate-sources.sh` to automate the generation of `cargo-sources.json` - Script downloads the `flatpak-cargo-generator.py` tool from upstream, generates the offline sources map based on `Cargo.lock`, and cleans up after itself Co-authored-by: arabianq <55220741+arabianq@users.noreply.github.com> --------- Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-17 19:35:36 +03:00
Tarasov Aleksandr	949307fcf8	Update dependencies and change version to 1.7.2 (#63 ) * deps: bump tokio to 1.52.1 * deps: bump clap to 4.6.1 * deps: cargo update bitflags -> v2.11.1 core2 - dary_heap -> v0.3.9 font-types -> v0.11.3 include-flate -> v0.3.3 include-flate-codegen -> v0.3.3 include-flate-compress -> v0.3.3 libc -> v0.2.185 libflate -> v2.3.0 libflate_lz77 -> v2.3.0 no_std_io2 + v0.9.3 portable-atomic-util -> v0.2.7 pxfm -> v0.1.29 rayon -> v1.12.0 uuid -> v1.23.1 webbrowser -> v1.2.1 * change version to 1.7.2	2026-04-17 14:42:59 +03:00
Tarasov Aleksandr	2a8fcca06b	Fix virtual mic audio linking (#62 ) * Fix virtual mic audio linking by managing it in AudioPlayer lifecycle - Moved `link_player_to_virtual_mic` to `src/utils/pipewire.rs` and updated it to return a termination sender. - Added `player_link_sender` to `AudioPlayer` to manage the PipeWire link between the daemon and the virtual mic. - Integrated linking logic into `AudioPlayer::play` and `AudioPlayer::update` to ensure the link is established when audio starts playing. - Ensured the link is terminated in `AudioPlayer::drop_stream` when the audio sink is closed. - Removed redundant and potentially failing startup linking loop from the daemon. - Fixed log spam by ensuring `link_player` is only attempted when necessary and errors are handled gracefully. - Maintained compatibility with stable Rust by avoiding unstable features. Co-authored-by: arabianq <55220741+arabianq@users.noreply.github.com> * small refactor * refactor --------- Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-17 14:24:58 +03:00
Tarasov Aleksandr	5c4b8f4b45	refactor(gui): replace verbose key matching with egui native methods (#60 ) Replaced the large match blocks in `chord_from_event` and `parse_chord` with `egui::Key::name()` and `egui::Key::from_name()`. This drastically reduces boilerplate code while maintaining the existing behavior that strictly allows only single-character alphanumeric keys and 'F' keys for chords. Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-17 13:58:08 +03:00
Tarasov Aleksandr	70c7e3789b	🔒 Fix potential memory exhaustion in socket reads (#59 ) Addresses a security vulnerability where the daemon or client could be forced to allocate up to 10MB of memory per malformed socket message, potentially leading to Out-Of-Memory (OOM) crashes. Changes: - Introduced a central `MAX_MESSAGE_SIZE` constant of 128KB in `src/types/socket.rs`. - Enforced the 128KB limit on incoming requests in `src/bin/daemon.rs`. - Enforced the 128KB limit on incoming responses in `src/utils/daemon.rs`. - Preserved detailed `eprintln!` logging when messages are rejected. Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-17 13:56:29 +03:00
Tarasov Aleksandr	5367a3daae	version 1.7.1, update deps, update docs (#57 ) * refactor: removed garbage * change version to 1.7.1 * cargo fmt * cargo update * docs: add information about hotkeys to README * docs: small refactor	2026-04-12 17:23:04 +03:00
Tarasov Aleksandr	42c0170044	fix: hotkeys setting from pwsp-gui (#56 ) * refactor: do not overwrite incorrect hotkeys config * fix: hotkeys not saved via pwsp-gui	2026-04-12 17:05:10 +03:00
RiDDiX	cb56cb3a04	fix: drop audio stream when idle to allow system suspend (#54 ) * fix: drop audio stream when idle to allow system suspend The daemon kept its ALSA playback stream open permanently, which PipeWire reported as a running Stream/Output/Audio node even with no tracks playing. This prevented desktop environments from detecting idle state and entering suspend. - Make the audio sink on-demand: created when playback starts, dropped when all tracks finish - Reduce player loop polling from 100ms to 2s when idle - Throttle PipeWire device enumeration to every ~5s while playing - Log only first and last link retry attempt instead of all 60	2026-04-12 00:42:10 +03:00
Tarasov Aleksandr	5a2418325d	change version to 1.7.0 (#52 )	2026-04-09 10:10:50 +03:00
Tarasov Aleksandr	a948ea2dcd	🧹 remove unsafe unwrap in file name parsing (#51 ) Replaced an unsafe `.unwrap()` with `.unwrap_or_default()` in `src/gui/draw.rs` when parsing file names. This prevents potential panics on invalid paths. Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>	2026-04-09 09:52:14 +03:00
RiDDiX	a156df346b	feat: add hotkey system (#48 ) * feat: add hotkey system for playing individual sounds Slot-based hotkey mappings stored in ~/.config/pwsp/hotkeys.json. Daemon serves hotkey IPC commands for CLI/compositor bindings. GUI supports focused hotkey triggers, a dedicated Hotkeys panel with search and conflict detection, file badges, and a key chord capture dialog. CLI gains play-hotkey, get hotkeys, set hotkey, set hotkey-key, and clear-hotkey subcommands. * feat: add global hotkey support via evdev Listen for keyboard events directly from /dev/input using evdev, enabling hotkeys to work system-wide regardless of window focus or display server (X11, GNOME, KDE Plasma, Hyprland). The daemon spawns async listeners for each keyboard device at startup, tracks modifier state, and triggers playback when a configured chord matches. Requires the user to be in the 'input' group; logs a warning and continues without global hotkeys if devices are inaccessible. * various changes * refactor: route hotkey mutations through daemon IPC GUI no longer writes hotkey config directly to disk. Instead, all mutations (set slot, set key chord, clear chord, remove slot) are sent to the daemon via IPC, which persists the changes. The state thread periodically syncs the hotkey config back from the daemon, so CLI-made changes are reflected in the GUI. New IPC commands: set_hotkey_action (arbitrary action per slot), clear_hotkey_key (remove key chord without removing the slot). Also removes unreachable capture overlay from draw_hotkeys(). * small refactor --------- Co-authored-by: arabian <a.tevg@ya.ru>	2026-04-06 21:43:41 +03:00
qrlh	7a13ae55a6	Add mka (Matroska audio) to the extensions exposed in the GUI (#49 ) Since the mka and mkv extensions are both Matroska format and share magic bytes, mka should work perfectly fine, even though it isn't explicitly mentioned by Symphonia. Tested it and it works, (as long as the audio codec is supported).	2026-04-04 18:58:24 +03:00