Skip to content

Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more

added apple models for both old and new mac - newer ones supports 10 languages and is on par with parakeet

altic-devdf7e62664cfd
diff --git a/Info.plist b/Info.plist
index d422388b..7f07dcfc 100644
--- a/Info.plist
+++ b/Info.plist
@@ -11,7 +11,7 @@
<key>CFBundleVersion</key>
<string>1</string>
<key>CFBundleShortVersionString</key>
- <string>1.5.1</string>
+ <string>1.5.2</string>
<key>LSMinimumSystemVersion</key>
<string>$(MACOSX_DEPLOYMENT_TARGET)</string>
<key>LSApplicationCategoryType</key>
@@ -24,5 +24,7 @@
<true/>
<key>NSAppleEventsUsageDescription</key>
<string>FluidVoice needs permission to control system events for managing launch at startup settings.</string>
+ <key>NSSpeechRecognitionUsageDescription</key>
+ <string>FluidVoice uses on-device speech recognition to transcribe your voice commands and text quickly and privately.</string>
</dict>
</plist>
diff --git a/Sources/Fluid/Persistence/SettingsStore.swift b/Sources/Fluid/Persistence/SettingsStore.swift
index 71bd6988..dabc66fa 100644
--- a/Sources/Fluid/Persistence/SettingsStore.swift
+++ b/Sources/Fluid/Persistence/SettingsStore.swift
@@ -872,7 +872,12 @@ final class SettingsStore: ObservableObject {
// MARK: - FluidAudio Models (Apple Silicon Only)
case parakeetTDT = "parakeet-tdt"
+
+ // MARK: - Apple Native
+ case appleSpeech = "apple-speech"
+ case appleSpeechAnalyzer = "apple-speech-analyzer"
+
// MARK: - Whisper Models (Universal)
case whisperTiny = "whisper-tiny"
@@ -889,6 +894,8 @@ final class SettingsStore: ObservableObject {
var displayName: String {
switch self {
case .parakeetTDT: return "Parakeet TDT"
+ case .appleSpeech: return "Apple Speech (Legacy)"
+ case .appleSpeechAnalyzer: return "Apple Speech (macOS 26+)"
case .whisperTiny: return "Whisper Tiny"
case .whisperBase: return "Whisper Base"
case .whisperSmall: return "Whisper Small"
@@ -901,6 +908,8 @@ final class SettingsStore: ObservableObject {
var languageSupport: String {
switch self {
case .parakeetTDT: return "25 Languages"
+ case .appleSpeech: return "System Languages"
+ case .appleSpeechAnalyzer: return "EN, ES, FR, DE, IT, JA, KO, PT, ZH"
case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, .whisperLargeTurbo, .whisperLarge:
return "99 Languages"
}
@@ -909,6 +918,8 @@ final class SettingsStore: ObservableObject {
var downloadSize: String {
switch self {
case .parakeetTDT: return "~500 MB"
+ case .appleSpeech: return "Built-in (Zero Download)"
+ case .appleSpeechAnalyzer: return "Built-in"
case .whisperTiny: return "~75 MB"
case .whisperBase: return "~142 MB"
case .whisperSmall: return "~466 MB"
@@ -927,7 +938,7 @@ final class SettingsStore: ObservableObject {
var isWhisperModel: Bool {
switch self {
- case .parakeetTDT: return false
+ case .parakeetTDT, .appleSpeech, .appleSpeechAnalyzer: return false
default: return true
}
}
@@ -960,10 +971,30 @@ final class SettingsStore: ObservableObject {
// MARK: - Architecture Filtering
- /// Returns models available for the current Mac's architecture
+ /// Requires macOS 26 (Tahoe) or later
+ var requiresMacOS26: Bool {
+ switch self {
+ case .appleSpeechAnalyzer: return true
+ default: return false
+ }
+ }
+
+ /// Returns models available for the current Mac's architecture and OS
static var availableModels: [SpeechModel] {
allCases.filter { model in
- !model.requiresAppleSilicon || CPUArchitecture.isAppleSilicon
+ // Filter by Apple Silicon requirement
+ if model.requiresAppleSilicon && !CPUArchitecture.isAppleSilicon {
+ return false
+ }
+ // Filter by macOS 26 requirement
+ if model.requiresMacOS26 {
+ if #available(macOS 26.0, *) {
+ return true
+ } else {
+ return false
+ }
+ }
+ return true
}
}
diff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swift
index fbdf2ece..bb28fbf7 100644
--- a/Sources/Fluid/Services/ASRService.swift
+++ b/Sources/Fluid/Services/ASRService.swift
@@ -105,6 +105,9 @@ final class ASRService: ObservableObject {
/// Cached providers to avoid re-instantiation
private var fluidAudioProvider: FluidAudioProvider?
private var whisperProvider: WhisperProvider?
+ private var appleSpeechProvider: AppleSpeechProvider?
+ /// Stored as Any? because @available cannot be applied to stored properties
+ private var _appleSpeechAnalyzerProvider: Any?
/// Prevent concurrent provider.prepare() calls (download/load) from overlapping.
/// Subsequent callers await the in-flight task.
@@ -116,10 +119,20 @@ final class ASRService: ObservableObject {
private var transcriptionProvider: TranscriptionProvider {
let model = SettingsStore.shared.selectedSpeechModel
- if model.isWhisperModel {
- return self.getWhisperProvider()
- } else {
+ switch model {
+ case .appleSpeechAnalyzer:
+ if #available(macOS 26.0, *) {
+ return self.getAppleSpeechAnalyzerProvider()
+ } else {
+ // Fallback to legacy Apple Speech on older macOS
+ return self.getAppleSpeechProvider()
+ }
+ case .appleSpeech:
+ return self.getAppleSpeechProvider()
+ case .parakeetTDT:
return self.getFluidAudioProvider()
+ default:
+ return self.getWhisperProvider()
}
}
@@ -143,6 +156,28 @@ final class ASRService: ObservableObject {
return provider
}
+ private func getAppleSpeechProvider() -> AppleSpeechProvider {
+ if let existing = appleSpeechProvider {
+ return existing
+ }
+ let provider = AppleSpeechProvider()
+ self.appleSpeechProvider = provider
+ DebugLogger.shared.info("ASRService: Created AppleSpeech provider", source: "ASRService")
+ return provider
+ }
+
+ @available(macOS 26.0, *)
+ private func getAppleSpeechAnalyzerProvider() -> AppleSpeechAnalyzerProvider {
+ if let existing = _appleSpeechAnalyzerProvider as? AppleSpeechAnalyzerProvider {
+ return existing
+ }
+ let provider = AppleSpeechAnalyzerProvider()
+ self._appleSpeechAnalyzerProvider = provider
+ DebugLogger.shared.info("ASRService: Created AppleSpeechAnalyzer provider", source: "ASRService")
+ return provider
+ }
+
+
/// Returns the user-friendly name of the currently selected speech model
var activeProviderName: String {
SettingsStore.shared.selectedSpeechModel.displayName
@@ -150,16 +185,20 @@ final class ASRService: ObservableObject {
/// Call this when the transcription provider setting changes to reset state
func resetTranscriptionProvider() {
+ let newModel = SettingsStore.shared.selectedSpeechModel
+ DebugLogger.shared.info("ASRService: Switching to '\(newModel.displayName)', resetting provider state...", source: "ASRService")
+
self.isAsrReady = false
self.modelsExistOnDisk = false
self.ensureReadyTask?.cancel()
self.ensureReadyTask = nil
self.ensureReadyProviderKey = nil
- DebugLogger.shared.info("ASRService: Provider reset, will re-initialize on next use", source: "ASRService")
// CRITICAL FIX: Immediately check if the NEW model's files exist on disk
// This prevents UI from showing "Download" when model is already downloaded
self.checkIfModelsExist()
+
+ DebugLogger.shared.info("ASRService: Provider reset complete, will initialize '\(newModel.displayName)' on next use", source: "ASRService")
}
// CRITICAL FIX (launch-time crash mitigation):
diff --git a/Sources/Fluid/Services/AppleSpeechAnalyzerProvider.swift b/Sources/Fluid/Services/AppleSpeechAnalyzerProvider.swift
new file mode 100644
index 00000000..1bd2807f
--- /dev/null
+++ b/Sources/Fluid/Services/AppleSpeechAnalyzerProvider.swift
@@ -0,0 +1,281 @@
+import AVFoundation
+import Combine
+import Foundation
+
+#if canImport(Speech)
+import Speech
+#endif
+
+// MARK: - Apple Speech Analyzer Provider (macOS 26+)
+
+/// A TranscriptionProvider that uses Apple's new SpeechAnalyzer API (macOS 26+).
+/// This provides advanced speech-to-text with streaming capabilities.
+@available(macOS 26.0, *)
+final class AppleSpeechAnalyzerProvider: TranscriptionProvider {
+ var name: String { "Apple Speech (macOS 26+)" }
+
+ var isAvailable: Bool {
+ // SpeechAnalyzer is always available on macOS 26+
+ true
+ }
+
+ private(set) var isReady: Bool = false
+
+ /// Buffer converter for audio format conversion
+ private var converter: BufferConverter?
+
+ /// The required audio format for the analyzer
+ private var analyzerFormat: AVAudioFormat?
+
+ init() {}
+
+ // MARK: - Lifecycle
+
+ func prepare(progressHandler: ((Double) -> Void)?) async throws {
+ // 1. Create a transcriber to check locale support and download if needed
+ let transcriber = SpeechTranscriber(
+ locale: Locale.current,
+ transcriptionOptions: [],
+ reportingOptions: [],
+ attributeOptions: []
+ )
+
+ // 2. Check if locale is supported
+ let supportedLocales = await SpeechTranscriber.supportedLocales
+ let currentLocaleID = Locale.current.identifier(.bcp47)
+ let isSupported = supportedLocales.map { $0.identifier(.bcp47) }.contains(currentLocaleID)
+
+ guard isSupported else {
+ throw NSError(
+ domain: "AppleSpeechAnalyzerProvider",
+ code: 1,
+ userInfo: [NSLocalizedDescriptionKey: "Current locale is not supported by SpeechAnalyzer"]
+ )
+ }
+
+ // 3. Check if model is installed, download if needed
+ let installedLocales = await SpeechTranscriber.installedLocales
+ let isInstalled = installedLocales.map { $0.identifier(.bcp47) }.contains(currentLocaleID)
+
+ if !isInstalled {
+ DebugLogger.shared.info("Downloading speech model for locale: \(currentLocaleID)", source: "AppleSpeechAnalyzerProvider")
+ if let downloader = try await AssetInventory.assetInstallationRequest(supporting: [transcriber]) {
+ // Report progress periodically during download
+ let progress = downloader.progress
+ Task {
+ while !progress.isFinished && !progress.isCancelled {
+ progressHandler?(progress.fractionCompleted)
+ try? await Task.sleep(for: .milliseconds(100))
+ }
+ }
+ try await downloader.downloadAndInstall()
+ }
+ }
+
+ // 4. Get the best available audio format for conversion
+ self.analyzerFormat = await SpeechAnalyzer.bestAvailableAudioFormat(compatibleWith: [transcriber])
+ self.converter = BufferConverter()
+
+ self.isReady = true
+ DebugLogger.shared.info("AppleSpeechAnalyzerProvider ready", source: "AppleSpeechAnalyzerProvider")
+ }
+
+ func clearCache() async throws {
+ // Release reserved locales
+ let reserved = await AssetInventory.reservedLocales
+ for locale in reserved {
+ await AssetInventory.release(reservedLocale: locale)
+ }
+ }
+
+ func modelsExistOnDisk() -> Bool {
+ // Check synchronously - we'll report true optimistically
+ // since this is called before prepare()
+ return true
+ }
+
+ // MARK: - Transcription
+
+ func transcribe(_ samples: [Float]) async throws -> ASRTranscriptionResult {
+ guard isReady, let analyzerFormat = self.analyzerFormat else {
+ throw NSError(
+ domain: "AppleSpeechAnalyzerProvider",
+ code: 2,
+ userInfo: [NSLocalizedDescriptionKey: "Speech Analyzer not ready"]
+ )
+ }
+
+ DebugLogger.shared.debug("AppleSpeechAnalyzer: Starting transcription with \(samples.count) samples", source: "AppleSpeechAnalyzerProvider")
+
+ // 1. Create a FRESH transcriber for this transcription
+ let freshTranscriber = SpeechTranscriber(
+ locale: Locale.current,
+ transcriptionOptions: [],
+ reportingOptions: [],
+ attributeOptions: []
+ )
+
+ // 2. Create input stream
+ let (inputStream, inputContinuation) = AsyncStream<AnalyzerInput>.makeStream()
+
+ // 3. Create a fresh analyzer with the fresh transcriber
+ let analyzer = SpeechAnalyzer(modules: [freshTranscriber])
+
+ // 4. Convert samples to AVAudioPCMBuffer
+ guard let buffer = createPCMBuffer(from: samples) else {
+ throw NSError(
+ domain: "AppleSpeechAnalyzerProvider",
+ code: 3,
+ userInfo: [NSLocalizedDescriptionKey: "Failed to create audio buffer"]
+ )
+ }
+
+ // 5. Convert to analyzer format if needed
+ let convertedBuffer: AVAudioPCMBuffer
+ if let converter = self.converter {
+ do {
+ convertedBuffer = try converter.convertBuffer(buffer, to: analyzerFormat)
+ } catch {
+ DebugLogger.shared.warning("Buffer conversion failed: \(error)", source: "AppleSpeechAnalyzerProvider")
+ convertedBuffer = buffer
+ }
+ } else {
+ convertedBuffer = buffer
+ }
+
+ // 6. Set up results collector FIRST (before starting analyzer - per Apple's pattern)
+ var finalText = ""
+ let resultsTask = Task {
+ DebugLogger.shared.debug("AppleSpeechAnalyzer: Results task started, waiting for results...", source: "AppleSpeechAnalyzerProvider")
+ for try await case let result in freshTranscriber.results {
+ let text = String(result.text.characters)
+ DebugLogger.shared.debug("AppleSpeechAnalyzer: Got result - isFinal: \(result.isFinal), text: '\(text)'", source: "AppleSpeechAnalyzerProvider")
+ if result.isFinal {
+ // ACCUMULATE results (per Apple's pattern) - don't break!
+ if !finalText.isEmpty && !text.isEmpty {
+ finalText += " "
+ }
+ finalText += text
+ }
+ // Continue iterating until stream ends (after finalizeAndFinish)
+ }
+ DebugLogger.shared.debug("AppleSpeechAnalyzer: Results iteration complete, accumulated: '\(finalText)'", source: "AppleSpeechAnalyzerProvider")
+ }
+
+ // 7. Start the analyzer (this kicks off processing)
+ DebugLogger.shared.debug("AppleSpeechAnalyzer: Starting analyzer...", source: "AppleSpeechAnalyzerProvider")
+ try await analyzer.start(inputSequence: inputStream)
+ DebugLogger.shared.debug("AppleSpeechAnalyzer: Analyzer started", source: "AppleSpeechAnalyzerProvider")
+
+ // 8. Feed audio and signal end of input
+ let input = AnalyzerInput(buffer: convertedBuffer)
+ inputContinuation.yield(input)
+ inputContinuation.finish()
+ DebugLogger.shared.debug("AppleSpeechAnalyzer: Audio fed and input finished", source: "AppleSpeechAnalyzerProvider")
+
+ // 9. Finalize - this tells the analyzer to process remaining audio and complete the results stream
+ do {
+ try await analyzer.finalizeAndFinishThroughEndOfInput()
+ DebugLogger.shared.debug("AppleSpeechAnalyzer: Analyzer finalized", source: "AppleSpeechAnalyzerProvider")
+ } catch {
+ DebugLogger.shared.warning("Analyzer finalize error: \(error.localizedDescription)", source: "AppleSpeechAnalyzerProvider")
+ }
+
+ // 10. Now wait for results task to complete (it will finish once stream closes)
+ do {
+ try await resultsTask.value
+ } catch {
+ DebugLogger.shared.warning("Speech recognition error: \(error.localizedDescription)", source: "AppleSpeechAnalyzerProvider")
+ }
+
+ DebugLogger.shared.debug("AppleSpeechAnalyzer: Transcription complete - result: '\(finalText)'", source: "AppleSpeechAnalyzerProvider")
+ return ASRTranscriptionResult(text: finalText, confidence: 1.0)
+ }
+
+ // MARK: - Helpers
+
+ /// Converts raw [Float] samples (16kHz mono) to AVAudioPCMBuffer
+ private func createPCMBuffer(from samples: [Float]) -> AVAudioPCMBuffer? {
+ guard let format = AVAudioFormat(
+ commonFormat: .pcmFormatFloat32,
+ sampleRate: 16000,
+ channels: 1,
+ interleaved: false
+ ) else {
+ return nil
+ }
+
+ guard let buffer = AVAudioPCMBuffer(
+ pcmFormat: format,
+ frameCapacity: AVAudioFrameCount(samples.count)
+ ) else {
+ return nil
+ }
+
+ buffer.frameLength = AVAudioFrameCount(samples.count)
+
+ guard let channelData = buffer.floatChannelData else { return nil }
+
+ samples.withUnsafeBufferPointer { samplePtr in
+ guard let baseAddress = samplePtr.baseAddress else { return }
+ channelData[0].update(from: baseAddress, count: samples.count)
+ }
+
+ return buffer
+ }
+}
+
+// MARK: - Buffer Converter (from Apple's sample)
+
+@available(macOS 26.0, *)
+private class BufferConverter {
+ enum Error: Swift.Error {
+ case failedToCreateConverter
+ case failedToCreateConversionBuffer
+ case conversionFailed(NSError?)
+ }
+
+ private var converter: AVAudioConverter?
+
+ func convertBuffer(_ buffer: AVAudioPCMBuffer, to format: AVAudioFormat) throws -> AVAudioPCMBuffer {
+ let inputFormat = buffer.format
+ guard inputFormat != format else {
+ return buffer
+ }
+
+ if converter == nil || converter?.outputFormat != format {
+ converter = AVAudioConverter(from: inputFormat, to: format)
+ converter?.primeMethod = .none
+ }
+
+ guard let converter else {
+ throw Error.failedToCreateConverter
+ }
+
+ let sampleRateRatio = converter.outputFormat.sampleRate / converter.inputFormat.sampleRate
+ let scaledInputFrameLength = Double(buffer.frameLength) * sampleRateRatio
+ let frameCapacity = AVAudioFrameCount(scaledInputFrameLength.rounded(.up))
+
+ guard let conversionBuffer = AVAudioPCMBuffer(
+ pcmFormat: converter.outputFormat,
+ frameCapacity: frameCapacity
+ ) else {
+ throw Error.failedToCreateConversionBuffer
+ }
+
+ var nsError: NSError?
+ var bufferProcessed = false
+
+ let status = converter.convert(to: conversionBuffer, error: &nsError) { _, inputStatusPointer in
+ defer { bufferProcessed = true }
+ inputStatusPointer.pointee = bufferProcessed ? .noDataNow : .haveData
+ return bufferProcessed ? nil : buffer
+ }
+
+ guard status != .error else {
+ throw Error.conversionFailed(nsError)
+ }
+
+ return conversionBuffer
+ }
+}
diff --git a/Sources/Fluid/Services/AppleSpeechProvider.swift b/Sources/Fluid/Services/AppleSpeechProvider.swift
new file mode 100644
index 00000000..6aba5bbd
--- /dev/null
+++ b/Sources/Fluid/Services/AppleSpeechProvider.swift
@@ -0,0 +1,155 @@
+import AVFoundation
+import Foundation
+import Speech
+
+// MARK: - Apple Speech Provider
+
+/// A TranscriptionProvider that uses Apple's native SFSpeechRecognizer.
+/// This runs strictly on-device, requires no downloads, and has 0 memory footprint when idle.
+final class AppleSpeechProvider: TranscriptionProvider {
+ var name: String { "Apple Speech (Legacy)" }
+
+ /// Always available on macOS 10.15+ (Catalina and later)
+ var isAvailable: Bool {
+ SFSpeechRecognizer.authorizationStatus() != .restricted
+ }
+
+ /// Apple Speech is "always ready" (no downloads needed),
+ /// but we track if we've checked permissions.
+ private(set) var isReady: Bool = false
+
+ /// The recognizer instance. We intentionally re-create it if the locale changes,
+ /// but for now we default to the system locale.
+ private var recognizer: SFSpeechRecognizer?
+
+ init() {
+ // Initialize with user's current locale
+ self.recognizer = SFSpeechRecognizer(locale: Locale.current)
+ }
+
+ // MARK: - Lifecycle
+
+ func prepare(progressHandler: ((Double) -> Void)?) async throws {
+ // 1. Request Authorization
+ let status = await self.requestAuthorization()
+
+ switch status {
+ case .authorized:
+ self.isReady = true
+ DebugLogger.shared.info("AppleSpeechProvider authorized and ready", source: "AppleSpeechProvider")
+ case .denied:
+ throw NSError(domain: "AppleSpeechProvider", code: 1, userInfo: [NSLocalizedDescriptionKey: "Speech recognition permission denied"])
+ case .restricted:
+ throw NSError(domain: "AppleSpeechProvider", code: 2, userInfo: [NSLocalizedDescriptionKey: "Speech recognition is restricted on this device"])
+ case .notDetermined:
+ // Should not happen after requestAuthorization returns, but handled for safety
+ self.isReady = false
+ @unknown default:
+ self.isReady = false
+ }
+ }
+
+ func clearCache() async throws {
+ // No cache to clear for system speech
+ }
+
+ func modelsExistOnDisk() -> Bool {
+ return true // System models are always "on disk"
+ }
+
+ // MARK: - Transcription
+
+ func transcribe(_ samples: [Float]) async throws -> ASRTranscriptionResult {
+ guard self.isAvailable else {
+ throw NSError(domain: "AppleSpeechProvider", code: 3, userInfo: [NSLocalizedDescriptionKey: "Speech recognition unavailable"])
+ }
+
+ // 1. Convert [Float] samples to AVAudioPCMBuffer
+ guard let buffer = self.createPCMBuffer(from: samples) else {
+ throw NSError(domain: "AppleSpeechProvider", code: 4, userInfo: [NSLocalizedDescriptionKey: "Failed to create audio buffer"])
+ }
+
+ // 2. Ensure recognizer exists
+ if self.recognizer == nil {
+ self.recognizer = SFSpeechRecognizer(locale: Locale.current)
+ }
+ guard let recognizer = self.recognizer else {
+ throw NSError(domain: "AppleSpeechProvider", code: 5, userInfo: [NSLocalizedDescriptionKey: "Failed to initialize SFSpeechRecognizer"])
+ }
+
+ if !recognizer.isAvailable {
+ throw NSError(domain: "AppleSpeechProvider", code: 6, userInfo: [NSLocalizedDescriptionKey: "SFSpeechRecognizer is currently unavailable"])
+ }
+
+ // 3. Create Request
+ let request = SFSpeechAudioBufferRecognitionRequest()
+ request.shouldReportPartialResults = false // We want the final result for this chunk
+ request.requiresOnDeviceRecognition = true // Enforce strict privacy/offline
+ request.append(buffer)
+ request.endAudio() // Signal that this buffer is the complete utterance for this request
+
+ // 4. Execute Recognition
+ return try await withCheckedThrowingContinuation { continuation in
+ var hasResumed = false
+
+ recognizer.recognitionTask(with: request) { result, error in
+ // Ensure we only resume once
+ guard !hasResumed else { return }
+
+ if let error = error {
+ hasResumed = true
+ // Ignore "No speech detected" errors often returned for silent chunks
+ DebugLogger.shared.warning("Apple transcribed error: \(error.localizedDescription)", source: "AppleSpeechProvider")
+ continuation.resume(returning: ASRTranscriptionResult(text: "", confidence: 0.0))
+ return
+ }
+
+ if let result = result, result.isFinal {
+ hasResumed = true
+ let transcription = result.bestTranscription.formattedString
+ DebugLogger.shared.debug("AppleSpeechProvider: Got final result: '\(transcription)'", source: "AppleSpeechProvider")
+ continuation.resume(returning: ASRTranscriptionResult(text: transcription, confidence: 1.0))
+ }
+ // Partial results ignored as we requested final only
+ }
+ }
+ }
+
+ // MARK: - Helpers
+
+ /// Converts raw [Float] samples (16kHz mono) to AVAudioPCMBuffer
+ private func createPCMBuffer(from samples: [Float]) -> AVAudioPCMBuffer? {
+ // Define format: 16kHz, Mono, Float32 (standard for ML/ASR)
+ guard let format = AVAudioFormat(commonFormat: .pcmFormatFloat32, sampleRate: 16000, channels: 1, interleaved: false) else {
+ return nil
+ }
+
+ guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: AVAudioFrameCount(samples.count)) else {
+ return nil
+ }
+
+ buffer.frameLength = AVAudioFrameCount(samples.count)
+
+ // Efficient copy
+ guard let channelData = buffer.floatChannelData else { return nil }
+
+ // Use withUnsafeBufferPointer for safe memory access
+ samples.withUnsafeBufferPointer { samplePtr in
+ guard let baseAddress = samplePtr.baseAddress else { return }
+ // Copy memory from array to AVAudioPCMBuffer
+ // channelData[0] is UnsafeMutablePointer<Float>
+ channelData[0].update(from: baseAddress, count: samples.count)
+ }
+
+ return buffer
+ }
+
+ /// Structured concurrency wrapper for authorization
+ private func requestAuthorization() async -> SFSpeechRecognizerAuthorizationStatus {
+ await withCheckedContinuation { continuation in
+ SFSpeechRecognizer.requestAuthorization { status in
+ continuation.resume(returning: status)
+ }
+ }
+ }
+}
diff --git a/Sources/Fluid/UI/AISettingsView.swift b/Sources/Fluid/UI/AISettingsView.swift
index 6da6615f..71690d52 100644
--- a/Sources/Fluid/UI/AISettingsView.swift
+++ b/Sources/Fluid/UI/AISettingsView.swift
@@ -249,9 +249,7 @@ struct AISettingsView: View {
Image(systemName: "info.circle.fill")
.foregroundStyle(self.theme.palette.accent)
.font(.caption)
- Text(SettingsStore.shared.selectedSpeechModel.isWhisperModel
- ? "Whisper models support 99 languages and work on any Mac."
- : "Parakeet TDT uses CoreML and Neural Engine for fastest transcription (25 languages) on Apple Silicon.")
+ Text(self.modelDescriptionText)
.font(.caption)
.foregroundStyle(.secondary)
}
@@ -268,6 +266,21 @@ struct AISettingsView: View {
}
}
+ /// Returns the appropriate description text for the currently selected speech model
+ private var modelDescriptionText: String {
+ let model = SettingsStore.shared.selectedSpeechModel
+ switch model {
+ case .appleSpeech:
+ return "Apple Speech (Legacy) uses on-device recognition. No download required, works on Intel and Apple Silicon."
+ case .appleSpeechAnalyzer:
+ return "Apple Speech uses advanced on-device recognition with fast, accurate transcription. Requires macOS 26+."
+ case .parakeetTDT:
+ return "Parakeet TDT uses CoreML and Neural Engine for fastest transcription (25 languages) on Apple Silicon."
+ default:
+ return "Whisper models support 99 languages and work on any Mac."
+ }
+ }
+
private var modelStatusView: some View {
HStack(spacing: 12) {
if self.asr.isDownloadingModel || self.asr.isLoadingModel {