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
import AppKit
import Combine
import SwiftUI
@MainActor
final class VoiceEngineSettingsViewModel: ObservableObject {
let settings: SettingsStore
private let appServices: AppServices
private var cancellables = Set<AnyCancellable>()
let installations = SpeechModelInstallationSnapshot.shared
var asr: ASRService { self.appServices.asr }
var areSpeechModelActionsBlocked: Bool {
!self.installations.canUseModelActions
|| self.asr.isRunning
|| self.asr.deletingModelID != nil
|| self.asr.activeExclusiveActivity != nil
|| self.downloadingModel != nil
|| self.asr.hasActiveModelDownload
|| self.asr.hasActiveModelPreparation
|| self.asr.isCancellingModelPreparation
|| (!self.asr.isAsrReady && (self.asr.isDownloadingModel || self.asr.isLoadingModel))
}
@Published var modelSortOption: ModelSortOption = .provider
@Published var providerFilter: SpeechProviderFilter = .all
@Published var englishOnlyFilter: Bool = false
@Published var installedOnlyFilter: Bool = false
@Published var showSpeechFilters: Bool = false
@Published var selectedSpeechProvider: SettingsStore.SpeechModel.Provider
@Published var previewSpeechModel: SettingsStore.SpeechModel
@Published var showAdvancedSpeechInfo: Bool = false
var downloadingModel: SettingsStore.SpeechModel? {
guard let modelID = self.asr.downloadingModelId else { return nil }
return SettingsStore.SpeechModel.allCases.first { $0.id == modelID }
}
var downloadProgress: Double {
self.asr.downloadProgress ?? 0.0
}
var isCancellingModelDownload: Bool {
self.asr.isCancellingModelDownload
}
init(settings: SettingsStore, appServices: AppServices) {
self.settings = settings
self.appServices = appServices
self.previewSpeechModel = settings.selectedSpeechModel
self.selectedSpeechProvider = settings.selectedSpeechModel.provider
appServices.objectWillChange
.sink { [weak self] _ in
Task { @MainActor in
self?.objectWillChange.send()
}
}
.store(in: &self.cancellables)
self.installations.objectWillChange
.sink { [weak self] _ in
Task { @MainActor in self?.objectWillChange.send() }
}
.store(in: &self.cancellables)
}
func onAppear() {
self.previewSpeechModel = self.settings.selectedSpeechModel
self.selectedSpeechProvider = self.settings.selectedSpeechModel.provider
self.installations.refresh()
Task {
let catalog = CompactSpeechModelReleaseCatalog.shared
let revision = catalog.revision
await catalog.refreshIfNeeded()
if catalog.revision != revision { self.installations.refresh() }
}
}
func handleSelectedSpeechModelChange(_ newValue: SettingsStore.SpeechModel) {
self.previewSpeechModel = newValue
self.setSelectedSpeechProvider(newValue.provider)
}
var filteredSpeechModels: [SettingsStore.SpeechModel] {
var models = SettingsStore.SpeechModel.availableModels
switch self.providerFilter {
case .all:
break
case .nvidia:
models = models.filter { $0.provider == .nvidia }
case .apple:
models = models.filter { $0.provider == .apple }
case .cohere:
models = models.filter { $0.provider == .cohere }
case .openai:
models = models.filter { $0.provider == .openai }
case .qwen:
models = models.filter { $0.provider == .qwen }
}
if self.englishOnlyFilter {
models = models.filter { model in
let label = model.languageSupport.lowercased()
let title = model.humanReadableName.lowercased()
return label.contains("english only") || title.contains("english")
}
}
if self.installedOnlyFilter {
models = models.filter { self.isSpeechModelInstalled($0) }
}
switch self.modelSortOption {
case .provider:
models.sort { $0.brandName.localizedCaseInsensitiveCompare($1.brandName) == .orderedAscending }
case .accuracy:
models.sort { $0.accuracyPercent > $1.accuracyPercent }
case .speed:
models.sort { $0.speedPercent > $1.speedPercent }
}
return models
}
func activateSpeechModel(_ model: SettingsStore.SpeechModel) {
guard !self.areSpeechModelActionsBlocked else { return }
withAnimation(.spring(response: 0.3, dampingFraction: 0.7)) {
self.settings.selectedSpeechModel = model
self.previewSpeechModel = model
self.setSelectedSpeechProvider(model.provider)
}
self.asr.resetTranscriptionProvider()
Task {
do {
try await self.asr.ensureAsrReady(source: .settings)
} catch is CancellationError {
DebugLogger.shared.info("Model activation cancelled: \(model.displayName)", source: "AISettingsView")
} catch {
DebugLogger.shared.error("Failed to prepare model after activation: \(error)", source: "AISettingsView")
self.asr.errorTitle = "Model Activation Failed"
self.asr.errorMessage = error.localizedDescription
self.asr.showError = true
}
}
}
/// The analyzer provider binds its locale during preparation, so a new locale needs a
/// provider reset. Preparation downloads the locale's model when it isn't installed.
func selectAppleSpeechLocale(_ localeIdentifier: String) {
guard !self.areSpeechModelActionsBlocked,
localeIdentifier != self.settings.selectedAppleSpeechLocaleIdentifier
else { return }
self.settings.selectedAppleSpeechLocaleIdentifier = localeIdentifier
self.asr.resetTranscriptionProvider()
Task {
do {
try await self.asr.ensureAsrReady(source: .settings)
} catch is CancellationError {
DebugLogger.shared.info("Apple Speech locale change cancelled: \(localeIdentifier)", source: "AISettingsView")
} catch {
DebugLogger.shared.error("Failed to prepare Apple Speech locale \(localeIdentifier): \(error)", source: "AISettingsView")
self.asr.errorTitle = "Language Change Failed"
self.asr.errorMessage = error.localizedDescription
self.asr.showError = true
}
}
}
func downloadSpeechModel(_ model: SettingsStore.SpeechModel, updateWeights: Bool = false) {
guard !self.areSpeechModelActionsBlocked else { return }
Task { [weak self] in
guard let self else { return }
do {
try await self.asr.downloadModel(model, updateWeights: updateWeights, progressHandler: nil)
DebugLogger.shared.info("Model download completed: \(model.displayName)", source: "VoiceEngineVM")
} catch is CancellationError {
DebugLogger.shared.info("Model download cancelled: \(model.displayName)", source: "VoiceEngineVM")
} catch {
DebugLogger.shared.error("Failed to download model \(model.displayName): \(error)", source: "VoiceEngineVM")
if let failure = error as? ParakeetArchiveDownloader.DownloadError, case .replacementCleanupFailed = failure {
self.asr.errorTitle = "Model Updated"
} else {
self.asr.errorTitle = updateWeights ? "Model Update Failed" : "Model Download Failed"
}
self.asr.errorMessage = error.localizedDescription
self.asr.showError = true
}
}
}
func cancelSpeechModelDownload() {
guard self.downloadingModel != nil, !self.isCancellingModelDownload else { return }
self.asr.cancelModelDownload()
}
func cancelActiveModelPreparation() {
self.asr.cancelModelPreparation()
}
func deleteSpeechModel(_ model: SettingsStore.SpeechModel) {
guard !self.areSpeechModelActionsBlocked else { return }
Task {
await self.deleteModels(model)
}
}
func isActiveSpeechModel(_ model: SettingsStore.SpeechModel) -> Bool {
self.settings.selectedSpeechModel == model
}
func isSpeechModelInstalled(_ model: SettingsStore.SpeechModel) -> Bool {
self.installations.isInstalled(modelID: model.id)
}
func isSpeechModelUpdateAvailable(_ model: SettingsStore.SpeechModel) -> Bool {
self.installations.updateAvailableIDs.contains(model.id)
}
func speechModelDownloadSize(_ model: SettingsStore.SpeechModel) -> String {
self.installations.latestDescriptors[model.id]?.downloadSize ?? model.downloadSize
}
var modelDescriptionText: String {
let model = self.settings.selectedSpeechModel
switch model {
case .appleSpeech:
return "Apple Speech (Legacy) uses built-in macOS speech recognition. No model 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 v3 uses CoreML and Neural Engine for fastest transcription (25 languages) on Apple Silicon."
case .parakeetTDTv2:
return "Parakeet TDT v2 is an English-only model optimized for accuracy and consistency on Apple Silicon."
case .fluidParakeetMini, .fluidParakeetPico, .fluidParakeetPro:
return "\(model.cardDescription) Requires Apple silicon."
case .parakeetRealtime:
return "Parakeet Flash uses FluidAudio's true streaming EOU pipeline for low-latency English dictation. Best when you want words to appear live as you speak."
case .qwen3Asr:
return "Qwen3 ASR is a multilingual FluidAudio model with strong quality, but higher memory usage. Requires macOS 15+."
case .qwen3Asr17B:
return "On-device dictation for Apple Silicon. Automatically detects 30 languages and produces text after you stop recording."
case .cohereTranscribeSixBit:
return "Cohere Transcribe downloads a CoreML pipeline from Hugging Face and caches it locally. Select the language manually before dictation. Best on Apple Silicon with 8GB+ RAM."
case .nemotronOffline:
return "Nemotron 3.5 Multilingual is slower but more accurate. Supports around 40 languages with auto or manual language selection. Best on Apple Silicon with 8GB+ RAM."
case .nemotronStreaming, .nemotronStreaming320:
return "Nemotron Speech 3.5 Streaming Capable uses NVIDIA's streaming CoreML pipeline. Supports around 40 languages with auto or manual language selection."
default:
return "Whisper models support 99 languages and work on any Mac."
}
}
func downloadModels() async {
do {
try await self.asr.ensureAsrReady(source: .settings)
} catch is CancellationError {
DebugLogger.shared.info("Model download cancelled", source: "AISettingsView")
} catch {
DebugLogger.shared.error("Failed to download models: \(error)", source: "AISettingsView")
self.asr.errorTitle = "Model Download Failed"
self.asr.errorMessage = error.localizedDescription
self.asr.showError = true
}
}
func deleteModels(_ model: SettingsStore.SpeechModel? = nil) async {
let target = model ?? self.settings.selectedSpeechModel
do {
try await self.asr.clearModelCache(for: target)
} catch {
DebugLogger.shared.error("Failed to delete model \(target.displayName): \(error)", source: "AISettingsView")
self.asr.errorTitle = "Model Deletion Failed"
self.asr.errorMessage = error.localizedDescription
self.asr.showError = true
}
// Inactive-model deletion must refresh its card without switching the active model.
self.objectWillChange.send()
}
func setSelectedSpeechProvider(_ provider: SettingsStore.SpeechModel.Provider) {
self.selectedSpeechProvider = provider
}
func openExternalModelSource(for model: SettingsStore.SpeechModel) {
guard let url = model.externalCoreMLSpec?.sourceURL else { return }
NSWorkspace.shared.open(url)
}
}