Rewrite Murmur in Rust for macOS and Linux

.github/workflows/rust.yml

@@ -0,0 +1,78 @@
+# Formatting, lints and tests for the Rust workspace in rust/, on the two platforms Murmur ships
+# for: macOS (Apple Silicon) and Linux (x86_64, like the Omarchy machine). Clippy runs on both
+# because each OS compiles its own platform code. No releases are built here.
+name: Rust
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+# A newer push to the same branch or PR replaces a run still in progress.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  CARGO_TERM_COLOR: always
+  # Incremental builds only help locally; on CI they just make the cache bigger.
+  CARGO_INCREMENTAL: 0
+
+defaults:
+  run:
+    working-directory: rust
+
+jobs:
+  check:
+    name: ${{ matrix.name }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: macOS
+            os: macos-latest
+          - name: Linux
+            os: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v5
+
+      # cpal's ALSA backend needs the ALSA headers to build. sherpa-onnx downloads its own
+      # prebuilt libraries during the build, so it needs nothing installed.
+      - name: Install Linux packages
+        if: runner.os == 'Linux'
+        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends libasound2-dev pkg-config
+
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: rust
+
+      # sherpa-onnx's build script would download its prebuilt libraries into target/, which
+      # rust-cache prunes before saving: a run that restored the cache skipped the build script
+      # and the macOS link failed with "library 'sherpa-onnx-c-api' not found". Download them
+      # here instead, outside target/, and point the build script at them. The archive is the
+      # one the build script would pick: shared libraries on macOS, static on Linux.
+      - name: Download sherpa-onnx
+        run: |
+          version=$(grep -A1 '^name = "sherpa-onnx-sys"' Cargo.lock | sed -n 's/^version = "\(.*\)"/\1/p')
+          kind=$([[ $RUNNER_OS == macOS ]] && echo osx-arm64-shared-lib || echo linux-x64-static-lib)
+          archive=sherpa-onnx-v$version-$kind
+          mkdir -p "$RUNNER_TEMP/sherpa-onnx"
+          curl -fsSL --retry 3 "https://github.com/k2-fsa/sherpa-onnx/releases/download/v$version/$archive.tar.bz2" \
+            | tar -xj -C "$RUNNER_TEMP/sherpa-onnx"
+          echo "SHERPA_ONNX_LIB_DIR=$RUNNER_TEMP/sherpa-onnx/$archive/lib" >> "$GITHUB_ENV"
+
+      - name: Format
+        run: cargo fmt --all --check
+
+      - name: Clippy
+        run: cargo clippy --workspace --all-targets --locked -- -D warnings
+
+      # Tests that need the speech model, a Claude key or a desktop are #[ignore]d and skipped.
+      - name: Test
+        run: cargo test --workspace --locked

App/Murmur/HotkeyMonitor.swift

@@ -49,6 +49,10 @@ enum Hotkey: String, CaseIterable, Identifiable {
 /// Creating the tap needs Accessibility permission, which Murmur needs anyway to paste. Call
 /// `install()` again once permission is granted.
 final class HotkeyMonitor {
+    /// How long the key has to stay down before it counts as push-to-talk. A quicker tap is left
+    /// to macOS, so tapping fn still opens the emoji picker without starting a recording.
+    static let holdDelay: TimeInterval = 0.2
+
     var hotkey: Hotkey = .fn
     var onPress: () -> Void = {}
     var onRelease: () -> Void = {}
@@ -59,6 +63,8 @@ final class HotkeyMonitor {
     private var tap: CFMachPort?
     private var runLoopSource: CFRunLoopSource?
     private var isDown = false
+    /// The hold delay is running: the key is down but `onPress` hasn't fired yet.
+    private var pendingPress: DispatchWorkItem?
 
     /// Returns false when the tap couldn't be created, which means no Accessibility permission yet.
     @discardableResult
@@ -88,6 +94,12 @@ final class HotkeyMonitor {
         tap = nil
         runLoopSource = nil
         isDown = false
+        cancelPendingPress()
+    }
+
+    private func cancelPendingPress() {
+        pendingPress?.cancel()
+        pendingPress = nil
     }
 
     fileprivate func handle(type: CGEventType, keyCode: UInt16, flags: CGEventFlags) {
@@ -96,16 +108,33 @@ final class HotkeyMonitor {
             // macOS switches a tap off if it stalls; turn it straight back on.
             if let tap { CGEvent.tapEnable(tap: tap, enable: true) }
         case .keyDown:
-            if isDown { onChord() }
+            guard isDown else { return }
+            if pendingPress != nil {
+                // A shortcut typed before the hold delay ran out: never start recording at all.
+                cancelPendingPress()
+            } else {
+                onChord()
+            }
         case .flagsChanged:
             guard keyCode == hotkey.keyCode else { return }
             let pressed = flags.contains(hotkey.flag)
             if pressed, !isDown {
                 isDown = true
-                onPress()
+                let press = DispatchWorkItem { [weak self] in
+                    guard let self else { return }
+                    pendingPress = nil
+                    onPress()
+                }
+                pendingPress = press
+                DispatchQueue.main.asyncAfter(deadline: .now() + Self.holdDelay, execute: press)
             } else if !pressed, isDown {
                 isDown = false
-                onRelease()
+                if pendingPress != nil {
+                    // A quick tap: recording never started, so there's nothing to finish.
+                    cancelPendingPress()
+                } else {
+                    onRelease()
+                }
             }
         default:
             break

rust/.gitignore

@@ -0,0 +1 @@
+/target