FluidVoice Development Roadmap: Platform Expansion, UI Automation, and AI Features

The FluidVoice development roadmap prioritizes macOS UI stability through automation, followed by native iOS and Windows ports, alongside continuous enhancements to on-device AI capabilities.

FluidVoice is an open-source macOS dictation application built on a modular Swift/SwiftUI architecture. The repository's source structure and documentation reveal a three-phase roadmap aimed at scaling from a stable macOS foundation to multi-platform availability while deepening AI-powered transcription features.

---

Core Architecture Supporting Roadmap Goals

The FluidVoice codebase is intentionally structured to enable platform portability. Understanding these foundations explains how the roadmap phases are technically feasible.

ASRService: The Cross-Platform Engine

The heart of FluidVoice is ASRService.swift, located at Sources/Fluid/Services/ASRService.swift. This service serializes audio capture, model management, and real-time inference across multiple speech recognition models including Parakeet, Nemotron, Whisper, and Apple Speech.

The service exposes a provider-agnostic API that does not depend on AppKit, making it portable to iOS and Windows targets. Key public methods include:

• downloadModel(_:progressHandler:) – Handles on-demand model fetching
• ensureAsrReady() – Prepares the selected model for inference
• start() – Begins audio capture and transcription

Application Bootstrap Pattern

The entry point at Sources/Fluid/fluidApp.swift demonstrates the service-wiring pattern that new platform targets will replicate:

@main
struct FluidApp: App {
    @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(MenuBarManager.shared)
        }
    }
}

This architecture separates service initialization from UI presentation, allowing platform-specific view layers to consume the same ASRService backend.

---

Phase 1: macOS UI Automation (Immediate Priority)

The first roadmap milestone focuses on release stability through comprehensive UI automation. This work is explicitly documented in docs/MACOS_UI_AUTOMATION_BRANCH_PLAN.md.

Automation Scope

The plan outlines a staged branch strategy with four phases:

1. Foundation – Add accessibility identifiers to all interactive UI elements
2. Deterministic Launch – Implement launch arguments that skip onboarding and preset app state
3. Smoke Suite – Create XCUITest coverage for critical user paths (dictation start/stop, model switching, transcription display)
4. CI Integration – Wire tests into GitHub Actions for regression detection

Implementation Targets

The automation plan specifically targets view files in Sources/Fluid/Views/, including:

• CommandModeView.swift – Voice command interface
• RewriteModeView.swift – Text transformation interface

Adding accessibility hooks to these views enables reliable automated interaction without altering user-facing behavior.

This phase is actively in progress. Landing this branch on main is the stated immediate priority before platform expansion work accelerates.

---

Phase 2: Native iOS and Windows Clients (Mid-Term)

Platform expansion to iOS and Windows is explicitly called out in the README: "iOS and Windows are on the way" with a wait-list page for interested users.

Technical Approach

The cross-platform strategy leverages the existing architecture:

Component	macOS	iOS	Windows
ASRService	✓ Reused	✓ Reused	✓ Reused (via Swift on Windows)
SwiftUI Views	AppKit-specific	UIKit adaptation	SwiftUI on Windows
Audio Capture	AVAudioEngine	AVAudioEngine	Platform abstraction
Hot-key System	NSEvent	UIKit gestures	Windows hooks

The README's platform roadmap (lines 19-21) indicates this work is in-progress but follows the automation milestone.

Code Portability Example

The model download pattern used on macOS will translate directly to iOS. From ASRService.swift (lines 511-528):

func ensureModelReady(_ model: SettingsStore.SpeechModel) async throws {
    // Kick off the download without changing the active model
    try await ASRService.shared.downloadModel(model, progressHandler: { progress in
        print("Download progress: \(Int(progress * 100))%")
    })
}

This async/await pattern with Combine-based progress reporting is equally valid on iOS and supported Swift-on-Windows targets.

Another Portable Pattern: Transcription Session Control

Starting dictation programmatically follows the same API across platforms:

