Refactor draw_files and draw_tree_node to improve maintainability and readability (#108)

- Extracted search field rendering to `draw_files_search_field`
- Extracted list rendering to `draw_files_list`
- Split `draw_tree_node` file and directory branch logic to `draw_tree_node_file` and `draw_tree_node_dir`

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/build.yml

@@ -23,7 +23,9 @@ jobs:
             zip jq \
             libpipewire-0.3-dev \
             libclang-dev \
-            libasound2-dev
+            libasound2-dev \
+            libdbus-1-dev \
+            pkg-config
 
       - name: Checkout code
         uses: actions/checkout@v4
@@ -33,7 +35,7 @@ jobs:
       - name: Setup Rust toolchain
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          toolchain: 1.94.1
 
       - name: Extract all binary names
         id: cargo-meta
@@ -45,8 +47,8 @@ jobs:
           echo "$BIN_NAMES" >> $GITHUB_OUTPUT
           echo "EOF" >> $GITHUB_OUTPUT
 
-      - name: Build all release binaries
+      - name: Build all binaries
-        run: cargo build --release --locked
+        run: cargo build --locked
 
       - name: Package all binaries into one archive
         shell: bash
@@ -59,7 +61,7 @@ jobs:
           FILES=()
           while IFS= read -r BIN; do
             [ -z "$BIN" ] && continue
-            FILES+=("target/release/$BIN")
+            FILES+=("target/debug/$BIN")
           done <<< "${{ steps.cargo-meta.outputs.bin_names }}"
 
           if [ "${#FILES[@]}" -eq 0 ]; then
@@ -103,7 +105,7 @@ jobs:
   flatpak-build:
     runs-on: ubuntu-latest
     container:
-      image: bilelmoussaoui/flatpak-github-actions:freedesktop-24.08
+      image: ghcr.io/flathub-infra/flatpak-github-actions:freedesktop-25.08
       options: --privileged
 
     steps:

.github/workflows/flatter.yml

@@ -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

.github/workflows/release.yml

@@ -74,7 +74,9 @@ jobs:
             zip jq \
             libpipewire-0.3-dev \
             libclang-dev \
-            libasound2-dev
+            libasound2-dev \
+            libdbus-1-dev \
+            pkg-config
 
       - name: Checkout code at tag
         uses: actions/checkout@v4
@@ -85,7 +87,7 @@ jobs:
       - name: Setup Rust toolchain
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          toolchain: 1.94.1
 
       - name: Extract all binary names
         id: cargo-meta
@@ -158,7 +160,7 @@ jobs:
     needs: prepare
     runs-on: ubuntu-latest
     container:
-      image: bilelmoussaoui/flatpak-github-actions:freedesktop-24.08
+      image: ghcr.io/flathub-infra/flatpak-github-actions:freedesktop-25.08
       options: --privileged
 
     steps:
@@ -174,10 +176,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

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pwsp"
-version = "1.6.2"
+version = "1.9.0"
 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.5.60", default-features = false, features = [
+clap = { version = "4.6.1", default-features = false, features = [
     "std",
     "suggestions",
     "help",
@@ -26,31 +26,42 @@ clap = { version = "4.5.60", default-features = false, features = [
     "error-context",
     "derive",
 ] }
+
 dirs = "6.0.0"
 itertools = "0.14.0"
+evdev = { version = "0.13.2", features = ["tokio"] }
+rfd = { version = "0.17.2", default-features = false, features = [
 
-rodio = { version = "0.22.2", default-features = false, features = [
+    "xdg-portal",
+
+] }
+opener = { version = "0.8.4", features = ["reveal"] }
+system-fonts = "0.1.0"
+anyhow = "1.0.102"
+
+rust-i18n = "4.0.0"
+sys-locale = "0.3.2"
+
+rodio = { git = "https://github.com/arabianq/rodio.git", rev = "1a08f281c352622bd82b87b8731585245802d9cf", default-features = false, features = [
     "symphonia-all",
+    "symphonia-libopus",
     "playback",
 ] }
 pipewire = "0.9.2"
-rfd = { version = "0.17.2", default-features = false, features = [
-    "xdg-portal",
-] }
-opener = { version = "0.8.4", features = ["reveal"] }
 
-egui = { version = "0.33.3", default-features = false, features = [
+egui = { version = "0.34.2", default-features = false, features = [
     "default_fonts",
     "rayon",
 ] }
-eframe = { version = "0.33.3", default-features = false, features = [
+eframe = { version = "0.34.2", default-features = false, features = [
     "default_fonts",
     "glow",
     "x11",
     "wayland",
 ] }
-egui_material_icons = "0.5.0"
+egui_extras = "0.34.1"
-egui_dnd = "0.14.0"
+egui_material_icons = "0.6.0"
+egui_dnd = "0.15.0"
 
 [[bin]]
 name = "pwsp-daemon"

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Tarasov Alexander
+Copyright (c) 2026 arabianq
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,213 +1,118 @@
-# **🎵 Pipewire Soundpad (PWSP)**
+<div align="center">
+  <h1>🎵 PipeWire Soundpad (PWSP)</h1>
+  <p><b>A simple, modern, and powerful soundboard for Linux, written in Rust.</b></p>
+  <img src="assets/screenshot.png" alt="PWSP Screenshot" width="700"/>
+</div>
 
-**PipeWire Soundpad (PWSP)** is a simple yet powerful **soundboard application** written in **Rust**. It provides a
+## 🌟 Overview
-user-friendly graphical interface for **managing and playing audio files, directing their output directly to the virtual
+**PipeWire Soundpad (PWSP)** is a graphical soundboard application that routes audio directly to your virtual microphone using **PipeWire**. It provides an intuitive interface for managing your audio collection, making it an ideal tool for gamers, streamers, and anyone looking to inject sound effects into voice chats on platforms like Discord, Zoom, or TeamSpeak.
-microphone.** This makes it an ideal tool for gamers, streamers, and anyone looking to inject sound effects into voice
-chats on platforms like **Discord, Zoom, or Teamspeak**.
 
-![screenshot.png](assets/screenshot.png)
+## ✨ Key Features
+* **🎙️ Virtual Microphone Output:** Seamlessly mixes your microphone input with sound effects by automatically managing PipeWire virtual devices.
+* **🎵 Multi-Format Support:** Plays popular audio formats including `mp3`, `wav`, `ogg`, `flac`, `mp4`, and `aac`.
+* **⚡ Global Hotkeys:** Trigger sounds instantly from anywhere, even when the app is running in the background.
+* **📂 Smart Collection Management:** Drag-and-drop folders, quick search, and collapsible tracks to keep your library organized.
+* **🎛️ Advanced Playback Controls:** Individual volume sliders, play/pause, position scrubbing, and concurrent multi-track playback.
+* **🔌 Plug & Play:** Automatically detects when an input device is connected or disconnected and handles linking/unlinking on the fly.
+* **🖥️ Modern GUI:** Clean, responsive, and lightweight interface powered by [egui](https://egui.rs/).
 
-# **🌟 Key Features**
+## ⚙️ Architecture
+PWSP is built with a client-server model to ensure stability and separation of concerns:
+* **`pwsp-daemon`**: The background engine. It runs silently, managing PipeWire virtual devices, audio routing, and playback.
+* **`pwsp-gui`**: The graphical interface. Communicates with the daemon via a Unix socket to control playback and settings.
+* **`pwsp-cli`**: The command-line tool. Perfect for scripting, hotkey binding, or quick terminal-based control.
 
-* **Multi-Format Support**: Play audio files in popular formats, including _**mp3**_, _**wav**_, _**ogg**_, _**flac**_,
+---
-  _**mp4**_, and _**aac**_.
-* **Virtual Microphone Output**: The application routes audio through a virtual device created by PipeWire, allowing
-  other users to hear the sounds as if you were speaking into your microphone.
-* **Modern and Clean GUI**: The interface is built with the [egui](https://egui.rs) library, ensuring an intuitive and
-  responsive user experience.
-* **Sound Collection Management**: Easily add and remove directories containing your audio files. The application scans
-  these folders and displays all supported files for quick access.
-* **Quick Search**: Use the built-in search bar to instantly find any sound file within your library.
-* **Detailed Playback Controls**:
-    * **Play/Pause button**.
-    * **Volume slider** for individual sound adjustment.
-    * **Position slider** to fast-forward or rewind the audio.
-* **Persistent Configuration**: The list of added directories and your selected audio output device are saved
-  automatically, so you won't need to reconfigure them every time you launch the application.
-* **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.
 
-# **⚙️ How It Works**
+## 🚀 Installation
 
-PWSP is designed with a clear separation of concerns, operating through a client-server architecture. It consists of
+### 📦 Flatpak (Recommended)
-three main components:
+Install PWSP via Flatpak from our custom repository:
+```bash
+flatpak remote-add --user --if-not-exists pwsp-repo https://arabianq.github.io/pipewire-soundpad/index.flatpakrepo
 
-* **pwsp-daemon**: This is the core of the application. It runs silently in the background, managing all the
+# Install stable version
-  heavy-lifting tasks. The daemon is responsible for:
+flatpak install --user arabianq-repo ru.arabianq.pwsp//stable
-    * Creating and managing virtual audio devices.
-    * Linking these devices within the PipeWire graph.
-    * Handling all audio playback.
-* **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.
 
-# **🚀 Installation**
+# Or install the nightly version (latest commit)
-
+flatpak install --user arabianq-repo ru.arabianq.pwsp//nightly
-## **Pre-built Packages**
+```
-
-You can download pre-built binaries and .deb packages from
-the [releases page](https://github.com/arabianq/pipewire-soundpad/releases).
-
-## **Fedora Linux (and derivatives)**
-
-If you're using Fedora, you can install PWSP from a dedicated repository using DNF.
-
-Add the repository:
 
+### 🐧 Linux Packages
+**Fedora (and derivatives):**
 ```bash
 sudo dnf copr enable arabianq/pwsp
-```
-
-Update cache:
-
-```bash
-sudo dnf makecache
-```
-
-Install PWSP:
-
-```bash
 sudo dnf install pwsp
 ```
 
-## **Arch Linux**
+**Arch Linux (AUR):**
-There is pwsp package in AUR.
-You can install it using yay, paru or any other AUR helper.
 ```bash
-paru pwsp-bin # or paru pwsp to build it locally
+paru -S pwsp-bin # or 'pwsp' to build from source
 ```
 
-## **Installing using cargo**
+**Debian / Ubuntu:** 
+Download pre-built `.deb` packages or standalone binaries from the [Releases page](https://github.com/arabianq/pipewire-soundpad/releases).
 
+### 🦀 Cargo / Source Build
 ```bash
 cargo install pwsp
-```
 
-## **Building from source**
+# OR clone and build manually:
-
-#### **Requirements**
-
-* **Rust**: Install [Rust](https://www.rust-lang.org/tools/install) (using rustup is recommended).
-* **PipeWire**: Ensure that [PipeWire](https://pipewire.org/) is installed and running on your system.
-
-#### **Build Instructions**
-
-Clone the repository:
-
-```bash
 git clone https://github.com/arabianq/pipewire-soundpad.git
 cd pipewire-soundpad
-```
-
-Build the project:
-
-```bash
 cargo build --release
 ```
+*(Note: Requires Rust toolchain and PipeWire running on your system).*
 
-Now you have three binary files inside ./target/release/:
+---
 
-- **pwsp-gui**
+## 🎮 Usage
-- **pwsp-cli**
-- **pwsp-daemon**
 
-# **🎮 Usage**
+### 1. Start the Daemon
-
+Before using the GUI or CLI, the daemon must be running in the background.
-Before using pwsp-gui or pwsp-cli, you **must** first run the pwsp-daemon in the background.
-
-### **Running the Daemon**
-
-You can start the daemon from the terminal or enable the systemd service for automatic startup.
-
-* **Manual Start:**
 
 ```bash
-/path/to/your/pwsp-daemon &
+# Recommended: Start and enable via systemd (starts on login)
+systemctl --user enable --now pwsp-daemon
+
+# Manual start (if not using systemd):
+pwsp-daemon &
 ```
 
-* **Using systemd (recommended):**  
+### 2. Using the GUI
-  If you installed PWSP using prebuilt packages, the systemd service is added automatically.
+1. **Add Sounds:** Click the **"+"** button to add a directory containing your audio files.
-    1. **Start the service:**
+2. **Select Mic:** Choose your physical microphone from the dropdown. PWSP will instantly create a virtual microphone combining your voice and the soundboard.
-        ```bash  
+3. **Play:** Click any sound to play it, adjust its volume, or assign a hotkey for quick access.
-        systemctl --user start pwsp-daemon
-        ```
-    2. **Enable autostart (starts on login):**
-        ```bash
-       systemctl --user enable --now pwsp-daemon
-        ```
-
-### **Using the GUI**
-
-1. **Add Sounds**: Click the **"+"** button and select a folder containing your audio files. The application
-   will automatically list all supported files.
-2. **Select Microphone**: In the main application window, select your microphone. PWSP will automatically
-   create a virtual microphone and feed it sound from two sources: **your microphone** and the **audio files**.
-3. **Playback**: Click on a file in the list to load it, then use the **"Play"** and **"Pause"** buttons to control
-   playback. You can also play single file once using **"Play File"** button.
-
-### **Using the CLI**
-
-The pwsp-cli tool allows you to control the daemon from the command line.
-
-* **General Help**: To see a list of all available commands, run:
 
+### 3. Using the CLI
+Control the daemon directly from your terminal:
 ```bash
-pwsp-cli --help
+pwsp-cli action play /path/to/sound.mp3
+pwsp-cli get volume
+pwsp-cli set position 20
+pwsp-cli --help # View all commands
 ```
 
-* **Example Commands**:
+---
-    * **Play a file**:
 
-      ```bash
+## ⌨️ Shortcuts & Controls
-      pwsp-cli action play <file_path>
-      ```
 
-    * **Get the current volume**:
+| Action                               | Keyboard               | Mouse                |
+| :----------------------------------- | :--------------------- | :------------------- |
+| **Play Track** (Stops others)        |                        | `Left Click`         |
+| **Add Track** (Plays simultaneously) |                        | `Ctrl + Left Click`  |
+| **Replace Last Track**               |                        | `Shift + Left Click` |
+| **Pause / Resume**                   | `Space`                |                      |
+| **Stop All Tracks**                  | `Backspace`            |                      |
+| **Open / Close Settings**            | `I`                    |                      |
+| **Search**                           | `/`                    |                      |
 
-      ```bash
+---
-      pwsp-cli get volume
-      ```
 
-    * **Set playback position to 20 seconds**:
+## 🤝 Contributing
+Contributions, issues, and feature requests are welcome! Feel free to check out the [issues page](https://github.com/arabianq/pipewire-soundpad/issues).
 
-      ```bash 
-      pwsp-cli set position 20
-      ```
-
-### **Hotkeys & Controls**
-
-#### **Keyboard Shortcuts**
-
-| Key                      | Action                                               |
-| :----------------------- | :--------------------------------------------------- |
-| **Space**                | Pause / Resume audio                                 |
-| **Backspace**            | Stop all audio tracks                                |
-| **Enter**                | Play selected file (stops all other tracks)          |
-| **Ctrl + Enter**         | Add selected file to playback (plays simultaneously) |
-| **Shift + Enter**        | Replace the last added track with the selected one   |
-| **I**                    | Open / Close settings                                |
-| **/**                    | Focus search field                                   |
-| **Ctrl + ↑ / ↓**         | Navigate through files                               |
-| **Ctrl + Shift + ↑ / ↓** | Navigate through directories                         |
-
-#### **Mouse Controls**
-
-* **Left Click**: Play track (stops all other tracks).
-* **Ctrl + Left Click**: Add track (plays simultaneously with current tracks).
-* **Shift + Left Click**: Replace the last added track with the selected one.
-
-# **🤝 Contributing**
-
-Contributions are welcome\! If you have ideas for improvements or find a bug, feel free to create
-an [issue](https://github.com/arabianq/pipewire-soundpad/issues) or submit
-a [pull request](https://github.com/arabianq/pipewire-soundpad/pulls).
-
-# **📜 License**
-
-This project is licensed under
-the [MIT License](https://github.com/arabianq/pipewire-soundpad/blob/main/LICENSE).
-
-# **🤖 AI Wiki**
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/arabianq/pipewire-soundpad)
+
+## 📜 License
+This project is licensed under the [MIT License](LICENSE).

locales/app.toml

@@ -0,0 +1,376 @@
+_version = 2
+
+# ----------------
+# Main page
+# ----------------
+
+[gui.play_file_button]
+en = "Play file"
+ru = "Выбрать файл"
+es = "Reproducir archivo"
+fr = "Lire le fichier"
+zh = "播放文件"
+ar = "تشغيل الملف"
+kz = "Файлды ойнату"
+he = "נגן קובץ"
+pt-BR = "Reproduzir arquivo"
+
+[gui.choose_mic_select]
+en = "Select microphone"
+ru = "Выбрать микрофон"
+es = "Seleccionar micrófono"
+fr = "Sélectionner le microphone"
+zh = "选择麦克风"
+ar = "اختر الميكروفون"
+kz = "Микрофонды таңдау"
+he = "בחר מיקרופון"
+pt-BR = "Selecionar microfone"
+
+[gui.search_placeholder]
+en = "Search files..."
+ru = "Поиск файлов..."
+es = "Buscar archivos..."
+fr = "Rechercher des fichiers..."
+zh = "搜索文件..."
+ar = "البحث عن ملفات..."
+kz = "Файлдарды іздеу..."
+he = "חפש קבצים..."
+pt-BR = "Buscar arquivos..."
+
+[gui.context.dirs.open]
+en = "Open"
+ru = "Открыть"
+es = "Abrir"
+fr = "Ouvrir"
+zh = "打开"
+ar = "فتح"
+kz = "Ашу"
+he = "פתח"
+pt-BR = "Abrir"
+
+[gui.context.dirs.open_in_fm]
+en = "Open in File Manager"
+ru = "Открыть в менеджере файлов"
+es = "Abrir en el gestor de archivos"
+fr = "Ouvrir dans le gestionnaire de fichiers"
+zh = "在文件管理器中打开"
+ar = "فتح في مدير الملفات"
+kz = "Файл менеджерінде ашу"
+he = "פתח במנהל הקבצים"
+pt-BR = "Abrir no gestor de arquivos"
+
+[gui.context.dirs.remove]
+en = "Remove"
+ru = "Удалить"
+es = "Eliminar"
+fr = "Supprimer"
+zh = "移除"
+ar = "إزالة"
+kz = "Жою"
+he = "הסר"
+pt-BR = "Remover"
+
+[gui.context.files.play_solo]
+en = "Play Solo"
+ru = "Играть"
+es = "Reproducir solo"
+fr = "Jouer en solo"
+zh = "单独播放"
+ar = "تشغيل منفرد"
+kz = "Жалғыз ойнату"
+he = "נגן סולו"
+pt-BR = "Reproduzir"
+
+[gui.context.files.add_new]
+en = "Add New"
+ru = "Добавить"
+es = "Añadir nuevo"
+fr = "Ajouter un nouveau"
+zh = "添加新项"
+ar = "إضافة جديد"
+kz = "Жаңасын қосу"
+he = "הוסף חדש"
+pt-BR = "Adicionar"
+
+[gui.context.files.replace_last]
+en = "Replace Last"
+ru = "Заменить Последний"
+es = "Reemplazar último"
+fr = "Remplacer le dernier"
+zh = "替换上一个"
+ar = "استبدال الأخير"
+kz = "Соңғысын ауыстыру"
+he = "החלף אחרון"
+pt-BR = "Substituir"
+
+[gui.context.files.show_in_fm]
+en = "Show in File Manager"
+ru = "Открыть в менеджере файлов"
+es = "Mostrar en el gestor de archivos"
+fr = "Afficher dans le gestionnaire de fichiers"
+zh = "在文件管理器中显示"
+ar = "عرض في مدير الملفات"
+kz = "Файл менеджерінде көрсету"
+he = "הצג במנהל הקבצים"
+pt-BR = "Mostrar no gestor de arquivos"
+
+[gui.context.files.asign_hotkey]
+en = "Assign Hotkey"
+ru = "Назначить Горячую Клавишу"
+es = "Asignar atajo"
+fr = "Assigner un raccourci"
+zh = "分配快捷键"
+ar = "تعيين مفتاح اختصار"
+kz = "Ыстық пернені тағайындау"
+he = "הקצה מקש קיצור"
+pt-BR = "Definir tecla de atalho"
+
+# ----------------
+# Settings
+# ----------------
+
+[gui.settings.header]
+en = "Settings"
+ru = "Настройки"
+es = "Ajustes"
+fr = "Paramètres"
+zh = "设置"
+ar = "الإعدادات"
+kz = "Баптаулар"
+he = "הגדרות"
+pt-BR = "Configurações"
+
+[gui.settings.remember_volume]
+en = "Always remember volume"
+ru = "Всегда запоминать громкость"
+es = "Recordar siempre el volumen"
+fr = "Toujours se souvenir du volume"
+zh = "始终记住音量"
+ar = "تذكر مستوى الصوت دائمًا"
+kz = "Әрқашан дыбыс деңгейін есте сақтау"
+he = "זכור תמיד עוצמת קול"
+pt-BR = "Lembrar volume"
+
+[gui.settings.remember_mic]
+en = "Always remember microphone"
+ru = "Всегда запоминать микрофон"
+es = "Recordar siempre el micrófono"
+fr = "Toujours se souvenir du microphone"
+zh = "始终记住麦克风"
+ar = "تذكر الميكروفون دائمًا"
+kz = "Әрқашан микрофонды есте сақтау"
+he = "זכור תמיד מיקרופון"
+pt-BR = "Lembrar microfone"
+
+[gui.settings.remember_ui_scale]
+en = "Always remember UI scale factor"
+ru = "Всегда запоминать масштаб интерфейса"
+es = "Recordar siempre la escala de la interfaz"
+fr = "Toujours se souvenir de l'échelle de l'interface"
+zh = "始终记住界面缩放比例"
+ar = "تذكر عامل تكبير الواجهة دائمًا"
+kz = "Әрқашан интерфейс масштабын есте сақтау"
+he = "זכור תמיד קנה מידה של ממשק משתמש"
+pt-BR = "Lembrar fator de escala da interface"
+
+[gui.settings.pause_on_window_close]
+en = "Pause audio playback when the window is closed"
+ru = "Останавливать воспроизведение при закрытии окна"
+es = "Pausar la reproducción de audio al cerrar la ventana"
+fr = "Mettre en pause la lecture audio à la fermeture de la fenêtre"
+zh = "关闭窗口时暂停音频播放"
+ar = "إيقاف الصوت مؤقتًا عند إغلاق النافذة"
+kz = "Терезе жабылған кезде дыбысты ойнатуды кідірту"
+he = "השהה השמעת שמע כאשר החלון נסגר"
+pt-BR = "Pausar reprodução de aúdio ao fechar a janela"
+
+[gui.settings.version]
+en = "GUI version: %{version}"
+ru = "Версия GUI: %{version}"
+es = "Versión de la GUI: %{version}"
+fr = "Version de l'interface : %{version}"
+zh = "GUI 版本: %{version}"
+ar = "إصدار الواجهة: %{version}"
+kz = "GUI нұсқасы: %{version}"
+he = "גרסת ממשק משתמש: %{version}"
+pt-BR = "Versão da GUI: %{version}"
+
+# ----------------
+# Hotkeys
+# ----------------
+
+[gui.hotkeys.header]
+en = "Hotkeys"
+ru = "Горячие клавиши"
+es = "Atajos de teclado"
+fr = "Raccourcis clavier"
+zh = "快捷键"
+ar = "اختصارات لوحة المفاتيح"
+kz = "Ыстық пернелер"
+he = "מקשי קיצור"
+pt-BR = "Atalhos"
+
+[gui.hotkeys.search_placeholder]
+en = "Search hotkeys..."
+ru = "Поиск горячих клавиш..."
+es = "Buscar atajos..."
+fr = "Rechercher des raccourcis..."
+zh = "搜索快捷键..."
+ar = "البحث عن الاختصارات..."
+kz = "Ыстық пернелерді іздеу..."
+he = "חפש מקשי קיצור..."
+pt-BR = "Buscar atalhos..."
+
+[gui.hotkeys.add_command_select]
+en = "Add Command"
+ru = "Добавить команду"
+es = "Añadir comando"
+fr = "Ajouter une commande"
+zh = "添加命令"
+ar = "إضافة أمر"
+kz = "Команда қосу"
+he = "הוסף פקודה"
+pt-BR = "Adicionar comando"
+
+[gui.hotkeys.toggle_pause_command]
+en = "Toggle Pause"
+ru = "Переключить паузу"
+es = "Alternar pausa"
+fr = "Basculer la pause"
+zh = "切换暂停"
+ar = "تبديل الإيقاف المؤقت"
+kz = "Кідіртуді ауыстыру"
+he = "הפעל/השהה"
+pt-BR = "Alternar reprodução"
+
+[gui.hotkeys.stop_playback_command]
+en = "Stop Playback"
+ru = "Остановить воспроизведение"
+es = "Detener reproducción"
+fr = "Arrêter la lecture"
+zh = "停止播放"
+ar = "إيقاف التشغيل"
+kz = "Ойнатуды тоқтату"
+he = "עצור השמעה"
+pt-BR = "Parar reprodução"
+
+[gui.hotkeys.pause_playback_command]
+en = "Pause Playback"
+ru = "Поставить воспроизведение на паузу"
+es = "Pausar reproducción"
+fr = "Mettre en pause la lecture"
+zh = "暂停播放"
+ar = "إيقاف التشغيل مؤقتاً"
+kz = "Ойнатуды кідірту"
+he = "השהה השמעה"
+pt-BR = "Pausar reprodução"
+
+[gui.hotkeys.resume_playback_command]
+en = "Resume Playback"
+ru = "Продолжить воспроизведение"
+es = "Reanudar reproducción"
+fr = "Reprendre la lecture"
+zh = "恢复播放"
+ar = "استئناف التشغيل"
+kz = "Ойнатуды жалғастыру"
+he = "המשך השמעה"
+pt-BR = "Resumir reprodução"
+
+[gui.hotkeys.toggle_loop_command]
+en = "Toggle Loop"
+ru = "Переключить зацикливание"
+es = "Alternar bucle"
+fr = "Basculer la boucle"
+zh = "切换循环"
+ar = "تبديل التكرار"
+kz = "Қайталауды ауыстыру"
+he = "הפעל/כבה לולאה"
+pt-BR = "Alternar loop"
+
+[gui.hotkeys.column_slot]
+en = "Slot"
+ru = "Слот"
+es = "Ranura"
+fr = "Emplacement"
+zh = "插槽"
+ar = "الخانة"
+kz = "Ұяшық"
+he = "משבצת"
+pt-BR = "Slot"
+
+[gui.hotkeys.column_sound]
+en = "Sound"
+ru = "Звук"
+es = "Sonido"
+fr = "Son"
+zh = "声音"
+ar = "الصوت"
+kz = "Дыбыс"
+he = "צליל"
+pt-BR = "Som"
+
+[gui.hotkeys.column_key_chord]
+en = "Key Chord"
+ru = "Клавиша"
+es = "Combinación de teclas"
+fr = "Combinaison de touches"
+zh = "组合键"
+ar = "تركيبة المفاتيح"
+kz = "Пернелер тіркесімі"
+he = "צירוף מקשים"
+pt-BR = "Combinação de teclas"
+
+[gui.hotkeys.column_actions]
+en = "Actions"
+ru = "Действия"
+es = "Acciones"
+fr = "Actions"
+zh = "操作"
+ar = "الإجراءات"
+kz = "Әрекеттер"
+he = "פעולות"
+pt-BR = "Ações"
+
+[gui.hotkeys.no_hotkeys_configured]
+en = "No hotkeys configured"
+ru = "Горячие клавиши не настроены"
+es = "No hay atajos configurados"
+fr = "Aucun raccourci configuré"
+zh = "未配置快捷键"
+ar = "لا توجد اختصارات معينة"
+kz = "Ыстық пернелер бапталмаған"
+he = "לא הוגדרו מקשי קיצור"
+pt-BR = "Nenhum atalho configurado"
+
+[gui.hotkeys.capture.header]
+en = "Press a key combination (e.g. Ctrl+Alt+1)"
+ru = "Нажмите сочетание клавиш (например, Ctrl+Alt+1)"
+es = "Presione una combinación de teclas (ej. Ctrl+Alt+1)"
+fr = "Appuyez sur une combinaison de touches (ex. Ctrl+Alt+1)"
+zh = "按下一个组合键 (例如 Ctrl+Alt+1)"
+ar = "اضغط على تركيبة مفاتيح (مثلاً Ctrl+Alt+1)"
+kz = "Пернелер тіркесімін басыңыз (мысалы, Ctrl+Alt+1)"
+he = "לחץ על צירוף מקשים (למשל Ctrl+Alt+1)"
+pt-BR = "Pressione uma combinação de tecla (ex: Ctrl+Alt+1)"
+
+[gui.hotkeys.capture.for]
+en = "for"
+ru = "для"
+es = "para"
+fr = "pour"
+zh = "用于"
+ar = "لـ"
+kz = "үшін"
+he = "עבור"
+pt-BR = "para"
+
+[gui.hotkeys.capture.cancel]
+en = "Press Escape to cancel"
+ru = "Нажмите Escape для отмены"
+es = "Presione Escape para cancelar"
+fr = "Appuyez sur Échap pour annuler"
+zh = "按 Escape 取消"
+ar = "اضغط Esc للإلغاء"
+kz = "Болдырмау үшін Escape пернесін басыңыз"
+he = "לחץ על Escape לביטול"
+pt-BR = "Pressione Esc para cancelar"

packages/aur/bin/.SRCINFO

@@ -1,7 +1,7 @@
 pkgbase = pwsp-bin
 pkgdesc = Lets you play audio files through your microphone (Pre-built binaries)
-pkgver = 1.6.2
+pkgver = 1.9.0
-pkgrel = 2
+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.2.zip :: https://github.com/arabianq/pipewire-soundpad/releases/download/v1.6.2/pwsp-v1.6.2-linux-x64.zip
+source = pwsp-bin-1.9.0.zip :: https://github.com/arabianq/pipewire-soundpad/releases/download/v1.9.0/pwsp-v1.9.0-linux-x64.zip
-source = pipewire-soundpad-1.6.2.tar.gz :: https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.6.2.tar.gz
+source = pipewire-soundpad-1.9.0.tar.gz :: https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.9.0.tar.gz
 sha256sums = SKIP
 sha256sums = SKIP
 

packages/aur/bin/PKGBUILD

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

packages/aur/standart/.SRCINFO

@@ -1,6 +1,6 @@
 pkgbase = pwsp
 	pkgdesc = Lets you play audio files through your microphone
-	pkgver = 1.6.2
+	pkgver = 1.9.0
 	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.2.tar.gz
+	source = https://github.com/arabianq/pipewire-soundpad/archive/refs/tags/v1.9.0.tar.gz
 	sha256sums = SKIP
 
 pkgname = pwsp

packages/aur/standart/PKGBUILD

@@ -1,13 +1,13 @@
 # Maintainer: Alexander Tarasov <a.tevg@ya.ru>
 pkgsubn=pwsp
 pkgname=pwsp
-pkgver=1.6.2
+pkgver=1.9.0
 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')
 

packages/flatpak/generate-sources.sh

@@ -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"

packages/flatpak/ru.arabianq.pwsp.desktop

@@ -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;

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

@@ -15,11 +15,17 @@
     <launchable type="desktop-id">ru.arabianq.pwsp.desktop</launchable>
     <screenshots>
         <screenshot type="default">
-            <image>
+            <image>https://raw.githubusercontent.com/arabianq/pipewire-soundpad/master/assets/screenshot.png</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.9.0" date="2026-05-15" />
+    </releases>
     <content_rating type="oars-1.1" />
 </component>

packages/flatpak/ru.arabianq.pwsp.yaml

@@ -1,6 +1,6 @@
 app-id: ru.arabianq.pwsp
 runtime: org.freedesktop.Platform
-runtime-version: "24.08"
+runtime-version: "25.08"
 sdk: org.freedesktop.Sdk
 sdk-extensions:
   - org.freedesktop.Sdk.Extension.rust-stable
@@ -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

packages/rpm/pwsp.spec

@@ -4,7 +4,7 @@
 %global cargo_install_lib 0
 
 Name:            pwsp
-Version:         1.6.2
+Version:         1.9.0
 Release:         %autorelease
 Summary:         Lets you play audio files through your microphone
 
@@ -18,6 +18,9 @@ BuildRequires: cargo
 BuildRequires: pipewire-devel
 BuildRequires: alsa-lib-devel
 BuildRequires: clang-devel
+BuildRequires: cmake
+BuildRequires: dbus-devel
+BuildRequires: pkgconf-pkg-config
 
 %global _description %{expand:
 PWSP lets you play audio files through your microphone. Has both CLI and

src/bin/cli.rs

@@ -1,9 +1,10 @@
+use anyhow::{Result, anyhow};
 use clap::{Parser, Subcommand};
 use pwsp::{
     types::socket::Request,
     utils::daemon::{make_request, wait_for_daemon},
 };
-use std::{error::Error, path::PathBuf};
+use std::path::PathBuf;
 
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -68,6 +69,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 +108,8 @@ enum GetCommands {
     DaemonVersion,
     /// Full player state
     FullState,
+    /// All hotkey slots
+    Hotkeys,
 }
 
 #[derive(Subcommand, Debug)]
@@ -125,10 +134,20 @@ 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]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn main() -> Result<()> {
     let cli = Cli::parse();
 
     wait_for_daemon().await?;
@@ -146,6 +165,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,18 +180,32 @@ 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,
+            ),
         },
     };
 
-    let response = make_request(request)
+    let response = make_request(request).await.map_err(|e| anyhow!(e))?;
-        .await
-        .map_err(|e| e as Box<dyn Error>)?;
     println!("{} : {}", response.status, response.message);
 
     Ok(())

src/bin/daemon.rs

@@ -1,15 +1,18 @@
+use anyhow::{Result, anyhow};
 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,
     },
 };
-use std::{error::Error, fs, time::Duration};
+use std::os::unix::fs::PermissionsExt;
+use std::{fs, time::Duration};
 use tokio::{
     io::{AsyncReadExt, AsyncWriteExt},
     net::UnixListener,
@@ -17,27 +20,22 @@ use tokio::{
 };
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn main() -> Result<()> {
     create_runtime_dir()?;
 
     if is_daemon_running()? {
-        return Err("Another instance is already running.".into());
+        return Err(anyhow!("Another instance is already running."));
     }
 
     get_daemon_config(); // Initialize daemon config
     create_virtual_mic()?;
-    get_audio_player().await; // Initialize audio player
+    if let Err(err) = get_audio_player().await {
+        eprintln!("Failed to initialize audio player: {}", err);
+    } // Initialize audio player
 
-    let max_retries = 5;
+    tokio::spawn(async {
-    for i in 0..=max_retries {
+        start_global_hotkey_listener().await;
-        match link_player_to_virtual_mic().await {
+    });
-            Ok(_) => break,
-            Err(e) => println!("{e}\t{i}/{max_retries}"),
-        }
-
-        sleep(Duration::from_millis(300 * i)).await;
-    }
-    link_player_to_virtual_mic().await?;
 
     let runtime_dir = get_runtime_dir();
 
@@ -45,11 +43,15 @@ async fn main() -> Result<(), Box<dyn Error>> {
     lock_file.lock()?;
 
     let socket_path = runtime_dir.join("daemon.sock");
-    if fs::metadata(&socket_path).is_ok() {
+    if let Err(e) = fs::remove_file(&socket_path)
-        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))?;
+
     println!(
         "Daemon started. Listening on {}",
         socket_path.to_str().unwrap_or_default()
@@ -75,7 +77,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
-async fn commands_loop(listener: UnixListener) -> Result<(), Box<dyn Error>> {
+async fn commands_loop(listener: UnixListener) -> Result<()> {
     loop {
         let (mut stream, _addr) = listener.accept().await?;
 
@@ -89,6 +91,14 @@ async fn commands_loop(listener: UnixListener) -> Result<(), Box<dyn Error>> {
 
             let request_len = u32::from_le_bytes(len_bytes) as usize;
 
+            if request_len > MAX_MESSAGE_SIZE {
+                eprintln!(
+                    "Failed to read message from client: request too large ({} bytes)!",
+                    request_len
+                );
+                return;
+            }
+
             let mut buffer = vec![0u8; request_len];
             if stream.read_exact(&mut buffer).await.is_err() {
                 eprintln!("Failed to read message from client!");
@@ -150,11 +160,25 @@ async fn commands_loop(listener: UnixListener) -> Result<(), Box<dyn Error>> {
 }
 
 async fn player_loop() {
+    let mut device_check_counter: u32 = 0;
     loop {
-        let mut audio_player = get_audio_player().await.lock().await;
+        let is_idle = match get_audio_player().await {
+            Ok(player_mutex) => {
+                let mut audio_player = player_mutex.lock().await;
+                let check_devices = device_check_counter == 0;
+                audio_player.update(check_devices).await;
+                audio_player.tracks.is_empty()
+            }
+            Err(_err) => true,
+        };
 
-        audio_player.update().await;
+        if is_idle {
-
+            device_check_counter = 0;
-        sleep(Duration::from_millis(100)).await;
+            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;
+        }
     }
 }

src/gui/input.rs

@@ -1,7 +1,82 @@
 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 {
@@ -17,7 +92,7 @@ impl SoundpadGui {
     }
 
     pub fn handle_input(&mut self, ctx: &Context) {
-        let modifiers = self.modifiers(ctx);
+        let _modifiers = self.modifiers(ctx);
         let search_focused = {
             if let Some(focused_id) = self.get_focused(ctx)
                 && let Some(search_id) = self.app_state.search_field_id
@@ -29,12 +104,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();
@@ -56,78 +195,23 @@ impl SoundpadGui {
                 }
             }
 
-            // Play selected file on Enter
+            // Check for hotkey chord triggers
-            if self.key_pressed(ctx, Key::Enter) && self.app_state.selected_file.is_some() {
+            let slots_to_play: Vec<String> = ctx.input(|i| {
-                let path = &self.app_state.selected_file.clone().unwrap();
+                let mut result = vec![];
-                if modifiers.ctrl {
+                for slot in &self.app_state.hotkey_config.slots {
-                    self.play_file(path, true);
+                    if let Some(chord) = &slot.key_chord
-                } else if modifiers.shift
+                        && let Some((mods, key)) = parse_chord(chord)
-                    && let Some(last_track) = self.audio_player_state.tracks.last()
+                        && i.modifiers == mods
-                {
+                        && i.key_pressed(key)
-                    self.stop(Some(last_track.id));
+                    {
-                    self.play_file(path, true);
+                        result.push(slot.slot.clone());
-                } else {
+                    }
-                    self.play_file(path, false);
                 }
-            }
+                result
+            });
 
-            // Iterate through dirs and files with Ctrl + Up/Down
+            for slot in slots_to_play {
-            let arrow_up_pressed = self.key_pressed(ctx, Key::ArrowUp);
+                self.play_hotkey_slot(&slot);
-            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();
-                    dirs.sort();
-
-                    let current_dir_index: i8;
-                    if let Some(current_dir) = &self.app_state.current_dir {
-                        if let Some(index) = dirs.iter().position(|x| x == current_dir) {
-                            current_dir_index = index as i8;
-                        } else {
-                            current_dir_index = -1;
-                        }
-                    } else {
-                        current_dir_index = -1;
-                    }
-
-                    let mut new_dir_index: i8;
-
-                    new_dir_index =
-                        current_dir_index - arrow_up_pressed as i8 + arrow_down_pressed as i8;
-
-                    if new_dir_index < 0 {
-                        new_dir_index = (dirs.len() - 1) as i8;
-                    } else if new_dir_index >= dirs.len() as i8 {
-                        new_dir_index = 0;
-                    }
-
-                    self.open_dir(&dirs[new_dir_index as usize]);
-                } else if self.app_state.current_dir.is_some() {
-                    let files = self.get_filtered_files();
-
-                    if files.is_empty() {
-                        return;
-                    }
-
-                    let current_files_index = self
-                        .app_state
-                        .selected_file
-                        .as_ref()
-                        .and_then(|f| files.iter().position(|x| x == f))
-                        .map(|i| i as i64)
-                        .unwrap_or(-1);
-
-                    let mut new_files_index =
-                        current_files_index - arrow_up_pressed as i64 + arrow_down_pressed as i64;
-
-                    if new_files_index < 0 {
-                        new_files_index = (files.len() - 1) as i64;
-                    } else if new_files_index >= files.len() as i64 {
-                        new_files_index = 0;
-                    }
-
-                    self.app_state.selected_file = Some(files[new_files_index as usize].clone());
-                }
             }
         }
         // });

src/gui/mod.rs

@@ -2,13 +2,15 @@ mod draw;
 mod input;
 mod update;
 
+use anyhow::{Result, anyhow};
 use eframe::{HardwareAcceleration, NativeOptions, icon_data::from_png_bytes, run_native};
-use egui::{Context, Vec2, ViewportBuilder};
+use egui::{Context, FontData, FontDefinitions, FontFamily, FontTweak, Vec2, ViewportBuilder};
 use itertools::Itertools;
 use pwsp::{
     types::{
         audio_player::PlayerState,
         config::GuiConfig,
+        config::HotkeyConfig,
         gui::{AppState, AudioPlayerState},
         socket::Request,
     },
@@ -19,13 +21,15 @@ use pwsp::{
 };
 use rfd::FileDialog;
 use std::{
-    error::Error,
+    cmp::Ordering,
-    path::PathBuf,
+    fs,
+    path::{Path, PathBuf},
     sync::{Arc, Mutex},
 };
+use system_fonts::{FontStyle, FoundFontSource, find_for_locale};
 
-const SUPPORTED_EXTENSIONS: [&str; 11] = [
+const SUPPORTED_EXTENSIONS: [&str; 13] = [
-    "mp3", "wav", "ogg", "flac", "mp4", "m4a", "aac", "mov", "mkv", "webm", "avi",
+    "mp3", "wav", "ogg", "flac", "mp4", "m4a", "aac", "mov", "mkv", "mka", "webm", "avi", "opus",
 ];
 
 struct SoundpadGui {
@@ -52,13 +56,17 @@ impl SoundpadGui {
         };
 
         soundpad_gui.app_state.dirs = config.dirs;
+        soundpad_gui.app_state.hotkey_config = HotkeyConfig::load().unwrap_or_default();
 
         soundpad_gui
     }
 
     pub fn play_toggle(&mut self) {
         let (new_state, request) = {
-            let guard = self.audio_player_state_shared.lock().unwrap();
+            let guard = self
+                .audio_player_state_shared
+                .lock()
+                .unwrap_or_else(|e| e.into_inner());
             match guard.state {
                 PlayerState::Playing => (Some(PlayerState::Paused), Some(Request::pause(None))),
                 PlayerState::Paused => (Some(PlayerState::Playing), Some(Request::resume(None))),
@@ -71,7 +79,10 @@ impl SoundpadGui {
         }
 
         if let Some(state) = new_state {
-            let mut guard = self.audio_player_state_shared.lock().unwrap();
+            let mut guard = self
+                .audio_player_state_shared
+                .lock()
+                .unwrap_or_else(|e| e.into_inner());
             guard.new_state = Some(state.clone());
             guard.state = state;
         }
@@ -100,19 +111,19 @@ impl SoundpadGui {
         self.app_state.current_dir = Some(path.clone());
         match path.read_dir() {
             Ok(read_dir) => {
-                self.app_state.files = read_dir
+                self.app_state.listed_files = read_dir
                     .filter_map(|res| res.ok())
                     .map(|entry| entry.path())
                     .collect();
             }
             Err(e) => {
                 eprintln!("Failed to read directory {:?}: {}", path, e);
-                self.app_state.files.clear();
+                self.app_state.listed_files.clear();
             }
         }
     }
 
-    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));
     }
 
@@ -142,9 +153,23 @@ 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();
+        let mut files: Vec<PathBuf> = self.app_state.listed_files.iter().cloned().collect();
-        files.sort();
+        files.sort_by(|a, b| {
+            let a_is_dir = a.is_dir();
+            let b_is_dir = b.is_dir();
+            if a_is_dir && !b_is_dir {
+                Ordering::Less
+            } else if !a_is_dir && b_is_dir {
+                Ordering::Greater
+            } else {
+                a.cmp(b)
+            }
+        });
 
         let search_query = self.app_state.search_query.to_lowercase();
         let search_query = search_query.trim();
@@ -153,7 +178,7 @@ impl SoundpadGui {
             .into_iter()
             .filter(|entry_path| {
                 if entry_path.is_dir() {
-                    return false;
+                    return true;
                 }
 
                 if !SUPPORTED_EXTENSIONS.contains(
@@ -184,7 +209,52 @@ impl SoundpadGui {
     }
 }
 
-pub async fn run() -> Result<(), Box<dyn Error>> {
+fn add_font(font_name: &str, font_bytes: &[u8], fonts: &mut FontDefinitions) -> Result<()> {
+    let font_data = FontData::from_owned(font_bytes.to_vec()).tweak(FontTweak {
+        scale: 1.0,
+        hinting_override: Some(true),
+        ..Default::default()
+    });
+
+    fonts
+        .font_data
+        .insert(font_name.to_owned(), font_data.into());
+
+    fonts
+        .families
+        .entry(FontFamily::Proportional)
+        .or_default()
+        .insert(0, font_name.to_owned());
+    fonts
+        .families
+        .entry(FontFamily::Monospace)
+        .or_default()
+        .insert(0, font_name.to_owned());
+
+    Ok(())
+}
+
+fn load_system_fonts(fonts: &mut FontDefinitions) -> Result<()> {
+    let (_, en_sans) = find_for_locale("en", FontStyle::Sans);
+    let (_, en_serif) = find_for_locale("en", FontStyle::Serif);
+    let (_, ja_sans) = find_for_locale("ja", FontStyle::Sans);
+    let (_, ar_sans) = find_for_locale("ar", FontStyle::Sans);
+
+    let system_fonts = [en_sans, en_serif, ja_sans, ar_sans].concat();
+
+    for font in system_fonts.iter().rev() {
+        let font_bytes = match &font.source {
+            FoundFontSource::Path(path) => fs::read(path)?,
+            FoundFontSource::Bytes(bytes) => bytes.to_vec(),
+        };
+
+        add_font(&font.key, &font_bytes, fonts)?;
+    }
+
+    Ok(())
+}
+
+pub async fn run() -> Result<()> {
     const ICON: &[u8] = include_bytes!("../../assets/icon.png");
 
     let options = NativeOptions {
@@ -206,6 +276,11 @@ pub async fn run() -> Result<(), Box<dyn Error>> {
         options,
         Box::new(|cc| {
             egui_material_icons::initialize(&cc.egui_ctx);
+
+            let mut fonts = FontDefinitions::default();
+            load_system_fonts(&mut fonts).ok();
+            cc.egui_ctx.set_fonts(fonts);
+
             Ok(Box::new(SoundpadGui::new(&cc.egui_ctx)))
         }),
     ) {
@@ -216,6 +291,6 @@ pub async fn run() -> Result<(), Box<dyn Error>> {
             }
             Ok(())
         }
-        Err(e) => Err(e.into()),
+        Err(e) => Err(anyhow!(e.to_string())),
     }
 }

src/gui/update.rs

@@ -8,7 +8,7 @@ use pwsp::{
 use std::time::{Duration, Instant};
 
 impl App for SoundpadGui {
-    fn update(&mut self, ctx: &Context, _frame: &mut EFrame) {
+    fn logic(&mut self, ctx: &Context, _frame: &mut EFrame) {
         // Remove directories
         for path in self.app_state.dirs_to_remove.drain() {
             self.app_state.dirs.retain(|x| x != &path);
@@ -16,7 +16,7 @@ impl App for SoundpadGui {
                 && current_dir == &path
             {
                 self.app_state.current_dir = None;
-                self.app_state.files.clear();
+                self.app_state.listed_files.clear();
             }
         }
 
@@ -77,7 +77,13 @@ impl App for SoundpadGui {
 
         // Sync audio player state
         {
-            let guard = self.audio_player_state_shared.lock().unwrap();
+            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();
         }
 
@@ -94,23 +100,35 @@ impl App for SoundpadGui {
 
         // Handle input
         self.handle_input(ctx);
+    }
 
+    fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut EFrame) {
         // Draw UI
-        CentralPanel::default().show(ctx, |ui| {
+        CentralPanel::default().show_inside(ui, |ui| {
             if !self.audio_player_state.is_daemon_running {
                 self.draw_waiting_for_daemon(ui);
                 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
-        ctx.request_repaint_after_secs(1.0 / 60.0);
+        ui.request_repaint_after_secs(1.0 / 60.0);
     }
 }

src/main.rs

@@ -1,8 +1,14 @@
 mod gui;
 
-use std::error::Error;
+use anyhow::Result;
+use rust_i18n::i18n;
+
+i18n!("locales", fallback = "en");
 
 #[tokio::main]
-async fn main() -> Result<(), Box<dyn Error>> {
+async fn main() -> Result<()> {
+    let locale = sys_locale::get_locale().unwrap_or(String::from("en-US"));
+    rust_i18n::set_locale(&locale);
+
     gui::run().await
 }

src/types/audio_player.rs

@@ -2,9 +2,10 @@ 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 anyhow::{Result, anyhow};
 use rodio::{Decoder, DeviceSinkBuilder, MixerDeviceSink, Player, Source};
 use serde::{Deserialize, Serialize};
 use std::{
@@ -53,29 +54,29 @@ 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
 }
 
 impl AudioPlayer {
-    pub async fn new() -> Result<Self, Box<dyn Error>> {
+    pub async fn new() -> Result<Self> {
         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,19 +89,61 @@ impl AudioPlayer {
         Ok(audio_player)
     }
 
+    fn ensure_stream(&mut self) -> Result<&MixerDeviceSink> {
+        if self.stream_handle.is_none() {
+            let mut sink = DeviceSinkBuilder::open_default_sink()?;
+            sink.log_on_drop(false);
+            self.stream_handle = Some(sink);
+        }
+        self.stream_handle
+            .as_ref()
+            .ok_or_else(|| anyhow!("Failed to initialize stream_handle"))
+    }
+
+    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 {}) {
+            if sender.send(Terminate {}).is_ok() {
-                Ok(_) => {
+                println!("Sent terminate signal to input link thread");
-                    println!("Sent terminate signal to link thread");
+                self.input_link_sender = None;
-                    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"),
             }
         }
     }
 
-    async fn link_devices(&mut self) -> Result<(), Box<dyn Error>> {
+    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<()> {
+        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<()> {
         self.abort_link_thread();
 
         let input_device;
@@ -179,6 +222,9 @@ impl AudioPlayer {
         } else {
             self.tracks.clear();
         }
+        if self.tracks.is_empty() {
+            self.drop_stream();
+        }
     }
 
     pub fn is_paused(&self) -> bool {
@@ -211,12 +257,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)
         }
     }
 
@@ -246,7 +292,7 @@ impl AudioPlayer {
         0.0
     }
 
-    pub fn seek(&mut self, position: f32, id: Option<u32>) -> Result<(), Box<dyn Error>> {
+    pub fn seek(&mut self, position: f32, id: Option<u32>) -> Result<()> {
         let position = if position < 0.0 { 0.0 } else { position };
 
         if let Some(id) = id {
@@ -262,39 +308,49 @@ impl AudioPlayer {
         Ok(())
     }
 
-    pub fn get_duration(&mut self, id: Option<u32>) -> Result<f32, Box<dyn Error>> {
+    pub fn get_duration(&mut self, id: Option<u32>) -> Result<f32> {
         if let Some(id) = id {
             if let Some(sound) = self.tracks.get(&id) {
-                return sound.duration.ok_or("Unknown duration".into());
+                return sound.duration.ok_or(anyhow!("Unknown duration"));
             }
         } else if let Some(sound) = self.tracks.values().last() {
-            return sound.duration.ok_or("Unknown duration".into());
+            return sound.duration.ok_or(anyhow!("Unknown duration"));
         }
-        Err("No track playing".into())
+        Err(anyhow!("No track playing"))
     }
 
-    pub async fn play(
+    pub async fn play(&mut self, file_path: &Path, concurrent: bool) -> Result<u32> {
-        &mut self,
+        let path_buf = file_path.to_path_buf();
-        file_path: &Path,
-        concurrent: bool,
-    ) -> Result<u32, Box<dyn Error>> {
-        if !file_path.exists() {
-            return Err(format!("File does not exist: {}", file_path.display()).into());
-        }
 
-        let file = fs::File::open(file_path)?;
+        let decoder_result =
-        match Decoder::try_from(file) {
+            tokio::task::spawn_blocking(move || -> Result<_, Box<dyn Error + Send + Sync>> {
+                if !path_buf.exists() {
+                    return Err(format!("File does not exist: {}", path_buf.display()).into());
+                }
+
+                let file = fs::File::open(&path_buf)?;
+                let decoder = Decoder::try_from(file)
+                    .map_err(|e| Box::new(e) as Box<dyn Error + Send + Sync>)?;
+                Ok(decoder)
+            })
+            .await?;
+
+        match decoder_result {
             Ok(source) => {
                 if !concurrent {
                     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();
@@ -312,7 +368,7 @@ impl AudioPlayer {
 
                 Ok(id)
             }
-            Err(err) => Err(err.into()),
+            Err(err) => Err(anyhow!(err)),
         }
     }
 
@@ -348,20 +404,26 @@ impl AudioPlayer {
         tracks
     }
 
-    pub async fn update(&mut self) {
+    pub async fn update(&mut self, check_devices: bool) {
-        if let Some(input_device_name) = &self.input_device_name {
+        if check_devices {
-            // Unlink devices if selected input device was removed
+            if let Some(input_device_name) = &self.input_device_name {
-            if self.input_link_sender.is_some() && get_device(input_device_name).await.is_err() {
+                // Unlink devices if selected input device was removed
-                // 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",
+                    eprintln!(
-                    input_device_name
+                        "Selected input device {} was removed, unlinking devices",
-                );
+                        input_device_name
-                self.abort_link_thread();
+                    );
+                    self.abort_link_thread();
+                }
+                // Link devices if not linked
+                else if self.input_link_sender.is_none() {
+                    self.link_devices().await.ok();
+                }
             }
-            // Link devices if not linked
+
-            else if self.input_link_sender.is_none() {
+            if self.stream_handle.is_some() && self.player_link_sender.is_none() {
-                self.link_devices().await.ok();
+                self.link_player().await.ok();
             }
         }
 
@@ -374,26 +436,46 @@ impl AudioPlayer {
             }
         }
 
+        let mut restart_futures = vec![];
+
         for id in restarts {
-            if let Some(sound) = self.tracks.get_mut(&id) {
+            if let Some(sound) = self.tracks.get(&id) {
-                if let Ok(file) = fs::File::open(&sound.path) {
+                let path = sound.path.clone();
-                    if let Ok(source) = Decoder::try_from(file) {
+                let handle = tokio::task::spawn_blocking(move || {
-                        sound.sink.append(source);
+                    if let Ok(file) = fs::File::open(&path)
-                        sound.sink.play();
+                        && let Ok(source) = Decoder::try_from(file)
+                    {
+                        return Some((id, source));
                     }
-                }
+                    None
+                });
+                restart_futures.push(handle);
+            }
+        }
+
+        for handle in restart_futures {
+            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>> {
+    pub async fn set_current_input_device(&mut self, name: &str) -> Result<()> {
         let input_device = get_device(name).await?;
 
         if input_device.device_type != DeviceType::Input {
-            return Err("Selected device is not an input device".into());
+            return Err(anyhow!("Selected device is not an input device"));
         }
 
         self.input_device_name = Some(name.to_string());

src/types/commands.rs

@@ -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 {
@@ -107,7 +144,10 @@ impl Executable for KillCommand {
 #[async_trait]
 impl Executable for PauseCommand {
     async fn execute(&self) -> Response {
-        let mut audio_player = get_audio_player().await.lock().await;
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
         audio_player.pause(self.id);
         Response::new(true, "Audio was paused")
     }
@@ -116,7 +156,10 @@ impl Executable for PauseCommand {
 #[async_trait]
 impl Executable for ResumeCommand {
     async fn execute(&self) -> Response {
-        let mut audio_player = get_audio_player().await.lock().await;
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
         audio_player.resume(self.id);
         Response::new(true, "Audio was resumed")
     }
@@ -125,7 +168,10 @@ impl Executable for ResumeCommand {
 #[async_trait]
 impl Executable for TogglePauseCommand {
     async fn execute(&self) -> Response {
-        let mut audio_player = get_audio_player().await.lock().await;
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
 
         if audio_player.get_state() == PlayerState::Stopped {
             return Response::new(false, "Audio is not playing");
@@ -163,7 +209,10 @@ impl Executable for TogglePauseCommand {
 #[async_trait]
 impl Executable for StopCommand {
     async fn execute(&self) -> Response {
-        let mut audio_player = get_audio_player().await.lock().await;
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
         audio_player.stop(self.id);
         Response::new(true, "Audio was stopped")
     }
@@ -172,7 +221,10 @@ impl Executable for StopCommand {
 #[async_trait]
 impl Executable for IsPausedCommand {
     async fn execute(&self) -> Response {
-        let audio_player = get_audio_player().await.lock().await;
+        let audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
         let is_paused = audio_player.is_paused().to_string();
         Response::new(true, is_paused)
     }
@@ -181,7 +233,10 @@ impl Executable for IsPausedCommand {
 #[async_trait]
 impl Executable for GetStateCommand {
     async fn execute(&self) -> Response {
-        let audio_player = get_audio_player().await.lock().await;
+        let audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
         let state = audio_player.get_state();
         match serde_json::to_string(&state) {
             Ok(json) => Response::new(true, json),
@@ -193,11 +248,14 @@ impl Executable for GetStateCommand {
 #[async_trait]
 impl Executable for GetVolumeCommand {
     async fn execute(&self) -> Response {
-        let mut audio_player = get_audio_player().await.lock().await;
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
         let volume = audio_player.get_volume(self.id);
 
         if let Some(volume) = volume {
-        Response::new(true, volume.to_string())
+            Response::new(true, volume.to_string())
         } else {
             Response::new(false, "Failed to get volume")
         }
@@ -208,7 +266,10 @@ impl Executable for GetVolumeCommand {
 impl Executable for SetVolumeCommand {
     async fn execute(&self) -> Response {
         if let Some(volume) = self.volume {
-            let mut audio_player = get_audio_player().await.lock().await;
+            let mut audio_player = match get_audio_player().await {
+                Ok(player) => player.lock().await,
+                Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+            };
             audio_player.set_volume(volume, self.id);
             Response::new(true, format!("Audio volume was set to {}", volume))
         } else {
@@ -220,7 +281,10 @@ impl Executable for SetVolumeCommand {
 #[async_trait]
 impl Executable for GetPositionCommand {
     async fn execute(&self) -> Response {
-        let audio_player = get_audio_player().await.lock().await;
+        let audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
         let position = audio_player.get_position(self.id);
         Response::new(true, position.to_string())
     }
@@ -230,7 +294,10 @@ impl Executable for GetPositionCommand {
 impl Executable for SeekCommand {
     async fn execute(&self) -> Response {
         if let Some(position) = self.position {
-            let mut audio_player = get_audio_player().await.lock().await;
+            let mut audio_player = match get_audio_player().await {
+                Ok(player) => player.lock().await,
+                Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+            };
             match audio_player.seek(position, self.id) {
                 Ok(_) => Response::new(true, format!("Audio position was set to {}", position)),
                 Err(err) => Response::new(false, err.to_string()),
@@ -244,7 +311,10 @@ impl Executable for SeekCommand {
 #[async_trait]
 impl Executable for GetDurationCommand {
     async fn execute(&self) -> Response {
-        let mut audio_player = get_audio_player().await.lock().await;
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
         match audio_player.get_duration(self.id) {
             Ok(duration) => Response::new(true, duration.to_string()),
             Err(err) => Response::new(false, err.to_string()),
@@ -256,7 +326,10 @@ impl Executable for GetDurationCommand {
 impl Executable for PlayCommand {
     async fn execute(&self) -> Response {
         if let Some(file_path) = &self.file_path {
-            let mut audio_player = get_audio_player().await.lock().await;
+            let mut audio_player = match get_audio_player().await {
+                Ok(player) => player.lock().await,
+                Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+            };
             match audio_player
                 .play(file_path, self.concurrent.unwrap_or(false))
                 .await
@@ -273,7 +346,10 @@ impl Executable for PlayCommand {
 #[async_trait]
 impl Executable for GetTracksCommand {
     async fn execute(&self) -> Response {
-        let audio_player = get_audio_player().await.lock().await;
+        let audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
         let tracks = audio_player.get_tracks();
         match serde_json::to_string(&tracks) {
             Ok(json) => Response::new(true, json),
@@ -285,7 +361,10 @@ impl Executable for GetTracksCommand {
 #[async_trait]
 impl Executable for GetCurrentInputCommand {
     async fn execute(&self) -> Response {
-        let audio_player = get_audio_player().await.lock().await;
+        let audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
         if let Some(input_device_name) = &audio_player.input_device_name {
             if let Ok(input_device) = get_device(input_device_name).await {
                 Response::new(
@@ -327,7 +406,10 @@ impl Executable for GetAllInputsCommand {
 impl Executable for SetCurrentInputCommand {
     async fn execute(&self) -> Response {
         if let Some(name) = &self.name {
-            let mut audio_player = get_audio_player().await.lock().await;
+            let mut audio_player = match get_audio_player().await {
+                Ok(player) => player.lock().await,
+                Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+            };
             match audio_player.set_current_input_device(name).await {
                 Ok(_) => Response::new(true, "Input device was set"),
                 Err(err) => Response::new(false, err.to_string()),
@@ -341,7 +423,10 @@ impl Executable for SetCurrentInputCommand {
 #[async_trait]
 impl Executable for SetLoopCommand {
     async fn execute(&self) -> Response {
-        let mut audio_player = get_audio_player().await.lock().await;
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
 
         match self.enabled {
             Some(enabled) => {
@@ -356,7 +441,10 @@ impl Executable for SetLoopCommand {
 #[async_trait]
 impl Executable for ToggleLoopCommand {
     async fn execute(&self) -> Response {
-        let mut audio_player = get_audio_player().await.lock().await;
+        let mut audio_player = match get_audio_player().await {
+            Ok(player) => player.lock().await,
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
+        };
         if let Some(id) = self.id {
             if let Some(track) = audio_player.tracks.get_mut(&id) {
                 track.looped = !track.looped;
@@ -391,20 +479,29 @@ impl Executable for GetFullStateCommand {
         let mut all_inputs = HashMap::new();
         let mut current_input_nick = String::new();
 
-        let audio_player = get_audio_player().await.lock().await;
+        let audio_player = match get_audio_player().await {
-        let current_input_name = audio_player.input_device_name.as_deref();
+            Ok(player) => player.lock().await,
-        for device in input_devices {
+            Err(err) => return Response::new(false, format!("Audio player error: {}", err)),
-            if device.name == "pwsp-virtual-mic" {
+        };
-                continue;
+        if let Some(current_input_name) = &audio_player.input_device_name {
-            }
+            for device in input_devices {
-
+                if device.name == "pwsp-virtual-mic" {
-            if let Some(name) = current_input_name {
+                    continue;
-                if device.name == name {
+                }
+                if device.name == *current_input_name {
                     current_input_nick = format!("{} - {}", device.name, device.nick);
                 }
-            }
 
-            all_inputs.insert(device.name, device.nick);
+                all_inputs.insert(device.name, device.nick);
+            }
+        } else {
+            for device in input_devices {
+                if device.name == "pwsp-virtual-mic" {
+                    continue;
+                }
+
+                all_inputs.insert(device.name, device.nick);
+            }
         }
 
         let full_state = FullState {
@@ -421,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)),
+        }
+    }
+}

src/types/config.rs

@@ -1,6 +1,7 @@
-use crate::utils::config::get_config_path;
+use crate::{types::socket::Request, utils::config::get_config_path};
+use anyhow::Result;
 use serde::{Deserialize, Serialize};
-use std::{error::Error, fs, path::PathBuf};
+use std::{collections::HashMap, fs, path::PathBuf};
 
 #[derive(Default, Clone, Serialize, Deserialize)]
 #[serde(default)]
@@ -10,11 +11,12 @@ pub struct DaemonConfig {
 }
 
 impl DaemonConfig {
-    pub fn save_to_file(&self) -> Result<(), Box<dyn Error>> {
+    pub fn save_to_file(&self) -> Result<()> {
         let config_path = get_config_path()?.join("daemon.json");
-        let config_dir = config_path.parent().unwrap();
 
-        if !config_path.exists() {
+        if let Some(config_dir) = config_path.parent()
+            && !config_path.exists()
+        {
             fs::create_dir_all(config_dir)?;
         }
 
@@ -23,10 +25,13 @@ impl DaemonConfig {
         Ok(())
     }
 
-    pub fn load_from_file() -> Result<DaemonConfig, Box<dyn Error>> {
+    pub fn load_from_file() -> Result<DaemonConfig> {
         let config_path = get_config_path()?.join("daemon.json");
         let bytes = fs::read(config_path)?;
-        Ok(serde_json::from_slice::<DaemonConfig>(&bytes)?)
+        match serde_json::from_slice::<DaemonConfig>(&bytes) {
+            Ok(config) => Ok(config),
+            Err(_) => Ok(DaemonConfig::default()),
+        }
     }
 }
 
@@ -61,11 +66,12 @@ impl Default for GuiConfig {
 }
 
 impl GuiConfig {
-    pub fn save_to_file(&mut self) -> Result<(), Box<dyn Error>> {
+    pub fn save_to_file(&mut self) -> Result<()> {
         let config_path = get_config_path()?.join("gui.json");
-        let config_dir = config_path.parent().unwrap();
 
-        if !config_path.exists() {
+        if let Some(config_dir) = config_path.parent()
+            && !config_path.exists()
+        {
             fs::create_dir_all(config_dir)?;
         }
 
@@ -79,9 +85,122 @@ impl GuiConfig {
         Ok(())
     }
 
-    pub fn load_from_file() -> Result<GuiConfig, Box<dyn Error>> {
+    pub fn load_from_file() -> Result<GuiConfig> {
         let config_path = get_config_path()?.join("gui.json");
         let bytes = fs::read(config_path)?;
-        Ok(serde_json::from_slice::<GuiConfig>(&bytes)?)
+        match serde_json::from_slice::<GuiConfig>(&bytes) {
+            Ok(config) => Ok(config),
+            Err(_) => Ok(GuiConfig::default()),
+        }
+    }
+}
+
+#[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> {
+        Ok(get_config_path()?.join("hotkeys.json"))
+    }
+
+    pub fn load() -> Result<HotkeyConfig> {
+        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<()> {
+        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()
     }
 }

src/types/gui.rs

@@ -1,4 +1,7 @@
-use crate::types::audio_player::{PlayerState, TrackInfo};
+use crate::types::{
+    audio_player::{PlayerState, TrackInfo},
+    config::HotkeyConfig,
+};
 
 use egui::Id;
 
@@ -40,8 +43,18 @@ pub struct AppState {
     pub dirs: Vec<PathBuf>,
     pub dirs_to_remove: HashSet<PathBuf>,
 
-    pub selected_file: Option<PathBuf>,
+    pub listed_files: HashSet<PathBuf>,
-    pub files: HashSet<PathBuf>,
+    pub listed_dirs: HashSet<PathBuf>,
+    pub dir_cache: HashMap<PathBuf, Vec<PathBuf>>,
+
+    pub show_hotkeys: bool,
+    pub hotkey_capture_active: bool,
+
+    pub hotkey_config: HotkeyConfig,
+    pub hotkey_search_query: String,
+
+    pub assigning_hotkey_slot: Option<String>,
+    pub assigning_hotkey_for_file: Option<PathBuf>,
 }
 
 #[derive(Default, Debug, Clone)]
@@ -55,6 +68,9 @@ pub struct AudioPlayerState {
 
     pub current_input: String,
     pub all_inputs: HashMap<String, String>,
+    pub all_inputs_sorted: Vec<(String, String)>,
 
     pub is_daemon_running: bool,
+
+    pub hotkey_config: Option<HotkeyConfig>,
 }

src/types/socket.rs

@@ -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)]

src/utils/commands.rs

@@ -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());
+    }
+}

src/utils/config.rs

@@ -1,6 +1,7 @@
-use std::{error::Error, path::PathBuf};
+use anyhow::Result;
+use std::path::PathBuf;
 
-pub fn get_config_path() -> Result<PathBuf, Box<dyn Error>> {
+pub fn get_config_path() -> Result<PathBuf> {
     let config_path = dirs::config_dir().expect("Failed to obtain config dir");
     Ok(config_path.join("pwsp"))
 }

src/utils/daemon.rs

@@ -1,11 +1,11 @@
-use crate::{
+use crate::types::{
-    types::{
+    audio_player::AudioPlayer,
-        audio_player::AudioPlayer,
+    config::DaemonConfig,
-        config::DaemonConfig,
+    socket::{MAX_MESSAGE_SIZE, Request, Response},
-        socket::{Request, Response},
-    },
-    utils::pipewire::{create_link, get_device},
 };
+
+use anyhow::Result;
+use std::os::unix::fs::PermissionsExt;
 use std::path::PathBuf;
 use std::{error::Error, fs};
 use tokio::{
@@ -17,11 +17,14 @@ use tokio::{
 
 static AUDIO_PLAYER: OnceCell<Mutex<AudioPlayer>> = OnceCell::const_new();
 
-pub async fn get_audio_player() -> &'static Mutex<AudioPlayer> {
+pub async fn get_audio_player() -> Result<&'static Mutex<AudioPlayer>, String> {
     AUDIO_PLAYER
-        .get_or_init(|| async {
+        .get_or_try_init(|| async {
             println!("Initializing audio player");
-            Mutex::new(AudioPlayer::new().await.unwrap())
+            match AudioPlayer::new().await {
+                Ok(player) => Ok(Mutex::new(player)),
+                Err(err) => Err(err.to_string()),
+            }
         })
         .await
 }
@@ -34,58 +37,21 @@ 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"))
 }
 
-pub fn create_runtime_dir() -> Result<(), Box<dyn Error>> {
+pub fn create_runtime_dir() -> Result<()> {
     let runtime_dir = get_runtime_dir();
     if !runtime_dir.exists() {
         fs::create_dir_all(&runtime_dir)?;
     }
+    fs::set_permissions(&runtime_dir, fs::Permissions::from_mode(0o700))?;
 
     Ok(())
 }
 
-pub fn is_daemon_running() -> Result<bool, Box<dyn Error>> {
+pub fn is_daemon_running() -> Result<bool> {
     let lock_file = fs::File::create(get_runtime_dir().join("daemon.lock"))?;
     match lock_file.try_lock() {
         Ok(_) => Ok(false),
@@ -93,7 +59,7 @@ pub fn is_daemon_running() -> Result<bool, Box<dyn Error>> {
     }
 }
 
-pub async fn wait_for_daemon() -> Result<(), Box<dyn Error>> {
+pub async fn wait_for_daemon() -> Result<()> {
     if is_daemon_running()? {
         return Ok(());
     }
@@ -130,6 +96,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());

src/utils/global_hotkeys.rs

@@ -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);
+            }
+        }
+    }
+}

src/utils/gui.rs

@@ -1,15 +1,16 @@
 use crate::{
     types::{
         audio_player::FullState,
-        config::GuiConfig,
+        config::{GuiConfig, HotkeyConfig},
         gui::AudioPlayerState,
         socket::{Request, Response},
     },
     utils::daemon::{is_daemon_running, make_request},
 };
+use anyhow::{Result, anyhow};
 use std::{
-    error::Error,
     sync::{Arc, Mutex},
+    time::Instant,
 };
 use tokio::time::{Duration, sleep};
 
@@ -21,11 +22,11 @@ pub fn get_gui_config() -> GuiConfig {
     })
 }
 
-pub fn make_request_sync(request: Request) -> Result<Response, Box<dyn Error>> {
+pub fn make_request_sync(request: Request) -> Result<Response> {
     tokio::task::block_in_place(|| {
         tokio::runtime::Handle::current()
             .block_on(make_request(request))
-            .map_err(|e| e as Box<dyn Error>)
+            .map_err(|e| anyhow!(e))
     })
 }
 
@@ -49,13 +50,16 @@ 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);
 
             if !is_running {
                 {
-                    let mut guard = audio_player_state_shared.lock().unwrap();
+                    let mut guard = audio_player_state_shared
+                        .lock()
+                        .unwrap_or_else(|e| e.into_inner());
                     guard.is_daemon_running = false;
                 }
                 sleep(Duration::from_millis(500)).await;
@@ -69,7 +73,9 @@ pub fn start_app_state_thread(audio_player_state_shared: Arc<Mutex<AudioPlayerSt
                 let full_state: FullState =
                     serde_json::from_str(&full_state_res.message).unwrap_or_default();
 
-                let mut guard = audio_player_state_shared.lock().unwrap();
+                let mut guard = audio_player_state_shared
+                    .lock()
+                    .unwrap_or_else(|e| e.into_inner());
 
                 guard.state = match guard.new_state.clone() {
                     Some(new_state) => {
@@ -86,10 +92,37 @@ pub fn start_app_state_thread(audio_player_state_shared: Arc<Mutex<AudioPlayerSt
                     .next()
                     .unwrap_or_default()
                     .to_string();
-                guard.all_inputs = full_state.all_inputs;
+
+                if guard.all_inputs != full_state.all_inputs {
+                    guard.all_inputs = full_state.all_inputs;
+                    let mut sorted: Vec<(String, String)> = guard
+                        .all_inputs
+                        .iter()
+                        .map(|(k, v)| (k.clone(), v.clone()))
+                        .collect();
+                    sorted.sort_by(|a, b| a.0.cmp(&b.0));
+                    guard.all_inputs_sorted = sorted;
+                }
+
                 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;
         }
     });

src/utils/mod.rs

@@ -1,5 +1,6 @@
 pub mod commands;
 pub mod config;
 pub mod daemon;
+pub mod global_hotkeys;
 pub mod gui;
 pub mod pipewire;

src/utils/pipewire.rs

@@ -1,14 +1,22 @@
 use crate::types::pipewire::{AudioDevice, DeviceType, Port, Terminate};
+use anyhow::{Result, anyhow};
 use pipewire::{
     context::ContextRc, link::Link, main_loop::MainLoopRc, properties::properties,
     registry::GlobalObject, spa::utils::dict::DictRef,
 };
-use std::{collections::HashMap, error::Error, thread};
+use std::{collections::HashMap, thread};
 use tokio::{
     sync::mpsc,
     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,11 +64,13 @@ fn parse_global_object(
                 (None, None)
             };
             // Check if the object is a port
-        } else if props.get("port.direction").is_some() {
+        } else if props.get("port.direction").is_some()
-            let node_id = props.get("node.id").unwrap().parse::<u32>().unwrap();
+            && let (Some(node_id), Some(port_id), Some(port_name)) = (
-            let port_id = props.get("port.id").unwrap().parse::<u32>().unwrap();
+                props.get("node.id").and_then(|id| id.parse::<u32>().ok()),
-            let port_name = props.get("port.name").unwrap();
+                props.get("port.id").and_then(|id| id.parse::<u32>().ok()),
-
+                props.get("port.name"),
+            )
+        {
             let port = Port {
                 node_id,
                 port_id,
@@ -76,10 +86,15 @@ fn parse_global_object(
 async fn pw_get_global_objects_thread(
     main_sender: mpsc::Sender<(Option<AudioDevice>, Option<Port>)>,
     pw_receiver: pipewire::channel::Receiver<Terminate>,
+    init_sender: std::sync::mpsc::SyncSender<Result<(), String>>,
 ) {
-    pipewire::init();
+    let (main_loop, context) = match setup_pipewire_context() {
-
+        Ok(res) => res,
-    let main_loop = MainLoopRc::new(None).expect("Failed to initialize pipewire main loop");
+        Err(e) => {
+            let _ = init_sender.send(Err(e));
+            return;
+        }
+    };
 
     // Stop main loop on Terminate message
     let _receiver = pw_receiver.attach(main_loop.loop_(), {
@@ -87,13 +102,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 = match context.connect(None) {
-    let core = context
+        Ok(core) => core,
-        .connect(None)
+        Err(e) => {
-        .expect("Failed to connect to pipewire context");
+            let _ = init_sender.send(Err(format!("Failed to connect to pipewire context: {}", e)));
-    let registry = core
+            return;
-        .get_registry()
+        }
-        .expect("Failed to get registry from pipewire context");
+    };
+
+    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()
@@ -109,17 +135,29 @@ async fn pw_get_global_objects_thread(
         })
         .register();
 
+    // Signal successful initialization
+    if init_sender.send(Ok(())).is_err() {
+        return;
+    }
+
     main_loop.run();
 }
 
-pub async fn get_all_devices() -> Result<(Vec<AudioDevice>, Vec<AudioDevice>), Box<dyn Error>> {
+pub async fn get_all_devices() -> Result<(Vec<AudioDevice>, Vec<AudioDevice>)> {
     // Channels to communicate with pipewire thread
     let (main_sender, mut main_receiver) = mpsc::channel(10);
     let (pw_sender, pw_receiver) = pipewire::channel::channel();
+    let (init_sender, init_receiver) = std::sync::mpsc::sync_channel(0);
 
     // Spawn pipewire thread in background
-    let _pw_thread =
+    let _pw_thread = tokio::spawn(async move {
-        tokio::spawn(async move { pw_get_global_objects_thread(main_sender, pw_receiver).await });
+        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(anyhow!(e));
+    }
 
     let mut input_devices: HashMap<u32, AudioDevice> = HashMap::new();
     let mut output_devices: HashMap<u32, AudioDevice> = HashMap::new();
@@ -144,15 +182,12 @@ 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
+                let _ = pw_sender.send(Terminate {});
-                    .send(Terminate {})
-                    .expect("Failed to terminate pipewire thread");
 
                 for port in ports {
                     let node_id = port.node_id;
 
-                    if input_devices.contains_key(&node_id) {
+                    if let Some(input_device) = input_devices.get_mut(&node_id) {
-                        let input_device = input_devices.get_mut(&node_id).unwrap();
                         match port.name.as_str() {
                             "input_FL" => input_device.input_fl = Some(port),
                             "input_FR" => input_device.input_fr = Some(port),
@@ -170,8 +205,7 @@ pub async fn get_all_devices() -> Result<(Vec<AudioDevice>, Vec<AudioDevice>), B
                             }
                             _ => {}
                         }
-                    } else if output_devices.contains_key(&node_id) {
+                    } else if let Some(output_device) = output_devices.get_mut(&node_id) {
-                        let output_device = output_devices.get_mut(&node_id).unwrap();
                         match port.name.as_str() {
                             "input_FL" => output_device.input_fl = Some(port),
                             "input_FR" => output_device.input_fr = Some(port),
@@ -196,8 +230,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));
+                input_devices.sort_by_key(|a| a.id);
-                output_devices.sort_by(|a, b| a.id.cmp(&b.id));
+                output_devices.sort_by_key(|a| a.id);
 
                 return Ok((input_devices, output_devices));
             }
@@ -205,34 +239,41 @@ pub async fn get_all_devices() -> Result<(Vec<AudioDevice>, Vec<AudioDevice>), B
     }
 }
 
-pub async fn get_device(device_name: &str) -> Result<AudioDevice, Box<dyn Error>> {
+pub async fn get_device(device_name: &str) -> Result<AudioDevice> {
-    let (mut input_devices, output_devices) = get_all_devices().await?;
+    let (input_devices, output_devices) = get_all_devices().await?;
-    input_devices.extend(output_devices);
 
-    for device in input_devices {
+    input_devices
-        if device.name == device_name
+        .into_iter()
-            || device.nick == device_name
+        .chain(output_devices)
-            || device.name.contains(device_name)
+        .find(|device| {
-            || device.nick.contains(device_name)
+            device.name == device_name
-        {
+                || device.nick == device_name
-            return Ok(device);
+                || device.name.contains(device_name)
-        }
+                || device.nick.contains(device_name)
-    }
+        })
-
+        .ok_or_else(|| anyhow!("Device not found"))
-    Err("Device not found".into())
 }
 
-pub fn create_virtual_mic() -> Result<pipewire::channel::Sender<Terminate>, Box<dyn Error>> {
+pub fn create_virtual_mic() -> Result<pipewire::channel::Sender<Terminate>> {
     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, context) = match setup_pipewire_context() {
-
+            Ok(res) => res,
-        let main_loop = MainLoopRc::new(None).expect("Failed to initialize pipewire main loop");
+            Err(e) => {
-        let context = ContextRc::new(&main_loop, None).expect("Failed to create pipewire context");
+                let _ = init_sender.send(Err(e));
-        let core = context
+                return;
-            .connect(None)
+            }
-            .expect("Failed to connect to 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 props = properties!(
             "factory.name" => "support.null-audio-sink",
@@ -244,9 +285,13 @@ pub fn create_virtual_mic() -> Result<pipewire::channel::Sender<Terminate>, Box<
             "object.linger" => "false", // Destroy the node on app exit
         );
 
-        let _node = core
+        let _node = match core.create_object::<pipewire::node::Node>("adapter", &props) {
-            .create_object::<pipewire::node::Node>("adapter", &props)
+            Ok(node) => node,
-            .expect("Failed to create virtual mic");
+            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();
@@ -254,28 +299,83 @@ 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(anyhow!(e));
+    }
+
     Ok(pw_sender)
 }
 
+pub async fn link_player_to_virtual_mic() -> Result<pipewire::channel::Sender<Terminate>> {
+    let pwsp_daemon_output = match get_device("pwsp-daemon").await {
+        Ok(device) => device,
+        Err(_) => {
+            return Err(anyhow!(
+                "Could not find alsa_playback.pwsp-daemon device, skipping device linking"
+            ));
+        }
+    };
+
+    let pwsp_daemon_input = match get_device("pwsp-virtual-mic").await {
+        Ok(device) => device,
+        Err(_) => {
+            return Err(anyhow!(
+                "Could not find pwsp-virtual-mic device, skipping device linking"
+            ));
+        }
+    };
+
+    let output_fl = match pwsp_daemon_output.output_fl {
+        Some(port) => port,
+        None => return Err(anyhow!("Failed to get pwsp-daemon output_fl")),
+    };
+    let output_fr = match pwsp_daemon_output.output_fr {
+        Some(port) => port,
+        None => return Err(anyhow!("Failed to get pwsp-daemon output_fr")),
+    };
+    let input_fl = match pwsp_daemon_input.input_fl {
+        Some(port) => port,
+        None => return Err(anyhow!("Failed to get pwsp-virtual-mic input_fl")),
+    };
+    let input_fr = match pwsp_daemon_input.input_fr {
+        Some(port) => port,
+        None => return Err(anyhow!("Failed to get pwsp-virtual-mic input_fr")),
+    };
+
+    create_link(output_fl, output_fr, input_fl, input_fr)
+}
+
 pub fn create_link(
     output_fl: Port,
     output_fr: Port,
     input_fl: Port,
     input_fr: Port,
-) -> Result<pipewire::channel::Sender<Terminate>, Box<dyn Error>> {
+) -> Result<pipewire::channel::Sender<Terminate>> {
     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, context) = match setup_pipewire_context() {
-
+            Ok(res) => res,
-        let main_loop = MainLoopRc::new(None).expect("Failed to initialize pipewire main loop");
+            Err(e) => {
-        let context = ContextRc::new(&main_loop, None).expect("Failed to create pipewire context");
+                let _ = init_sender.send(Err(e));
-        let core = context
+                return;
-            .connect(None)
+            }
-            .expect("Failed to connect to 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 props_fl = properties! {
             "link.output.node" => format!("{}", output_fl.node_id).as_str(),
@@ -290,12 +390,20 @@ pub fn create_link(
             "link.input.port"  => format!("{}", input_fr.port_id).as_str(),
         };
 
-        let _link_fl = core
+        let _link_fl = match core.create_object::<Link>("link-factory", &props_fl) {
-            .create_object::<Link>("link-factory", &props_fl)
+            Ok(link) => link,
-            .expect("Failed to create link FL");
+            Err(e) => {
-        let _link_fr = core
+                let _ = init_sender.send(Err(format!("Failed to create link FL: {}", e)));
-            .create_object::<Link>("link-factory", &props_fr)
+                return;
-            .expect("Failed to create link FR");
+            }
+        };
+        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();
@@ -306,8 +414,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(anyhow!(e));
+    }
+
     Ok(pw_sender)
 }