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
feat: Add memory safety checks and UX improvements for large Whisper models
altic-devfca453b246ee
diff --git a/Sources/Fluid/ContentView.swift b/Sources/Fluid/ContentView.swiftindex a6f73ed3..efa94b82 100644--- a/Sources/Fluid/ContentView.swift+++ b/Sources/Fluid/ContentView.swift@@ -1409,13 +1409,24 @@ struct ContentView: View {// Don't reset overlay mode here - let it stay colored until it hides}+ // Show "Transcribing..." state before calling stop() to keep overlay visible.+ // The asr.stop() call performs the final transcription which can take a moment+ // (especially for slower models like Whisper Medium/Large).+ DebugLogger.shared.debug("Showing transcription processing state", source: "ContentView")+ self.menuBarManager.setProcessing(true)+ NotchOverlayManager.shared.updateTranscriptionText("Transcribing...")+// Stop the ASR service and wait for transcription to complete- // This will set isRunning = false, which triggers overlay hide- // The overlay will hide while still showing the correct mode color (no gray transition)+ // The processing indicator will stay visible during this phaselet transcribedText = await asr.stop()+ // Reset the transcription text display after transcription completes+ NotchOverlayManager.shared.updateTranscriptionText("")+guard transcribedText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false else {DebugLogger.shared.debug("Transcription returned empty text", source: "ContentView")+ // Hide processing state when returning early+ self.menuBarManager.setProcessing(false)return}@@ -1428,11 +1439,12 @@ struct ContentView: View {guard DictationAIPostProcessingGate.isConfigured() else {promptTest.lastError = "AI post-processing is not configured. Enable AI Enhancement and configure a provider/model (and API key for non-local endpoints)."+ self.menuBarManager.setProcessing(false)return}promptTest.isProcessing = true- self.menuBarManager.setProcessing(true)+ // Processing already true from abovedefer {self.menuBarManager.setProcessing(false)promptTest.isProcessing = false@@ -1482,8 +1494,8 @@ struct ContentView: View {if shouldUseAI {DebugLogger.shared.debug("Routing transcription through AI post-processing", source: "ContentView")- // Show processing animation in notch- self.menuBarManager.setProcessing(true)+ // Update overlay text to show we're now refining (processing already true)+ NotchOverlayManager.shared.updateTranscriptionText("Refining...")finalText = await self.processTextWithAI(transcribedText)@@ -1491,6 +1503,8 @@ struct ContentView: View {self.menuBarManager.setProcessing(false)} else {finalText = transcribedText+ // No AI processing, hide the processing state+ self.menuBarManager.setProcessing(false)}// Apply GAAV formatting as the FINAL step (after AI post-processing)diff --git a/Sources/Fluid/Persistence/SettingsStore.swift b/Sources/Fluid/Persistence/SettingsStore.swiftindex a3f6494c..53ab1c94 100644--- a/Sources/Fluid/Persistence/SettingsStore.swift+++ b/Sources/Fluid/Persistence/SettingsStore.swift@@ -1453,7 +1453,7 @@ final class SettingsStore: ObservableObject {case whisperBase = "whisper-base"case whisperSmall = "whisper-small"case whisperMedium = "whisper-medium"- // case whisperLargeTurbo = "whisper-large-turbo" // buggy - so removed temporarily+ case whisperLargeTurbo = "whisper-large-turbo" // temporarily disabled in UIcase whisperLarge = "whisper-large"var id: String { rawValue }@@ -1470,7 +1470,7 @@ final class SettingsStore: ObservableObject {case .whisperBase: return "Whisper Base"case .whisperSmall: return "Whisper Small"case .whisperMedium: return "Whisper Medium"- // case .whisperLargeTurbo: return "Whisper Large Turbo" // buggy - so removed temporarily+ case .whisperLargeTurbo: return "Whisper Large Turbo (Disabled)"case .whisperLarge: return "Whisper Large"}}@@ -1481,7 +1481,7 @@ final class SettingsStore: ObservableObject {case .parakeetTDTv2: return "English Only (Higher Accuracy)"case .appleSpeech: return "System Languages"case .appleSpeechAnalyzer: return "EN, ES, FR, DE, IT, JA, KO, PT, ZH"- case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, /* .whisperLargeTurbo, */ .whisperLarge: // buggy - so removed temporarily+ case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, .whisperLargeTurbo, .whisperLarge:return "99 Languages"}}@@ -1496,7 +1496,7 @@ final class SettingsStore: ObservableObject {case .whisperBase: return "~142 MB"case .whisperSmall: return "~466 MB"case .whisperMedium: return "~1.5 GB"- // case .whisperLargeTurbo: return "~1.6 GB" // buggy - so removed temporarily+ case .whisperLargeTurbo: return "~1.6 GB"case .whisperLarge: return "~2.9 GB"}}@@ -1522,7 +1522,7 @@ final class SettingsStore: ObservableObject {case .whisperBase: return "ggml-base.bin"case .whisperSmall: return "ggml-small.bin"case .whisperMedium: return "ggml-medium.bin"- // case .whisperLargeTurbo: return "ggml-large-v3-turbo.bin" // buggy - so removed temporarily+ case .whisperLargeTurbo: return "ggml-large-v3-turbo.bin"case .whisperLarge: return "ggml-large-v3.bin"default: return nil}@@ -1535,7 +1535,7 @@ final class SettingsStore: ObservableObject {case .whisperBase: return "base"case .whisperSmall: return "small"case .whisperMedium: return "medium"- // case .whisperLargeTurbo: return "large-v3-turbo" // buggy - so removed temporarily+ case .whisperLargeTurbo: return "large-v3-turbo"case .whisperLarge: return "large-v3"default: return nil}@@ -1554,6 +1554,9 @@ final class SettingsStore: ObservableObject {/// Returns models available for the current Mac's architecture and OSstatic var availableModels: [SpeechModel] {allCases.filter { model in+ if model == .whisperLargeTurbo {+ return false+ }// Filter by Apple Silicon requirementif model.requiresAppleSilicon, !CPUArchitecture.isAppleSilicon {return false@@ -1588,7 +1591,7 @@ final class SettingsStore: ObservableObject {case .whisperBase: return "Standard Choice"case .whisperSmall: return "Balanced Speed & Accuracy"case .whisperMedium: return "Medium Quality"- // case .whisperLargeTurbo: return "Higher Quality but Faster" // buggy - so removed temporarily+ case .whisperLargeTurbo: return "Higher Quality but Faster"case .whisperLarge: return "Maximum Accuracy"}}@@ -1612,13 +1615,49 @@ final class SettingsStore: ObservableObject {return "Better accuracy than Base. Moderate resource usage."case .whisperMedium:return "High accuracy for demanding tasks. Requires more memory."- // case .whisperLargeTurbo: // buggy - so removed temporarily- // return "Near-maximum accuracy with optimized speed."+ case .whisperLargeTurbo:+ return "Near-maximum accuracy with optimized speed."case .whisperLarge:return "Best possible accuracy. Large download and memory usage."}}+ /// Minimum recommended RAM in GB for this model to run safely+ var requiredMemoryGB: Double {+ switch self {+ case .parakeetTDT, .parakeetTDTv2:+ return 4.0+ case .appleSpeech, .appleSpeechAnalyzer:+ return 2.0 // Built-in, minimal overhead+ case .whisperTiny:+ return 2.0+ case .whisperBase:+ return 3.0+ case .whisperSmall:+ return 4.0+ case .whisperMedium:+ return 6.0+ case .whisperLargeTurbo:+ return 8.0+ case .whisperLarge:+ return 10.0 // Large model needs ~6-8GB working memory + model size+ }+ }++ /// Warning text for models with high memory requirements, nil if no warning needed+ var memoryWarning: String? {+ switch self {+ case .whisperLarge:+ return "⚠️ Requires 10GB+ RAM. May crash on systems with limited memory."+ case .whisperLargeTurbo:+ return "⚠️ Requires 8GB+ RAM. May be unstable on some systems."+ case .whisperMedium:+ return "Requires 6GB+ RAM for stable operation."+ default:+ return nil+ }+ }+/// Speed rating (1-5, higher is faster)var speedRating: Int {switch self {@@ -1630,7 +1669,7 @@ final class SettingsStore: ObservableObject {case .whisperBase: return 4case .whisperSmall: return 3case .whisperMedium: return 2- // case .whisperLargeTurbo: return 3 // buggy - so removed temporarily+ case .whisperLargeTurbo: return 3case .whisperLarge: return 1}}@@ -1646,7 +1685,7 @@ final class SettingsStore: ObservableObject {case .whisperBase: return 3case .whisperSmall: return 4case .whisperMedium: return 4- // case .whisperLargeTurbo: return 5 // buggy - so removed temporarily+ case .whisperLargeTurbo: return 5case .whisperLarge: return 5}}@@ -1662,7 +1701,7 @@ final class SettingsStore: ObservableObject {case .whisperBase: return 0.80case .whisperSmall: return 0.60case .whisperMedium: return 0.40- // case .whisperLargeTurbo: return 0.65 // buggy - so removed temporarily+ case .whisperLargeTurbo: return 0.65case .whisperLarge: return 0.20}}@@ -1678,7 +1717,7 @@ final class SettingsStore: ObservableObject {case .whisperBase: return 0.60case .whisperSmall: return 0.70case .whisperMedium: return 0.80- // case .whisperLargeTurbo: return 0.95 // buggy - so removed temporarily+ case .whisperLargeTurbo: return 0.95case .whisperLarge: return 1.00}}@@ -1707,7 +1746,7 @@ final class SettingsStore: ObservableObject {/// Large Whisper models are too slow for streaming, so they only do final transcription on stop.var supportsStreaming: Bool {switch self {- case .whisperMedium, .whisperLarge: // .whisperLargeTurbo - buggy - so removed temporarily+ case .whisperMedium, .whisperLargeTurbo, .whisperLarge:return false // Too slow for real-time chunk processingdefault:return true // All other models support streaming@@ -1728,7 +1767,7 @@ final class SettingsStore: ObservableObject {return .nvidiacase .appleSpeech, .appleSpeechAnalyzer:return .apple- case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, /* .whisperLargeTurbo, */ .whisperLarge: // buggy - so removed temporarily+ case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, .whisperLargeTurbo, .whisperLarge:return .openai}}@@ -1778,7 +1817,7 @@ final class SettingsStore: ObservableObject {return "NVIDIA"case .appleSpeech, .appleSpeechAnalyzer:return "Apple"- case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, /* .whisperLargeTurbo, */ .whisperLarge: // buggy - so removed temporarily+ case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, .whisperLargeTurbo, .whisperLarge:return "OpenAI"}}@@ -1798,7 +1837,7 @@ final class SettingsStore: ObservableObject {return "#76B900"case .appleSpeech, .appleSpeechAnalyzer:return "#A2AAAD" // Apple Gray- case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, /* .whisperLargeTurbo, */ .whisperLarge: // buggy - so removed temporarily+ case .whisperTiny, .whisperBase, .whisperSmall, .whisperMedium, .whisperLargeTurbo, .whisperLarge:return "#10A37F" // OpenAI Teal}}diff --git a/Sources/Fluid/Services/ASRService.swift b/Sources/Fluid/Services/ASRService.swiftindex 7c22bdeb..134166f2 100644--- a/Sources/Fluid/Services/ASRService.swift+++ b/Sources/Fluid/Services/ASRService.swift@@ -40,6 +40,24 @@ private actor TranscriptionExecutor {}}+private actor ModelDownloadRegistry {+ private var tasks: [String: Task<Void, Error>] = [:]++ func run(for key: String, operation: @escaping () async throws -> Void) async throws {+ if let existing = tasks[key] {+ return try await existing.value+ }++ let task = Task {+ try await operation()+ }+ self.tasks[key] = task+ defer { tasks[key] = nil }++ try await task.value+ }+}+/// A comprehensive speech recognition service that handles real-time audio transcription.////// This service manages the entire ASR (Automatic Speech Recognition) pipeline including:@@ -93,6 +111,7 @@ final class ASRService: ObservableObject {private var downloadProgressTask: Task<Void, Never>?private var hasCompletedFirstTranscription: Bool = false // Track if model has warmed up with first transcription+ private let downloadRegistry = ModelDownloadRegistry()// MARK: - Error Handling@@ -225,18 +244,35 @@ final class ASRService: ObservableObject {/// - model: The model to download/// - progressHandler: Optional callback for download progress (0.0 to 1.0)func downloadModel(_ model: SettingsStore.SpeechModel, progressHandler: ((Double) -> Void)?) async throws {- DebugLogger.shared.info("Downloading model: \(model.displayName) (without changing active selection)", source: "ASRService")+ try await self.downloadRegistry.run(for: model.id) { [weak self] in+ guard let self else { return }- // Get a fresh provider for this specific model (uses modelOverride for Whisper)- let provider = self.getProvider(for: model)+ await MainActor.run {+ self.downloadingModelId = model.id+ }- // Prepare (download) the model- try await provider.prepare(progressHandler: { progress in- let clamped = max(0.0, min(1.0, progress))- progressHandler?(clamped)- })+ defer {+ Task { @MainActor [weak self] in+ guard let self else { return }+ if self.downloadingModelId == model.id {+ self.downloadingModelId = nil+ }+ }+ }++ DebugLogger.shared.info("Downloading model: \(model.displayName) (without changing active selection)", source: "ASRService")- DebugLogger.shared.info("Model download completed: \(model.displayName)", source: "ASRService")+ // Get a fresh provider for this specific model (uses modelOverride for Whisper)+ let provider = await MainActor.run { self.getProvider(for: model) }++ // Prepare (download) the model+ try await provider.prepare(progressHandler: { progress in+ let clamped = max(0.0, min(1.0, progress))+ progressHandler?(clamped)+ })++ DebugLogger.shared.info("Model download completed: \(model.displayName)", source: "ASRService")+ }}/// Call this when the transcription provider setting changes to reset statediff --git a/Sources/Fluid/Services/FluidAudioProvider.swift b/Sources/Fluid/Services/FluidAudioProvider.swiftindex 0822d526..fe125c4c 100644--- a/Sources/Fluid/Services/FluidAudioProvider.swift+++ b/Sources/Fluid/Services/FluidAudioProvider.swift@@ -64,8 +64,9 @@ final class FluidAudioProvider: TranscriptionProvider {func modelsExistOnDisk() -> Bool {let baseCacheDir = AsrModels.defaultCacheDirectory().deletingLastPathComponent()+ let selectedModel = self.modelOverride ?? SettingsStore.shared.selectedSpeechModel- if SettingsStore.shared.selectedSpeechModel == .parakeetTDTv2 {+ if selectedModel == .parakeetTDTv2 {let v2CacheDir = baseCacheDir.appendingPathComponent("parakeet-tdt-0.6b-v2-coreml")return FileManager.default.fileExists(atPath: v2CacheDir.path)} else {@@ -76,7 +77,7 @@ final class FluidAudioProvider: TranscriptionProvider {func clearCache() async throws {let baseCacheDir = AsrModels.defaultCacheDirectory().deletingLastPathComponent()- let selectedModel = SettingsStore.shared.selectedSpeechModel+ let selectedModel = self.modelOverride ?? SettingsStore.shared.selectedSpeechModelif selectedModel == .parakeetTDTv2 {// Clear v2 cache onlydiff --git a/Sources/Fluid/Services/GlobalHotkeyManager.swift b/Sources/Fluid/Services/GlobalHotkeyManager.swiftindex 7f0e5fc5..24bbf4d2 100644--- a/Sources/Fluid/Services/GlobalHotkeyManager.swift+++ b/Sources/Fluid/Services/GlobalHotkeyManager.swift@@ -3,6 +3,25 @@ import Foundation@MainActorfinal class GlobalHotkeyManager: NSObject {+ private final class HotkeyState: @unchecked Sendable {+ private let lock = NSLock()+ var isKeyPressed = false+ var isCommandModeKeyPressed = false+ var isRewriteKeyPressed = false+ var modifierOnlyKeyDown = false+ var otherKeyPressedDuringModifier = false+ var modifierPressStartTime: Date?+ var pendingHoldModeStart: Task<Void, Never>?+ var pendingHoldModeType: HoldModeType?++ func withLock<T>(_ block: () -> T) -> T {+ self.lock.lock()+ defer { self.lock.unlock() }+ return block()+ }+ }++ private let state = HotkeyState()private nonisolated(unsafe) var eventTap: CFMachPort?private nonisolated(unsafe) var runLoopSource: CFRunLoopSource?private let asrService: ASRService@@ -17,21 +36,49 @@ final class GlobalHotkeyManager: NSObject {private var rewriteModeCallback: (() async -> Void)?private var cancelCallback: (() -> Bool)? // Returns true if handledprivate var pressAndHoldMode: Bool = SettingsStore.shared.pressAndHoldMode- // These state flags are accessed from CGEvent tap callback (may run off main thread)- // and @MainActor tasks. Marked nonisolated(unsafe) since they're simple booleans- // with effectively atomic reads/writes, and the event tap runs on main run loop.- private nonisolated(unsafe) var isKeyPressed = false- private nonisolated(unsafe) var isCommandModeKeyPressed = false- private nonisolated(unsafe) var isRewriteKeyPressed = false++ private nonisolated var isKeyPressed: Bool {+ get { self.state.withLock { self.state.isKeyPressed } }+ set { self.state.withLock { self.state.isKeyPressed = newValue } }+ }++ private nonisolated var isCommandModeKeyPressed: Bool {+ get { self.state.withLock { self.state.isCommandModeKeyPressed } }+ set { self.state.withLock { self.state.isCommandModeKeyPressed = newValue } }+ }++ private nonisolated var isRewriteKeyPressed: Bool {+ get { self.state.withLock { self.state.isRewriteKeyPressed } }+ set { self.state.withLock { self.state.isRewriteKeyPressed = newValue } }+ }// Modifier-only shortcut tracking: detect if another key was pressed during modifier hold- private nonisolated(unsafe) var modifierOnlyKeyDown = false- private nonisolated(unsafe) var otherKeyPressedDuringModifier = false+ private nonisolated var modifierOnlyKeyDown: Bool {+ get { self.state.withLock { self.state.modifierOnlyKeyDown } }+ set { self.state.withLock { self.state.modifierOnlyKeyDown = newValue } }+ }++ private nonisolated var otherKeyPressedDuringModifier: Bool {+ get { self.state.withLock { self.state.otherKeyPressedDuringModifier } }+ set { self.state.withLock { self.state.otherKeyPressedDuringModifier = newValue } }+ }+// Reserved for future tap-vs-hold timing detection (e.g., quick tap to toggle vs long hold)- private var modifierPressStartTime: Date?- private nonisolated(unsafe) var pendingHoldModeStart: Task<Void, Never>?+ private nonisolated var modifierPressStartTime: Date? {+ get { self.state.withLock { self.state.modifierPressStartTime } }+ set { self.state.withLock { self.state.modifierPressStartTime = newValue } }+ }++ private nonisolated var pendingHoldModeStart: Task<Void, Never>? {+ get { self.state.withLock { self.state.pendingHoldModeStart } }+ set { self.state.withLock { self.state.pendingHoldModeStart = newValue } }+ }+// Tracks which mode's pending start is active (for cancellation on key combos)- private var pendingHoldModeType: HoldModeType?+ private nonisolated var pendingHoldModeType: HoldModeType? {+ get { self.state.withLock { self.state.pendingHoldModeType } }+ set { self.state.withLock { self.state.pendingHoldModeType = newValue } }+ }private enum HoldModeType {case transcriptiondiff --git a/Sources/Fluid/Services/MeetingTranscriptionService.swift b/Sources/Fluid/Services/MeetingTranscriptionService.swiftindex 4bf864e5..8ec944aa 100644--- a/Sources/Fluid/Services/MeetingTranscriptionService.swift+++ b/Sources/Fluid/Services/MeetingTranscriptionService.swift@@ -218,6 +218,13 @@ final class MeetingTranscriptionService: ObservableObject {self.currentStatus = "Transcribing... \(Int(progressPercent * 100))%"}+ if allTranscriptions.isEmpty {+ DebugLogger.shared.warning(+ "No audio chunks were long enough to transcribe (minimum 1 second required)",+ source: "MeetingTranscriptionService"+ )+ }+// Combine all chunk transcriptionslet finalText = allTranscriptions.joined(separator: " ")let avgConfidence = chunkCount > 0 ? totalConfidence / Float(chunkCount) : 0@@ -377,7 +384,7 @@ final class MeetingTranscriptionService: ObservableObject {converter.convert(to: outputBuffer, error: &error) { _, outStatus inif inputConsumed {- outStatus.pointee = .noDataNow+ outStatus.pointee = .endOfStreamreturn nil}inputConsumed = truediff --git a/Sources/Fluid/Services/WhisperProvider.swift b/Sources/Fluid/Services/WhisperProvider.swiftindex c22d7c9c..d25825a5 100644--- a/Sources/Fluid/Services/WhisperProvider.swift+++ b/Sources/Fluid/Services/WhisperProvider.swift@@ -136,6 +136,34 @@ final class WhisperProvider: TranscriptionProvider {)}+ // Check available memory before loading large models+ let selectedModel = self.modelOverride ?? SettingsStore.shared.selectedSpeechModel+ let requiredMemoryGB = selectedModel.requiredMemoryGB+ let availableMemoryGB = Self.availableMemoryGB()++ DebugLogger.shared.info(+ "WhisperProvider: Memory check - Required: \(String(format: "%.1f", requiredMemoryGB))GB, Available: \(String(format: "%.1f", availableMemoryGB))GB",+ source: "WhisperProvider"+ )++ if availableMemoryGB < requiredMemoryGB {+ let errorMessage = """+ Insufficient memory for \(selectedModel.displayName).+ Required: \(String(format: "%.1f", requiredMemoryGB)) GB+ Available: \(String(format: "%.1f", availableMemoryGB)) GB++ Please try a smaller model (e.g., Whisper Base or Small) or close other applications to free up memory.+ """++ DebugLogger.shared.error("WhisperProvider: \(errorMessage)", source: "WhisperProvider")++ throw NSError(+ domain: "WhisperProvider",+ code: -4,+ userInfo: [NSLocalizedDescriptionKey: errorMessage]+ )+ }+// Load the modelDebugLogger.shared.info("WhisperProvider: Loading Whisper model...", source: "WhisperProvider")self.whisper = Whisper(fromFileURL: self.modelURL)@@ -145,6 +173,37 @@ final class WhisperProvider: TranscriptionProvider {DebugLogger.shared.info("WhisperProvider: Model ready (\(currentModelName))", source: "WhisperProvider")}+ /// Returns the available system memory in GB+ private static func availableMemoryGB() -> Double {+ var pageSize: vm_size_t = 0+ host_page_size(mach_host_self(), &pageSize)++ var vmStats = vm_statistics64()+ var count = mach_msg_type_number_t(MemoryLayout<vm_statistics64>.size / MemoryLayout<integer_t>.size)++ let result = withUnsafeMutablePointer(to: &vmStats) { pointer in+ pointer.withMemoryRebound(to: integer_t.self, capacity: Int(count)) { intPointer in+ host_statistics64(mach_host_self(), HOST_VM_INFO64, intPointer, &count)+ }+ }++ guard result == KERN_SUCCESS else {+ // Fallback: assume we have enough memory if we can't check+ DebugLogger.shared.warning("WhisperProvider: Failed to get memory stats, assuming sufficient memory", source: "WhisperProvider")+ return 16.0+ }++ // Calculate free + inactive memory (memory that can be reclaimed)+ let freePages = UInt64(vmStats.free_count)+ let inactivePages = UInt64(vmStats.inactive_count)+ let purgablePages = UInt64(vmStats.purgeable_count)++ let availableBytes = (freePages + inactivePages + purgablePages) * UInt64(pageSize)+ let availableGB = Double(availableBytes) / (1024 * 1024 * 1024)++ return availableGB+ }+func transcribe(_ samples: [Float]) async throws -> ASRTranscriptionResult {// Whisper.cpp asserts on very short buffers; guard early to avoid abort.let minSamples = 16_000diff --git a/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swift b/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swiftindex e25f5531..00ea45e7 100644--- a/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swift+++ b/Sources/Fluid/UI/AISettings/VoiceEngineSettingsViewModel.swift@@ -113,6 +113,8 @@ final class VoiceEngineSettingsViewModel: ObservableObject {func downloadSpeechModel(_ model: SettingsStore.SpeechModel) {guard !self.asr.isRunning else { return }guard self.downloadingModel == nil else { return } // Prevent concurrent downloads+ self.downloadingModel = model+ self.downloadProgress = 0.0Task {// Mark this model as downloadingdiff --git a/Sources/Fluid/UI/AISettingsView+SpeechRecognition.swift b/Sources/Fluid/UI/AISettingsView+SpeechRecognition.swiftindex 54c410cc..11c2c8a9 100644--- a/Sources/Fluid/UI/AISettingsView+SpeechRecognition.swift+++ b/Sources/Fluid/UI/AISettingsView+SpeechRecognition.swift@@ -198,6 +198,28 @@ extension VoiceEngineSettingsView {Spacer()}++ // Memory warning for large models+ if let memoryWarning = model.memoryWarning {+ HStack(spacing: 6) {+ Image(systemName: "exclamationmark.triangle.fill")+ .font(.caption2)+ .foregroundStyle(.orange)+ Text(memoryWarning)+ .font(.caption2)+ .foregroundStyle(.orange)+ }+ .padding(.horizontal, 8)+ .padding(.vertical, 4)+ .background(+ RoundedRectangle(cornerRadius: 6)+ .fill(.orange.opacity(0.1))+ .overlay(+ RoundedRectangle(cornerRadius: 6)+ .stroke(.orange.opacity(0.3), lineWidth: 1)+ )+ )+ }}.frame(maxWidth: .infinity, alignment: .leading)