func startDictation() async throws {
    // Ensure the selected model is loaded first
    try await ASRService.shared.ensureAsrReady()
    // Begin listening (the hot-key does the same under the hood)
    try await ASRService.shared.start()
}

Live Transcription Binding

For UI layers, the @Published property wrapper in ASRService (lines 74-78) enables reactive updates:

import Combine
import Fluid

class LiveTranscription: ObservableObject {
    @Published var text = ""

    private var cancellable: AnyCancellable?

    init() {
        // Bind to the published `partialTranscription` from the service
        cancellable = ASRService.shared.$partialTranscription
            .receive(on: DispatchQueue.main)
            .assign(to: \.text, on: self)
    }
}

This publisher-based pattern works identically in SwiftUI on macOS, iOS, and Windows.

---

Phase 3: Fluid Intelligence and Feature Enhancements (Ongoing)

Beyond platform expansion, the roadmap includes continuous improvement to AI capabilities and user experience.

Recent Enhancements (Version 1.6.0)

The README's "What's New in 1.6.0" section (lines 34-40) documents the project's feature release cadence:

• Parakeet speed improvements – Faster on-device inference
• Fluid Intelligence expansion – Enhanced on-device AI for transcription context
• Theming system – User-customizable appearance
• Onboarding refinements – Smoother first-launch experience

Future AI Development

The long-term roadmap includes:

• Open-sourcing Fluid Intelligence – The on-device AI layer currently proprietary will become available
• Per-app prompt configuration – Context-aware transcription tuned to specific applications
• Enhanced hot-key ergonomics – More customizable activation patterns
• Model download UX improvements – Better progress visibility and retry handling

These enhancements build atop the same ASRService foundation, ensuring they benefit all platform targets.

---

Key Files for Tracking Roadmap Progress

File	Roadmap Relevance
README.md	High-level vision, platform announcements, release notes
Sources/Fluid/Services/ASRService.swift	Core engine portable across all target platforms
Sources/Fluid/fluidApp.swift	Bootstrap pattern for new platform entry points
Sources/Fluid/Views/	UI layer targeted by automation; adaptation point for iOS
docs/MACOS_UI_AUTOMATION_BRANCH_PLAN.md	Concrete automation milestone plan
Package.swift	Swift Package Manager manifest ensuring cross-platform dependency resolution

---

Summary

The FluidVoice development roadmap follows a disciplined sequence:

• Immediate: Complete macOS UI automation with accessibility identifiers, XCUITest coverage, and CI integration
• Mid-term: Ship native iOS and Windows clients reusing the ASRService core
• Long-term: Expand Fluid Intelligence capabilities and open-source the on-device AI layer

This progression prioritizes stability before scale, ensuring the cross-platform architecture is battle-tested on macOS before replication.

---

Frequently Asked Questions

When will iOS and Windows versions of FluidVoice be available?

According to the README, iOS and Windows clients are actively in development with wait-list registration open. The team is prioritizing macOS UI automation stability—documented in docs/MACOS_UI_AUTOMATION_BRANCH_PLAN.md—before accelerating platform port work. No specific release dates are published, but the architecture in ASRService.swift is already designed for cross-platform reuse.

What is the macOS UI automation plan?

The automation plan is a four-phase initiative to add accessibility identifiers, deterministic launch arguments, XCUITest smoke suites, and CI integration. This work targets view files like CommandModeView.swift and RewriteModeView.swift in Sources/Fluid/Views/ without altering user-facing functionality. The goal is regression-free releases through automated testing.

What is Fluid Intelligence?

Fluid Intelligence is FluidVoice's on-device AI layer for transcription enhancement. Version 1.6.0 expanded these capabilities, and the long-term roadmap includes eventually open-sourcing this component. It operates within ASRService alongside other providers like Whisper and Parakeet.

Can I contribute to the roadmap implementation?

Yes. The repository structure supports contributions across all phases: the docs/ directory contains the automation plan for immediate milestone work, ASRService.swift offers the portable core for platform expansion, and the README tracks feature enhancement priorities. Issues and pull requests are tracked on the GitHub repository.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}