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.plistindex 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.swiftindex 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 falsedefault: 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 OSstatic 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.swiftindex 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-instantiationprivate 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 modelvar activeProviderName: String {SettingsStore.shared.selectedSpeechModel.displayName@@ -150,16 +185,20 @@ final class ASRService: ObservableObject {/// Call this when the transcription provider setting changes to reset statefunc resetTranscriptionProvider() {+ let newModel = SettingsStore.shared.selectedSpeechModel+ DebugLogger.shared.info("ASRService: Switching to '\(newModel.displayName)', resetting provider state...", source: "ASRService")+self.isAsrReady = falseself.modelsExistOnDisk = falseself.ensureReadyTask?.cancel()self.ensureReadyTask = nilself.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 downloadedself.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.swiftnew file mode 100644index 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.swiftnew file mode 100644index 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.swiftindex 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 {