diff --git a/scripts/hearing-aid.py b/scripts/hearing-aid.py
new file mode 100644
index 00000000..82cd91ec
--- /dev/null
+++ b/scripts/hearing-aid.py
@@ -0,0 +1,1094 @@
+#!/usr/bin/env python3
+
+# Needs https://github.com/google/bumble on Windows
+# See https://github.com/google/bumble/blob/main/docs/mkdocs/src/platforms/windows.md for usage.
+# You need to associate WinUSB with your Bluetooth interface. Once done, you can roll back to the original driver from Device Manager.
+
+import asyncio
+import argparse
+import logging
+import signal
+import struct
+import sys
+import threading
+import platform
+from queue import Queue
+from typing import Any, Callable, Dict, List, Optional
+
+from PyQt5.QtGui import QDoubleValidator
+from colorama import Fore, Style, init as colorama_init
+colorama_init(autoreset=True)
+
+from PyQt5.QtWidgets import (
+    QApplication, QWidget, QVBoxLayout, QLabel, QSlider,
+    QCheckBox, QPushButton, QLineEdit, QGridLayout, QComboBox
+)
+from PyQt5.QtCore import Qt, QTimer, pyqtSignal, QObject
+
+handler = logging.StreamHandler()
+class ColorFormatter(logging.Formatter):
+    COLORS = {
+        logging.DEBUG: Fore.BLUE,
+        logging.INFO: Fore.GREEN,
+        logging.WARNING: Fore.YELLOW,
+        logging.ERROR: Fore.RED,
+        logging.CRITICAL: Fore.MAGENTA,
+    }
+    def format(self, record):
+        color = self.COLORS.get(record.levelno, "")
+        prefix = f"{color}[{record.levelname}:{record.name}]{Style.RESET_ALL}"
+        return f"{prefix} {record.getMessage()}"
+
+handler.setFormatter(ColorFormatter())
+logging.basicConfig(level=logging.INFO, handlers=[handler])
+logger = logging.getLogger("hearing-aid")
+
+OPCODE_READ_REQUEST: int = 0x0A
+OPCODE_READ_RESPONSE: int = 0x0B
+OPCODE_WRITE_REQUEST: int = 0x12
+OPCODE_WRITE_RESPONSE: int = 0x13
+OPCODE_HANDLE_VALUE_NTF: int = 0x1B
+
+ATT_HANDLES: Dict[str, int] = {
+    'LOUD_SOUND_REDUCTION': 0x1B,
+    'HEARING_AID': 0x2A,
+}
+
+ATT_CCCD_HANDLES: Dict[str, int] = {
+    'LOUD_SOUND_REDUCTION': ATT_HANDLES['LOUD_SOUND_REDUCTION'] + 1,
+    'HEARING_AID': ATT_HANDLES['HEARING_AID'] + 1,
+}
+
+AACP_HEADER = bytes([0x04, 0x00, 0x04, 0x00])
+AACP_HANDSHAKE = bytes([0x00, 0x00, 0x04, 0x00, 0x01, 0x00, 0x02, 0x00,
+                        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+
+class AACPOpcodes:
+    SET_FEATURE_FLAGS = 0x4D
+    REQUEST_NOTIFICATIONS = 0x0F
+    CONTROL_COMMAND = 0x09
+
+class ControlCommandId:
+    HEARING_AID = 0x2C
+    HPS_GAIN_SWIPE = 0x2F
+    HEARING_ASSIST_CONFIG = 0x33
+    LISTENING_MODE = 0x0D
+    OWNS_CONNECTION = 0x06
+
+
+class BluezChannel:
+    def __init__(self, socket, loop):
+        self.socket = socket
+        self.loop = loop
+        self.sink = None
+        self._running = True
+        self._thread = threading.Thread(target=self._read_loop, daemon=True)
+        self._thread.start()
+
+    def send_pdu(self, pdu):
+        try:
+            logger.debug(f"Sending PDU: {pdu.hex() if pdu else 'None'}")
+            self.socket.send(pdu)
+        except OSError as e:
+            logger.error(f"Socket send error: {e}")
+
+    def _read_loop(self):
+        while self._running:
+            try:
+                data = self.socket.recv(2048)
+                logger.debug(f"Received PDU: {data.hex() if data else 'None'}")
+                if not data:
+                    break
+                if self.sink:
+                    self.loop.call_soon_threadsafe(self.sink, data)
+            except OSError:
+                break
+
+    def stop(self):
+        self._running = False
+        try:
+            self.socket.close()
+        except:
+            pass
+
+
+def _make_reader(ch):
+    recv_q: asyncio.Queue = asyncio.Queue()
+
+    def _sink(sdu):
+        try:
+            recv_q.put_nowait(sdu)
+        except Exception:
+            logger.debug("Dropping SDU in sink fallback")
+
+    try:
+        ch.sink = _sink
+    except Exception:
+        logger.debug("Failed to set channel.sink fallback")
+
+    async def _reader_from_sink():
+        item = await recv_q.get()
+        return item
+
+    return _reader_from_sink
+
+
+class HearingAidSettings:
+    def __init__(self, left_eq: List[float], right_eq: List[float], left_amp: float, right_amp: float,
+                 left_tone: float, right_tone: float, left_conv: bool, right_conv: bool,
+                 left_anr: float, right_anr: float, net_amp: float, balance: float, own_voice: float) -> None:
+        self.left_eq = left_eq
+        self.right_eq = right_eq
+        self.left_amplification = left_amp
+        self.right_amplification = right_amp
+        self.left_tone = left_tone
+        self.right_tone = right_tone
+        self.left_conversation_boost = left_conv
+        self.right_conversation_boost = right_conv
+        self.left_ambient_noise_reduction = left_anr
+        self.right_ambient_noise_reduction = right_anr
+        self.net_amplification = net_amp
+        self.balance = balance
+        self.own_voice_amplification = own_voice
+
+
+def parse_hearing_aid_settings(data: bytes) -> Optional[HearingAidSettings]:
+    if len(data) < 104:
+        logger.warning("Data too short for parsing")
+        return None
+    buffer = data
+    offset = 4
+
+    left_eq = []
+    for _ in range(8):
+        val, = struct.unpack('<f', buffer[offset:offset+4])
+        left_eq.append(val)
+        offset += 4
+
+    left_amp, = struct.unpack('<f', buffer[offset:offset+4])
+    offset += 4
+    left_tone, = struct.unpack('<f', buffer[offset:offset+4])
+    offset += 4
+    left_conv_float, = struct.unpack('<f', buffer[offset:offset+4])
+    left_conv = left_conv_float > 0.5
+    offset += 4
+    left_anr, = struct.unpack('<f', buffer[offset:offset+4])
+    offset += 4
+
+    right_eq = []
+    for _ in range(8):
+        val, = struct.unpack('<f', buffer[offset:offset+4])
+        right_eq.append(val)
+        offset += 4
+
+    right_amp, = struct.unpack('<f', buffer[offset:offset+4])
+    offset += 4
+    right_tone, = struct.unpack('<f', buffer[offset:offset+4])
+    offset += 4
+    right_conv_float, = struct.unpack('<f', buffer[offset:offset+4])
+    right_conv = right_conv_float > 0.5
+    offset += 4
+    right_anr, = struct.unpack('<f', buffer[offset:offset+4])
+    offset += 4
+
+    own_voice, = struct.unpack('<f', buffer[offset:offset+4])
+
+    avg = (left_amp + right_amp) / 2
+    amplification = max(-1, min(1, avg))
+    diff = right_amp - left_amp
+    balance = max(-1, min(1, diff))
+
+    return HearingAidSettings(left_eq, right_eq, left_amp, right_amp, left_tone, right_tone,
+                              left_conv, right_conv, left_anr, right_anr, amplification, balance, own_voice)
+
+class AACPManager:
+    def __init__(self):
+        self.channel = None
+        self.running = False
+        self._recv_q = asyncio.Queue()
+        self.control_cmd_listeners: Dict[int, List[Callable[[bytes], None]]] = {}
+
+    def set_channel(self, channel):
+        self.channel = channel
+
+        def _sink(pdu):
+            try:
+                self._recv_q.put_nowait(pdu)
+            except Exception:
+                logger.debug("Dropping SDU")
+
+        channel.sink = _sink
+        self.running = True
+
+    def register_control_cmd_listener(self, cmd_id: int, listener: Callable[[bytes], None]):
+        if cmd_id not in self.control_cmd_listeners:
+            self.control_cmd_listeners[cmd_id] = []
+        self.control_cmd_listeners[cmd_id].append(listener)
+
+    async def send_handshake(self):
+        self.channel.send_pdu(AACP_HANDSHAKE)
+        logger.info("AACP handshake sent")
+
+    async def send_notification_request(self):
+        pdu = (
+            AACP_HEADER
+            + bytes([AACPOpcodes.REQUEST_NOTIFICATIONS, 0x00, 0xFF, 0xFF, 0xFF, 0xFF])
+        )
+        self.channel.send_pdu(pdu)
+        logger.info("AACP notification request sent")
+
+    async def send_set_feature_flags(self):
+        pdu = (
+            AACP_HEADER
+            + bytes([
+                AACPOpcodes.SET_FEATURE_FLAGS, 0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
+        )
+        self.channel.send_pdu(pdu)
+        logger.info("AACP set feature flags sent")
+
+    async def send_control_command(self, cmd_id: int, value: bytes):
+        padded = (value + bytes(4))[:4]
+        pdu = AACP_HEADER + bytes([AACPOpcodes.CONTROL_COMMAND, 0x00, cmd_id]) + padded
+        self.channel.send_pdu(pdu)
+        logger.info(f"AACP control command {cmd_id:#04x} sent: {value.hex()}")
+
+    async def listen(self):
+        logger.info("AACP listener started")
+        while self.running:
+            try:
+                pdu = await self._recv_q.get()
+                if not isinstance(pdu, (bytes, bytearray)):
+                    pdu = bytes(pdu)
+                self._handle_packet(pdu)
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.debug(f"AACP listen error: {e}")
+                break
+        logger.info("AACP listener stopped")
+
+    def _handle_packet(self, pdu: bytes):
+        if len(pdu) < 5 or pdu[:4] != AACP_HEADER:
+            return
+
+        opcode = pdu[4]
+        payload = pdu[4:]
+
+        if opcode == AACPOpcodes.CONTROL_COMMAND:
+            if len(payload) < 7:
+                return
+            cmd_id = payload[2]
+            value = payload[3:7]
+            value = value.rstrip(b'\x00') or bytes([0])
+
+            logger.info(f"AACP control command received: {cmd_id:#04x} = {value.hex()}")
+
+            if cmd_id in self.control_cmd_listeners:
+                for listener in self.control_cmd_listeners[cmd_id]:
+                    listener(value)
+
+    def stop(self):
+        self.running = False
+
+
+class ATTManager:
+    def __init__(self):
+        self.channel = None
+        self.responses: Queue = Queue()
+        self.listeners: Dict[int, List[Any]] = {}
+        self.running = False
+        self._recv_q = asyncio.Queue()
+
+    def set_channel(self, channel):
+        self.channel = channel
+
+        def _sink(pdu):
+            try:
+                self._recv_q.put_nowait(pdu)
+            except Exception:
+                logger.debug("Dropping ATT PDU")
+
+        channel.sink = _sink
+        self.running = True
+
+    def register_listener(self, handle: int, listener: Any) -> None:
+        if handle not in self.listeners:
+            self.listeners[handle] = []
+        self.listeners[handle].append(listener)
+
+    async def enable_notifications(self, handle_name: str) -> None:
+        await self.write_cccd(handle_name, b'\x01\x00')
+        logger.info(f"Enabled notifications for handle {handle_name}")
+
+    async def read(self, handle_name: str) -> bytes:
+        handle_value = ATT_HANDLES[handle_name]
+        lsb = handle_value & 0xFF
+        msb = (handle_value >> 8) & 0xFF
+        pdu = bytes([OPCODE_READ_REQUEST, lsb, msb])
+        self.channel.send_pdu(pdu)
+        response = await self._read_response()
+        return response
+
+    async def write(self, handle_name: str, value: bytes) -> None:
+        handle_value = ATT_HANDLES[handle_name]
+        lsb = handle_value & 0xFF
+        msb = (handle_value >> 8) & 0xFF
+        pdu = bytes([OPCODE_WRITE_REQUEST, lsb, msb]) + value
+        self.channel.send_pdu(pdu)
+        try:
+            await self._read_response(timeout=2.0)
+        except Exception:
+            logger.warning(f"No write response received for handle {handle_name}")
+
+    async def write_cccd(self, handle_name: str, value: bytes) -> None:
+        handle_value = ATT_CCCD_HANDLES[handle_name]
+        lsb = handle_value & 0xFF
+        msb = (handle_value >> 8) & 0xFF
+        pdu = bytes([OPCODE_WRITE_REQUEST, lsb, msb]) + value
+        self.channel.send_pdu(pdu)
+        try:
+            await self._read_response(timeout=2.0)
+        except Exception:
+            logger.warning(f"No CCCD write response received for handle {handle_name}")
+
+    async def _read_response(self, timeout: float = 2.0) -> bytes:
+        try:
+            response = await asyncio.wait_for(
+                asyncio.get_event_loop().run_in_executor(
+                    None, lambda: self.responses.get(timeout=timeout)
+                ),
+                timeout=timeout + 0.5
+            )
+            return response[1:]  # Skip opcode
+        except Exception:
+            raise Exception("No response received") from None
+
+    async def listen_notifications(self) -> None:
+        logger.info("ATT notification listener started")
+        while self.running:
+            try:
+                pdu = await self._recv_q.get()
+
+                if not isinstance(pdu, (bytes, bytearray)):
+                    pdu = bytes(pdu)
+
+                if len(pdu) > 0 and pdu[0] == OPCODE_HANDLE_VALUE_NTF:
+                    handle = pdu[1] | (pdu[2] << 8)
+                    value = pdu[3:]
+                    if handle in self.listeners:
+                        for listener in self.listeners[handle]:
+                            listener(value)
+                else:
+                    self.responses.put(pdu)
+
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.debug(f"ATT listen error: {e}")
+                break
+
+        logger.info("ATT notification listener stopped")
+
+    def stop(self):
+        self.running = False
+
+
+
+class SignalEmitter(QObject):
+    update_ui = pyqtSignal(HearingAidSettings)
+    update_hearing_aid_toggle = pyqtSignal(bool)
+    update_swipe_toggle = pyqtSignal(bool)
+    update_loud_sound_reduction_toggle = pyqtSignal(bool)
+    update_listening_mode = pyqtSignal(int)
+    connected = pyqtSignal()
+
+
+class HearingAidApp(QWidget):
+    def __init__(self, att_manager: ATTManager, aacp_manager: AACPManager,
+                 loop: asyncio.AbstractEventLoop) -> None:
+        super().__init__()
+        self.att_manager = att_manager
+        self.aacp_manager = aacp_manager
+        self.loop = loop
+        self.emitter = SignalEmitter()
+        self.emitter.update_ui.connect(self.on_update_ui)
+        self.emitter.update_hearing_aid_toggle.connect(self._set_hearing_aid_toggle)
+        self.emitter.update_swipe_toggle.connect(self._set_swipe_toggle)
+        self.emitter.update_loud_sound_reduction_toggle.connect(self._set_loud_sound_reduction_toggle)
+        self.emitter.update_listening_mode.connect(self._set_listening_mode)
+        self.emitter.connected.connect(self.on_connected)
+        self.debounce_timer = QTimer()
+        self.debounce_timer.setSingleShot(True)
+        self.debounce_timer.timeout.connect(self.send_settings)
+        self.init_ui()
+
+    def init_ui(self) -> None:
+        self.setWindowTitle("LibrePods - Hearing Aid")
+        layout = QVBoxLayout()
+
+        # Status label
+        self.status_label = QLabel("Connecting...")
+        layout.addWidget(self.status_label, alignment=Qt.AlignCenter)
+
+        # Listening Mode combo box
+        self.listening_mode_combo = QComboBox()
+        self.listening_mode_combo.addItems(["Off", "Noise Cancellation", "Transparency", "Adaptive"])
+        self.listening_mode_combo.currentIndexChanged.connect(self.on_listening_mode_changed)
+        layout.addWidget(QLabel("Listening Mode"))
+        layout.addWidget(self.listening_mode_combo)
+
+        layout.addWidget(QLabel("Switch to Transparency mode for Hearing Aid to work."))
+
+        layout.addSpacing(20)
+
+        self.loud_sound_reduction_checkbox = QCheckBox("Loud Sound Reduction")
+        self.loud_sound_reduction_checkbox.stateChanged.connect(self.on_loud_sound_reduction_toggle)
+        layout.addWidget(self.loud_sound_reduction_checkbox)
+
+        self.hearing_aid_checkbox = QCheckBox("Hearing Aid")
+        self.hearing_aid_checkbox.stateChanged.connect(self.on_hearing_aid_toggle)
+        layout.addWidget(self.hearing_aid_checkbox)
+
+        layout.addSpacing(20)
+
+        # EQ Inputs
+        eq_layout = QGridLayout()
+        self.left_eq_inputs: List[QLineEdit] = []
+        self.right_eq_inputs: List[QLineEdit] = []
+
+        eq_labels = ["250Hz", "500Hz", "1kHz", "2kHz", "3kHz", "4kHz", "6kHz", "8kHz"]
+        eq_layout.addWidget(QLabel("Frequency"), 0, 0)
+        eq_layout.addWidget(QLabel("Left"), 0, 1, alignment=Qt.AlignCenter)
+        eq_layout.addWidget(QLabel("Right"), 0, 2, alignment=Qt.AlignCenter)
+
+        validator = QDoubleValidator(0.0, 100.0, 6)
+
+        for i, label in enumerate(eq_labels):
+            eq_layout.addWidget(QLabel(label), i + 1, 0)
+            left_input = QLineEdit()
+            right_input = QLineEdit()
+            left_input.setValidator(validator)
+            right_input.setValidator(validator)
+            left_input.setPlaceholderText("Left")
+            right_input.setPlaceholderText("Right")
+            self.left_eq_inputs.append(left_input)
+            self.right_eq_inputs.append(right_input)
+            eq_layout.addWidget(left_input, i + 1, 1)
+            eq_layout.addWidget(right_input, i + 1, 2)
+
+        eq_group = QWidget()
+        eq_group.setLayout(eq_layout)
+        layout.addWidget(QLabel("Loss, in dBHL"))
+        layout.addWidget(eq_group)
+
+        # Amplification
+        self.amp_slider = QSlider(Qt.Horizontal)
+        self.amp_slider.setRange(-100, 100)
+        self.amp_slider.setValue(0)
+        layout.addWidget(QLabel("Amplification"))
+        layout.addWidget(self.amp_slider)
+
+        self.swipe_checkbox = QCheckBox("Swipe to control amplification")
+        self.swipe_checkbox.stateChanged.connect(self.on_swipe_toggle)
+        layout.addWidget(self.swipe_checkbox)
+
+        # Balance
+        self.balance_slider = QSlider(Qt.Horizontal)
+        self.balance_slider.setRange(-100, 100)
+        self.balance_slider.setValue(0)
+        layout.addWidget(QLabel("Balance"))
+        layout.addWidget(self.balance_slider)
+
+        # Tone
+        self.tone_slider = QSlider(Qt.Horizontal)
+        self.tone_slider.setRange(-100, 100)
+        self.tone_slider.setValue(0)
+        layout.addWidget(QLabel("Tone"))
+        layout.addWidget(self.tone_slider)
+
+        # Ambient Noise Reduction
+        self.anr_slider = QSlider(Qt.Horizontal)
+        self.anr_slider.setRange(0, 100)
+        self.anr_slider.setValue(0)
+        layout.addWidget(QLabel("Ambient Noise Reduction"))
+        layout.addWidget(self.anr_slider)
+
+        # Conversation Boost
+        self.conv_checkbox = QCheckBox("Conversation Boost")
+        layout.addWidget(self.conv_checkbox)
+
+        # Own Voice Amplification
+        self.own_voice_slider = QSlider(Qt.Horizontal)
+        self.own_voice_slider.setRange(0, 100)
+        self.own_voice_slider.setValue(50)
+        layout.addWidget(QLabel("Own Voice Amplification"))
+        layout.addWidget(self.own_voice_slider)
+
+        # Reset button
+        self.reset_button = QPushButton("Reset adjustments")
+        layout.addWidget(self.reset_button)
+
+        # Connect signals for ATT settings
+        for input_box in self.left_eq_inputs + self.right_eq_inputs:
+            input_box.textChanged.connect(self.on_value_changed)
+        self.amp_slider.valueChanged.connect(self.on_value_changed)
+        self.balance_slider.valueChanged.connect(self.on_value_changed)
+        self.tone_slider.valueChanged.connect(self.on_value_changed)
+        self.anr_slider.valueChanged.connect(self.on_value_changed)
+        self.conv_checkbox.stateChanged.connect(self.on_value_changed)
+        self.own_voice_slider.valueChanged.connect(self.on_value_changed)
+        self.reset_button.clicked.connect(self.reset_settings)
+
+        self.setLayout(layout)
+
+    def on_connected(self) -> None:
+        self.status_label.setText("Connected")
+        self.att_manager.register_listener(ATT_HANDLES['HEARING_AID'], self.on_att_notification)
+        self.att_manager.register_listener(ATT_HANDLES['LOUD_SOUND_REDUCTION'], self.on_loud_sound_reduction_notification)
+        self.aacp_manager.register_control_cmd_listener(ControlCommandId.HEARING_AID, self._on_hearing_aid_cmd)
+        self.aacp_manager.register_control_cmd_listener(ControlCommandId.HPS_GAIN_SWIPE, self._on_swipe_cmd)
+        self.aacp_manager.register_control_cmd_listener(ControlCommandId.LISTENING_MODE, self._on_listening_mode_cmd)
+        asyncio.run_coroutine_threadsafe(self._initial_setup(), self.loop)
+
+    def on_loud_sound_reduction_notification(self, value: bytes) -> None:
+        enabled = value[0] == 0x01 if value else False
+        self.emitter.update_loud_sound_reduction_toggle.emit(enabled)
+
+    def _set_loud_sound_reduction_toggle(self, enabled: bool):
+        self.loud_sound_reduction_checkbox.blockSignals(True)
+        self.loud_sound_reduction_checkbox.setChecked(enabled)
+        self.loud_sound_reduction_checkbox.blockSignals(False)
+
+    def on_loud_sound_reduction_toggle(self, state: int):
+        enabled = state == Qt.Checked
+        asyncio.run_coroutine_threadsafe(self._send_loud_sound_reduction_toggle(enabled), self.loop)
+
+    async def _send_loud_sound_reduction_toggle(self, enabled: bool):
+        value = bytes([0x01]) if enabled else bytes([0x00])
+        await self.att_manager.write('LOUD_SOUND_REDUCTION', value)
+
+    def _on_hearing_aid_cmd(self, value: bytes):
+        enabled = value[0] == 0x01 if value else False
+        self.emitter.update_hearing_aid_toggle.emit(enabled)
+
+    def _on_swipe_cmd(self, value: bytes):
+        enabled = value[0] == 0x01 if value else False
+        self.emitter.update_swipe_toggle.emit(enabled)
+
+    def _on_listening_mode_cmd(self, value: bytes):
+        mode_value = value[0] if value else 0x01
+        index = mode_value - 1 if 1 <= mode_value <= 4 else 0
+        self.emitter.update_listening_mode.emit(index)
+
+    def _set_hearing_aid_toggle(self, enabled: bool):
+        self.hearing_aid_checkbox.blockSignals(True)
+        self.hearing_aid_checkbox.setChecked(enabled)
+        self.hearing_aid_checkbox.blockSignals(False)
+
+    def _set_swipe_toggle(self, enabled: bool):
+        self.swipe_checkbox.blockSignals(True)
+        self.swipe_checkbox.setChecked(enabled)
+        self.swipe_checkbox.blockSignals(False)
+
+    def _set_listening_mode(self, index: int):
+        self.listening_mode_combo.blockSignals(True)
+        self.listening_mode_combo.setCurrentIndex(index)
+        self.listening_mode_combo.blockSignals(False)
+
+    def on_hearing_aid_toggle(self, state: int):
+        enabled = state == Qt.Checked
+        asyncio.run_coroutine_threadsafe(self._send_hearing_aid_toggle(enabled), self.loop)
+
+    def on_swipe_toggle(self, state: int):
+        enabled = state == Qt.Checked
+        asyncio.run_coroutine_threadsafe(self._send_swipe_toggle(enabled), self.loop)
+
+    def on_listening_mode_changed(self, index: int):
+        value = index + 1
+        asyncio.run_coroutine_threadsafe(self._send_listening_mode(value), self.loop)
+
+    async def _send_hearing_aid_toggle(self, enabled: bool):
+        if enabled:
+            await self.aacp_manager.send_control_command(ControlCommandId.HEARING_AID, bytes([0x01, 0x01]))
+            await self.aacp_manager.send_control_command(ControlCommandId.HEARING_ASSIST_CONFIG, bytes([0x01]))
+        else:
+            await self.aacp_manager.send_control_command(ControlCommandId.HEARING_AID, bytes([0x02, 0x02]))
+            await self.aacp_manager.send_control_command(ControlCommandId.HEARING_ASSIST_CONFIG, bytes([0x02]))
+
+    async def _send_swipe_toggle(self, enabled: bool):
+        value = bytes([0x01]) if enabled else bytes([0x02])
+        await self.aacp_manager.send_control_command(ControlCommandId.HPS_GAIN_SWIPE, value)
+
+    async def _send_listening_mode(self, value: int):
+        await self.aacp_manager.send_control_command(ControlCommandId.LISTENING_MODE, bytes([value]))
+
+    async def _initial_setup(self):
+        try:
+            await self.att_manager.enable_notifications('HEARING_AID')
+            await self.att_manager.enable_notifications('LOUD_SOUND_REDUCTION')
+            data = await self.att_manager.read('HEARING_AID')
+            settings = parse_hearing_aid_settings(data)
+            if settings:
+                self.emitter.update_ui.emit(settings)
+                logger.info("Initial ATT settings loaded")
+            loud_sound_data = await self.att_manager.read('LOUD_SOUND_REDUCTION')
+            loud_sound_enabled = loud_sound_data[0] == 0x01 if loud_sound_data else False
+            self.emitter.update_loud_sound_reduction_toggle.emit(loud_sound_enabled)
+            logger.info("Initial loud sound reduction setting loaded")
+        except Exception as e:
+            logger.error(f"Initial ATT setup failed: {e}")
+
+    def on_att_notification(self, value: bytes) -> None:
+        settings = parse_hearing_aid_settings(value)
+        if settings:
+            self.emitter.update_ui.emit(settings)
+
+    def on_update_ui(self, settings: HearingAidSettings) -> None:
+        self.amp_slider.blockSignals(True)
+        self.balance_slider.blockSignals(True)
+        self.tone_slider.blockSignals(True)
+        self.anr_slider.blockSignals(True)
+        self.conv_checkbox.blockSignals(True)
+        self.own_voice_slider.blockSignals(True)
+
+        self.amp_slider.setValue(int(settings.net_amplification * 100))
+        self.balance_slider.setValue(int(settings.balance * 100))
+        self.tone_slider.setValue(int(settings.left_tone * 100))
+        self.anr_slider.setValue(int(settings.left_ambient_noise_reduction * 100))
+        self.conv_checkbox.setChecked(settings.left_conversation_boost)
+        self.own_voice_slider.setValue(int(settings.own_voice_amplification * 100))
+
+        for i, value in enumerate(settings.left_eq):
+            self.left_eq_inputs[i].blockSignals(True)
+            self.left_eq_inputs[i].setText(f"{value:.2f}")
+            self.left_eq_inputs[i].blockSignals(False)
+        for i, value in enumerate(settings.right_eq):
+            self.right_eq_inputs[i].blockSignals(True)
+            self.right_eq_inputs[i].setText(f"{value:.2f}")
+            self.right_eq_inputs[i].blockSignals(False)
+
+        self.amp_slider.blockSignals(False)
+        self.balance_slider.blockSignals(False)
+        self.tone_slider.blockSignals(False)
+        self.anr_slider.blockSignals(False)
+        self.conv_checkbox.blockSignals(False)
+        self.own_voice_slider.blockSignals(False)
+
+    def on_value_changed(self) -> None:
+        self.debounce_timer.start(100)
+
+    def send_settings(self) -> None:
+        asyncio.run_coroutine_threadsafe(self._send_settings_async(), self.loop)
+
+    async def _send_settings_async(self) -> None:
+        try:
+            amp = self.amp_slider.value() / 100.0
+            balance = self.balance_slider.value() / 100.0
+            tone = self.tone_slider.value() / 100.0
+            anr = self.anr_slider.value() / 100.0
+            conv = self.conv_checkbox.isChecked()
+            own_voice = self.own_voice_slider.value() / 100.0
+
+            left_amp = amp + (0.5 - balance) * amp * 2 if balance < 0 else amp
+            right_amp = amp + (balance - 0.5) * amp * 2 if balance > 0 else amp
+
+            left_eq = [float(input_box.text() or 0) for input_box in self.left_eq_inputs]
+            right_eq = [float(input_box.text() or 0) for input_box in self.right_eq_inputs]
+
+            settings = HearingAidSettings(
+                left_eq, right_eq, left_amp, right_amp, tone, tone,
+                conv, conv, anr, anr, amp, balance, own_voice
+            )
+            await self._send_hearing_aid_settings(settings)
+        except Exception as e:
+            logger.error(f"Failed to send settings: {e}")
+
+    async def _send_hearing_aid_settings(self, settings: HearingAidSettings) -> None:
+        data = await self.att_manager.read('HEARING_AID')
+        if len(data) < 104:
+            logger.error("Read data too short for sending settings")
+            return
+        buffer = bytearray(data)
+        # buffer[0] = 0x02
+        # buffer[1] = 0x02
+        buffer[2] = 0x64
+
+        for i in range(8):
+            struct.pack_into('<f', buffer, 4 + i * 4, settings.left_eq[i])
+        struct.pack_into('<f', buffer, 36, settings.left_amplification)
+        struct.pack_into('<f', buffer, 40, settings.left_tone)
+        struct.pack_into('<f', buffer, 44, 1.0 if settings.left_conversation_boost else 0.0)
+        struct.pack_into('<f', buffer, 48, settings.left_ambient_noise_reduction)
+
+        for i in range(8):
+            struct.pack_into('<f', buffer, 52 + i * 4, settings.right_eq[i])
+        struct.pack_into('<f', buffer, 84, settings.right_amplification)
+        struct.pack_into('<f', buffer, 88, settings.right_tone)
+        struct.pack_into('<f', buffer, 92, 1.0 if settings.right_conversation_boost else 0.0)
+        struct.pack_into('<f', buffer, 96, settings.right_ambient_noise_reduction)
+
+        struct.pack_into('<f', buffer, 100, settings.own_voice_amplification)
+
+        await self.att_manager.write('HEARING_AID', buffer)
+        logger.info("Hearing aid settings sent")
+
+    def reset_settings(self):
+        self.amp_slider.setValue(0)
+        self.balance_slider.setValue(0)
+        self.tone_slider.setValue(0)
+        self.anr_slider.setValue(50)
+        self.conv_checkbox.setChecked(False)
+        self.own_voice_slider.setValue(50)
+        self.on_value_changed()
+
+    def closeEvent(self, event) -> None:
+        self.att_manager.stop()
+        self.aacp_manager.stop()
+        event.accept()
+
+
+# Make sure shutdown event is created earlier
+SHUTDOWN_EVENT = threading.Event()
+
+# Add a global shutdown event to signal the async loop to exit cleanly
+async def run_bluez(bdaddr: str, att_manager: ATTManager, aacp_manager: AACPManager,
+                     app_window: HearingAidApp, shutdown_event: threading.Event = SHUTDOWN_EVENT):
+    try:
+        import bluetooth
+    except ImportError:
+        logger.error("PyBluez (bluetooth) not installed. Install it or use --bumble.")
+        return 1
+
+    logger.info(f"Connecting to {bdaddr} using bluez sockets...")
+
+    att_channel = None
+    aacp_channel = None
+    att_listen_task = None
+    aacp_listen_task = None
+    try:
+        # ATT
+        att_sock = bluetooth.BluetoothSocket(bluetooth.L2CAP)
+        att_sock.connect((bdaddr, 31))
+        logger.info("Connected to ATT (PSM 31)")
+
+        # AACP
+        aacp_sock = bluetooth.BluetoothSocket(bluetooth.L2CAP)
+        aacp_sock.connect((bdaddr, 4097))
+        logger.info("Connected to AACP (PSM 4097)")
+
+        loop = asyncio.get_running_loop()
+
+        att_channel = BluezChannel(att_sock, loop)
+        att_manager.set_channel(att_channel)
+
+        aacp_channel = BluezChannel(aacp_sock, loop)
+        aacp_manager.set_channel(aacp_channel)
+
+        # AACP Setup
+        await aacp_manager.send_handshake()
+        await asyncio.sleep(0.1)
+        await aacp_manager.send_notification_request()
+        await asyncio.sleep(0.1)
+        await aacp_manager.send_set_feature_flags()
+        await asyncio.sleep(0.1)
+        await aacp_manager.send_control_command(ControlCommandId.OWNS_CONNECTION, bytes([0x01]))
+
+        app_window.emitter.connected.emit()
+
+        att_listen_task = asyncio.create_task(att_manager.listen_notifications())
+        aacp_listen_task = asyncio.create_task(aacp_manager.listen())
+
+        logger.info("BlueZ connection established. UI is now active.")
+
+        try:
+            await loop.run_in_executor(None, shutdown_event.wait)
+        except asyncio.CancelledError:
+            pass
+    except Exception as e:
+        logger.error(f"BlueZ connection failed: {e}")
+        return 1
+    finally:
+        # Ensure we attempt a clean shutdown
+        if att_listen_task:
+            att_listen_task.cancel()
+            try:
+                await att_listen_task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                pass
+        if aacp_listen_task:
+            aacp_listen_task.cancel()
+            try:
+                await aacp_listen_task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                pass
+        if att_channel:
+            try:
+                att_channel.stop()
+            except Exception:
+                pass
+        if aacp_channel:
+            try:
+                aacp_channel.stop()
+            except Exception:
+                pass
+
+    return 0
+
+
+async def run_bumble(bdaddr: str, att_manager: ATTManager, aacp_manager: AACPManager,
+                     app_window: HearingAidApp, shutdown_event: threading.Event = SHUTDOWN_EVENT):
+    try:
+        from bumble.l2cap import ClassicChannelSpec, ClassicChannel
+        from bumble.transport import open_transport
+        from bumble.device import Device, Connection
+        from bumble.host import Host
+        from bumble.core import PhysicalTransport, UUID
+        from bumble.pairing import PairingConfig, PairingDelegate
+        from bumble.hci import HCI_Error
+        from bumble.keys import JsonKeyStore
+        from bumble.sdp import ServiceAttribute, DataElement
+    except ImportError:
+        logger.error("Bumble not installed")
+        return 1
+
+    transport = None
+    device = None
+    connection = None
+    att_listen_task = None
+    aacp_listen_task = None
+
+    try:
+        async def get_device():
+            logger.info("Opening transport...")
+            transport = await open_transport("usb:0")
+            device = Device(host=Host(controller_source=transport.source, controller_sink=transport.sink))
+            device.classic_enabled = True
+            device.le_enabled = False
+            device.keystore = JsonKeyStore.from_device(device, "./keys.json")
+            device.pairing_config_factory = lambda conn: PairingConfig(
+                sc=True, mitm=False, bonding=True,
+                delegate=PairingDelegate(io_capability=PairingDelegate.NO_OUTPUT_NO_INPUT)
+            )
+            await device.power_on()
+            logger.info("Device powered on")
+
+            def on_l2cap_connection(channel: ClassicChannel):
+                logger.info("Incoming L2CAP connection on PSM %d", channel.psm)
+                async def handle_data():
+                    try:
+                        reader = _make_reader(channel)
+                        while True:
+                            data = await reader()
+                            print(f"Received PDU on PSM {channel.psm}: {data.hex() if data else 'None'}")
+                    except Exception as e:
+                        logger.info("L2CAP channel on PSM %d closed: %s", channel.psm, e)
+                asyncio.create_task(handle_data())
+
+            att_server_spec = ClassicChannelSpec(psm=31, mtu=512)
+            device.create_l2cap_server(att_server_spec, handler=on_l2cap_connection)
+            logger.info("L2CAP server registered on PSM 0x%04X", att_server_spec.psm)
+
+            device.sdp_service_records =  {
+                    0x4f491200: [
+                        ServiceAttribute(0x0000, DataElement.unsigned_integer_32(0x4f491200)),
+                        ServiceAttribute(0x0001, DataElement.sequence([DataElement.uuid(UUID.from_16_bits(0x1200))])),
+                        ServiceAttribute(0x0002, DataElement.unsigned_integer_32(0x00000000)),
+                        ServiceAttribute(0x0005, DataElement.sequence([DataElement.uuid(UUID.from_16_bits(0x1002))])),
+                        ServiceAttribute(0x0006, DataElement.sequence([
+                            DataElement.unsigned_integer_16(0x656e), DataElement.unsigned_integer_16(0x006a), DataElement.unsigned_integer_16(0x0100),
+                            DataElement.unsigned_integer_16(0x6672), DataElement.unsigned_integer_16(0x006a), DataElement.unsigned_integer_16(0x0110),
+                            DataElement.unsigned_integer_16(0x6465), DataElement.unsigned_integer_16(0x006a), DataElement.unsigned_integer_16(0x0120),
+                            DataElement.unsigned_integer_16(0x6a61), DataElement.unsigned_integer_16(0x006a), DataElement.unsigned_integer_16(0x0130)
+                        ])),
+                        ServiceAttribute(0x0008, DataElement.unsigned_integer_8(0xff)),
+                        ServiceAttribute(0x0101, DataElement.text_string('PnP Information')),
+                        ServiceAttribute(0x0200, DataElement.unsigned_integer_16(0x0102)),
+                        ServiceAttribute(0x0201, DataElement.unsigned_integer_16(0x004c)),
+                        ServiceAttribute(0x0202, DataElement.unsigned_integer_16(0x0000)),
+                        ServiceAttribute(0x0203, DataElement.unsigned_integer_16(0x0f60)),
+                        ServiceAttribute(0x0204, DataElement.boolean(True)),
+                        ServiceAttribute(0x0205, DataElement.unsigned_integer_16(0x0001)),
+                        ServiceAttribute(0xa000, DataElement.unsigned_integer_32(0x00a026c4)),
+                        ServiceAttribute(0xafff, DataElement.unsigned_integer_16(0x0001))
+                    ]
+                }
+
+            logger.info("SDP service records set up")
+
+            return transport, device
+
+        async def setup_aacp(conn: Connection):
+            spec = ClassicChannelSpec(psm=4097, mtu=2048)
+            logger.info("Requesting AACP channel on PSM = 0x%04X", spec.psm)
+            if not conn.is_encrypted:
+                await conn.encrypt()
+                await asyncio.sleep(0.05)
+            channel: ClassicChannel = await conn.create_l2cap_channel(spec=spec)
+            aacp_manager.set_channel(channel)
+            logger.info("AACP channel established")
+
+            await aacp_manager.send_handshake()
+            await asyncio.sleep(0.1)
+            await aacp_manager.send_notification_request()
+            await asyncio.sleep(0.1)
+            await aacp_manager.send_set_feature_flags()
+
+            return channel
+
+        async def setup_att(conn: Connection):
+            spec = ClassicChannelSpec(psm=31, mtu=512)
+            logger.info("Requesting ATT channel on PSM = 0x%04X", spec.psm)
+            if not conn.is_encrypted:
+                await conn.encrypt()
+                await asyncio.sleep(0.05)
+            channel: ClassicChannel = await conn.create_l2cap_channel(spec=spec)
+            att_manager.set_channel(channel)
+            logger.info("ATT channel established")
+            return channel
+
+        transport, device = await get_device()
+        logger.info("Connecting to %s (BR/EDR)...", bdaddr)
+        connection = await device.connect(bdaddr, PhysicalTransport.BR_EDR)
+        logger.info("Connected to %s (handle %s)", connection.peer_address, connection.handle)
+        logger.info("Authenticating...")
+        await connection.authenticate()
+        if not connection.is_encrypted:
+            logger.info("Encrypting link...")
+            await connection.encrypt()
+
+        await setup_aacp(connection)
+        await setup_att(connection)
+
+        app_window.emitter.connected.emit()
+
+        att_listen_task = asyncio.create_task(att_manager.listen_notifications())
+        aacp_listen_task = asyncio.create_task(aacp_manager.listen())
+
+        logger.info("Connection established. UI is now active.")
+        try:
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, shutdown_event.wait)
+        except asyncio.CancelledError:
+            pass
+    except HCI_Error as e:
+        if "PAIRING_NOT_ALLOWED_ERROR" in str(e):
+            logger.error("Put your device into pairing mode and run the script again")
+        else:
+            logger.error("HCI error: %s", e)
+    except Exception as e:
+        logger.error("Unexpected error: %s", e)
+    finally:
+        logger.info("Shutting down bumble connection...")
+        # Cancel and await listening tasks
+        if att_listen_task:
+            att_listen_task.cancel()
+            try:
+                await att_listen_task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                pass
+        if aacp_listen_task:
+            aacp_listen_task.cancel()
+            try:
+                await aacp_listen_task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                pass
+
+        # Attempt to cleanly disconnect the remote device
+        if connection:
+            try:
+                await connection.disconnect()
+            except Exception:
+                pass
+
+        if transport:
+            logger.info("Closing transport...")
+            try:
+                await transport.close()
+            except Exception:
+                pass
+            logger.info("Transport closed")
+    return 0
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("bdaddr", help="Bluetooth address of the hearing aid device")
+    parser.add_argument("--debug", action="store_true", help="Enable debug logging")
+    parser.add_argument("--bumble", action="store_true", help="Force use of Bumble stack (default on Windows)")
+    args = parser.parse_args()
+    logging.getLogger().setLevel(logging.DEBUG if args.debug else logging.INFO)
+
+    qt_app = QApplication(sys.argv)
+    loop = asyncio.new_event_loop()
+
+    att_manager = ATTManager()
+    aacp_manager = AACPManager()
+
+    window = HearingAidApp(att_manager, aacp_manager, loop)
+    window.show()
+
+    def quit_app(signum, frame):
+        # Signal the application shutdown to both main thread and the async thread
+        SHUTDOWN_EVENT.set()
+        try:
+            att_manager.stop()
+            aacp_manager.stop()
+        except Exception:
+            pass
+        qt_app.quit()
+
+    signal.signal(signal.SIGINT, quit_app)
+    signal.signal(signal.SIGTERM, quit_app)
+    
+    def run_async():
+        asyncio.set_event_loop(loop)
+        use_bumble = args.bumble or platform.system() == "Windows"
+        try:
+            if use_bumble:
+                loop.run_until_complete(run_bumble(args.bdaddr, att_manager, aacp_manager, window, SHUTDOWN_EVENT))
+            else:
+                import subprocess
+                ps_output = subprocess.run(["ps", "-A"], capture_output=True, text=True).stdout
+                if "librepods" in ps_output:
+                    logger.error("LibrePods is running. Please close it before using this script.")
+                    loop.call_soon_threadsafe(loop.stop)
+                    quit_app(None, None)
+                    return
+                loop.run_until_complete(
+                    run_bluez(args.bdaddr, att_manager, aacp_manager, window, SHUTDOWN_EVENT)
+                )
+        except Exception as e:
+            logger.error("Async thread error: %s", e)
+        finally:
+            loop.call_soon_threadsafe(loop.stop)
+
+    # Keep the async thread non-daemon so cleanup can run
+    async_thread = threading.Thread(target=run_async, daemon=False)
+    async_thread.start()
+
+    timer = QTimer()
+    timer.timeout.connect(lambda: None)
+    timer.start(100)
+
+    # Run GUI and wait for async thread cleanup
+    exit_code = qt_app.exec_()
+
+    # Ensure shutdown is signaled (in case user closed the window)
+    SHUTDOWN_EVENT.set()
+
+    # Wait for async thread to finish gracefully for a short timeout
+    async_thread.join(timeout=10)
+
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/proximity_keys.py b/scripts/proximity_keys.py
similarity index 100%
rename from proximity_keys.py
rename to scripts/proximity_keys.py