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

22.1 KB
Raw Blame
import AppKit
import SwiftUI

// Extracted product colors; no SettingsStore, audio, models, or production callbacks.
enum FluidBrandColors { static let blue = Color(red: 0.10, green: 0.46, blue: 1) }
enum AppTheme { enum Metrics { enum Showcase { static let cardRadius: CGFloat = 24 } } }

/// One bounded clock makes pause/scrub deterministic. No clock remains at rest.
@MainActor final class SequencePlayer: ObservableObject {
    static let duration = 25.0
    @Published var time = 0.0
    @Published private(set) var playing = false
    @Published var slow = false
    @Published private(set) var demoActive = false
    var canActivate: Bool { time >= 13.4 }
    func toggleDemo() {
        guard canActivate else { return }
        pause()
        demoActive.toggle()
    }
    private var timer: Timer?
    private var lastTick = 0.0
    private var intervals: [Double] = []
    private(set) var tickCount = 0
    var stage: String {
        switch time {
        case ..<3.4: return "Overlay arrives"
        case ..<4.3: return "Mode chip"
        case ..<7.3: return "Basic and Smart"
        case ..<10.0: return "Smart selected"
        case ..<13.4: return "Shortcut"
        case ..<19.5: return "Correction example"
        default: return "Numbered list example"
        }
    }
    func play() {
        guard timer == nil else { return }
        if time >= Self.duration { time = 0 }
        playing = true
        lastTick = ProcessInfo.processInfo.systemUptime
        let timer = Timer(timeInterval: 1 / 60, repeats: true) { [weak self] _ in
            MainActor.assumeIsolated { self?.tick() }
        }
        timer.tolerance = 0.002
        self.timer = timer
        RunLoop.main.add(timer, forMode: .common)
    }
    private func tick() {
        let now = ProcessInfo.processInfo.systemUptime
        let delta = now - lastTick
        lastTick = now
        if intervals.count < 5000 { intervals.append(delta) }
        tickCount += 1
        time = min(Self.duration, time + delta * (slow ? 0.5 : 1))
        if time >= Self.duration { pause() }
    }
    func pause() { timer?.invalidate(); timer = nil; playing = false }
    func seek(_ value: Double) { pause(); demoActive = false; time = min(Self.duration, max(0, value)) }
    func replay() { seek(0); intervals.removeAll(keepingCapacity: true); tickCount = 0; play() }
    func report() -> String {
        let sorted = intervals.sorted()
        let p95 = sorted.isEmpty ? 0 : sorted[min(sorted.count - 1, Int(Double(sorted.count) * 0.95))] * 1000
        return "ticks=\(tickCount) activeTimer=\(timer != nil) time=\(time) callback_p95_ms=\(p95) callback_over_33ms=\(intervals.filter { $0 > 0.0333 }.count)\nCallback timing is not presented-frame or GPU timing.\n"
    }
}

struct PreviewScene: View {
    @ObservedObject var player: SequencePlayer
    @Environment(\.accessibilityReduceMotion) private var systemReduceMotion
    @Environment(\.accessibilityReduceTransparency) private var systemReduceTransparency
    @State private var previewReduceMotion = false
    @State private var previewOpaque = false
    var reduced: Bool { systemReduceMotion || previewReduceMotion }
    private let paleBlue = Color(red: 0.48, green: 0.72, blue: 1)
    private func progress(_ start: Double, _ length: Double) -> Double {
        let x = min(1, max(0, (player.time - start) / length))
        return x * x * x * (x * (x * 6 - 15) + 10)
    }
    private var arrival: Double { progress(0.15, 1.1) }
    private var overlayOpacity: Double { player.demoActive ? 1 : arrival * (1 - progress(12.0, 0.6)) }
    private var press: Double { progress(4.10, 0.16) * (1 - progress(4.30, 0.25)) }
    private var menu: Double { progress(4.40, 0.5) * (1 - progress(9.3, 0.5)) }
    private var menuSpring: Double {
        let t = min(1.2, max(0, player.time - 4.40))
        return 1 - exp(-8 * t) * (cos(11 * t) + (8.0 / 11) * sin(11 * t))
    }
    private var secondPress: Double { progress(7.0, 0.12) * (1 - progress(7.18, 0.18)) }
    private var selection: Double { player.time >= 7.18 ? 1 : 0 }
    private var pointerApproach: Double { progress(5.05, 0.55) }
    private var pointerToSmart: Double { progress(6.15, 0.65) }
    private var highlight: Double { progress(3.55, 0.4) * (1 - progress(10.0, 0.4)) }

    var body: some View {
        VStack(spacing: 0) {
            stage
            controls
        }
        .preferredColorScheme(.dark)
        .frame(minWidth: 880, idealWidth: 1040, minHeight: 730, idealHeight: 810)
    }
    // A continuous camera move, with still reading holds. All transforms stop at 11.8s.
    private var reveal: Double { progress(0.5, 2.7) }
    private var dock: Double { progress(10.0, 1.8) }
    private var cameraScale: Double { reduced ? 1 : 2.8 - 0.85 * reveal - 0.95 * dock }
    private var pitch: Double { reduced ? 0 : 60 * (1 - reveal) + 12 * reveal * (1 - dock) }
    private var yaw: Double { reduced ? 0 : 28 * (1 - reveal) - 10 * reveal * (1 - dock) }
    private var roll: Double { reduced ? 0 : -14 * (1 - reveal) + 2 * reveal * (1 - dock) }
    fileprivate var stage: some View {
        GeometryReader { geo in
            ZStack {
                Color(red: 0.018, green: 0.026, blue: 0.05)
                RadialGradient(colors: [FluidBrandColors.blue.opacity(0.19), .clear], center: .init(x: 0.64, y: 0.65), startRadius: 0, endRadius: 510)
                // A second fixed light gives the moving glass a spatial reference.
                Ellipse().fill(RadialGradient(colors: [Color(red: 0.12, green: 0.25, blue: 0.47).opacity(0.16), .clear], center: .center, startRadius: 0, endRadius: 400))
                    .frame(width: 820, height: 240).rotationEffect(.degrees(-25))
                    .position(x: geo.size.width * 0.68, y: geo.size.height * 0.7)
                VStack(alignment: .leading, spacing: 12) {
                    Text("Meet your overlay")
                        .font(.fluidSystem(size: 42, design: .serif))
                    Text("Change modes with one click.")
                        .font(.fluidSystem(size: 15)).foregroundStyle(.white.opacity(0.5))
                }
                .frame(maxWidth: .infinity, alignment: .leading)
                .padding(.leading, 70)
                .opacity(progress(1.15, 1.0) * (1 - progress(3.4, 0.55)))
                .offset(y: reduced ? 0 : 15 * (1 - progress(1.15, 1.0)))
                .position(x: geo.size.width / 2, y: 100)

                Text("Change modes\nwith one click.")
                    .font(.fluidSystem(size: 32, design: .serif))
                    .foregroundStyle(.white.opacity(0.92))
                    .frame(maxWidth: .infinity, alignment: .leading).padding(.leading, 70)
                    .opacity(progress(4.0, 0.6) * (1 - progress(9.5, 0.5)))
                    .position(x: geo.size.width / 2, y: 122)

                // Overlay and menu share one camera, so their attachment never drifts.
                ZStack {
                    overlay
                }
                .frame(width: 340, height: 90.25)
                .rotation3DEffect(.degrees(pitch), axis: (x: 1, y: 0, z: 0), perspective: 0.45)
                .rotation3DEffect(.degrees(yaw), axis: (x: 0, y: 1, z: 0), perspective: 0.45)
                .rotationEffect(.degrees(roll))
                .scaleEffect(cameraScale)
                .opacity(overlayOpacity)
                .offset(y: player.demoActive || reduced ? 0 : 8 * progress(12.0, 0.6))
                .animation(reduced ? .easeOut(duration: 0.15) : .easeOut(duration: 0.25), value: player.demoActive)
                .position(x: geo.size.width / 2 + (reduced ? 0 : 90 * (1 - reveal)),
                          y: geo.size.height * 0.57 + dock * (geo.size.height * 0.43 - 123))
                .accessibilityHidden(overlayOpacity < 0.1)

                VStack(spacing: 12) {
                    if player.demoActive {
                        Text("Overlay preview · microphone off")
                            .font(.fluidSystem(size: 12)).foregroundStyle(.white.opacity(0.55))
                        Button("Hide overlay") { player.toggleDemo() }
                            .buttonStyle(.plain).foregroundStyle(paleBlue)
                    } else {
                        Text("Let’s try Smart mode")
                            .font(.fluidSystem(size: 22, design: .serif))
                            .foregroundStyle(.white.opacity(0.92))
                        HStack(spacing: 10) {
                            Text("Press").foregroundStyle(.white.opacity(0.8))
                            Text("⌥ Space")
                                .font(.fluidSystem(size: 22, weight: .medium))
                                .padding(.horizontal, 13).padding(.vertical, 8)
                                .background(.white.opacity(0.08), in: RoundedRectangle(cornerRadius: 9))
                            Text("to start dictating").foregroundStyle(.white.opacity(0.8))
                        }
                        .font(.fluidSystem(size: 18))
                        Button("Try dictation") { player.toggleDemo() }
                            .buttonStyle(.plain).font(.fluidSystem(size: 13, weight: .medium))
                            .foregroundStyle(paleBlue)
                        Text("Preview shortcut · no audio recorded")
                            .font(.fluidSystem(size: 11)).foregroundStyle(.white.opacity(0.4))
                    }
                }
                .opacity(progress(12.8, 0.6))
                .disabled(!player.canActivate)
                .allowsHitTesting(player.canActivate)
                .position(x: geo.size.width / 2, y: geo.size.height - (player.demoActive ? 37 : 110))
                .accessibilityHidden(!player.canActivate)

                example
                    .opacity(progress(13.4, 0.8))
                    .offset(y: reduced ? 0 : 18 * (1 - progress(13.4, 0.8)))
                    .position(x: geo.size.width / 2, y: geo.size.height * 0.32)
                    .accessibilityHidden(player.time < 13.4)
            }
            .clipped()
        }
    }
    private var overlay: some View {
        BottomOverlayView(smart: selection > 0.5,
                          chipScale: reduced ? 1 : 1 - 0.075 * press,
                          chipHighlighted: highlight > 0.1,
                          demonstrationMenu: AnyView(
                            modeMenu
                                .scaleEffect(reduced ? 1 : (player.time < 9.3 ? 0.86 + 0.14 * menuSpring : 0.86 + 0.14 * menu), anchor: .bottomTrailing)
                                .rotation3DEffect(.degrees(reduced ? 0 : -16 * (1 - menu)), axis: (x: 1, y: 0, z: 0), anchor: .bottom, perspective: 0.35)
                                .opacity(menu)
                                .offset(y: reduced ? 0 : 9 * (1 - menuSpring))
                                .accessibilityHidden(menu < 0.5)
                          ),
                          demonstrationPointer: AnyView(
                            Image(systemName: "cursorarrow")
                                .font(.system(size: 15)).foregroundStyle(.white)
                                .shadow(color: .black.opacity(0.5), radius: 2, y: 1)
                                .scaleEffect(reduced ? 1 : 1 - 0.12 * max(press, secondPress))
                                .offset(x: 7 + 34 * (1 - progress(3.4, 0.65)) - 65 * pointerApproach,
                                        y: 7 + 31 * (1 - progress(3.4, 0.65)) - 54 * pointerApproach + 25 * pointerToSmart)
                                .opacity((reduced ? 0 : 1) * progress(3.3, 0.2) * (1 - progress(8.05, 0.3)))
                                .accessibilityHidden(true)
                          ))
    }
    private var modeMenu: some View {
        ProductionPromptMenu(smart: selection > 0.5,
                             smartPress: reduced ? 0 : secondPress,
                             hoveredRowID: player.time >= 6.75 && player.time < 7.18 ? "privateAI" : nil,
                             basicOpacity: progress(4.65, 0.24),
                             smartOpacity: progress(4.73, 0.28),
                             basicOffset: reduced ? 0 : 5 * (1 - progress(4.65, 0.30)),
                             smartOffset: reduced ? 0 : 7 * (1 - progress(4.73, 0.34)))
    }
    private var example: some View {
        let index = player.time >= 19.5 ? 1 : 0
        let item = PracticeExamples.items[index]
        let switchOpacity = player.time < 19.5 ? 1 - progress(19.15, 0.35) : progress(19.5, 0.4)
        return VStack(alignment: .leading, spacing: 18) {
            HStack(spacing: 16) {
                ForEach(0..<2) { option in
                    Button(PracticeExamples.items[option].label) { player.seek(option == 0 ? 16 : 23) }
                        .buttonStyle(.plain)
                        .font(.fluidSystem(size: 12, weight: .medium))
                        .foregroundStyle(option == index ? paleBlue : .white.opacity(0.45))
                        .accessibilityAddTraits(option == index ? [.isSelected] : [])
                }
            }
            VStack(alignment: .leading, spacing: 16) {
                Text(item.title)
                    .font(.fluidSystem(size: 26, design: .serif))
                    .fixedSize(horizontal: false, vertical: true)
                HStack(alignment: .top, spacing: 24) {
                    VStack(alignment: .leading, spacing: 8) {
                        Text("You say").foregroundStyle(.white.opacity(0.5))
                        Text(item.spoken).foregroundStyle(.white.opacity(0.8))
                    }.frame(maxWidth: .infinity, alignment: .leading)
                    Rectangle().fill(.white.opacity(0.1)).frame(width: 1, height: 132)
                    VStack(alignment: .leading, spacing: 8) {
                        Text("Smart").foregroundStyle(paleBlue)
                        Text(item.cleaned).foregroundStyle(.white.opacity(0.93))
                    }.frame(maxWidth: .infinity, alignment: .leading)
                }
                .font(.fluidSystem(size: 14)).lineSpacing(3)
            }
            .frame(height: 198, alignment: .topLeading)
            .opacity(switchOpacity)
        }
        .padding(26).frame(width: 650, alignment: .leading)
        .modifier(OnboardingGlassSurface(selected: true, forceOpaque: previewOpaque))
    }
    private var controls: some View {
        VStack(spacing: 12) {
            HStack(spacing: 14) {
                Button(action: { player.replay() }) { Image(systemName: "arrow.counterclockwise") }.help("Replay")
                Button(action: { player.playing ? player.pause() : player.play() }) {
                    Image(systemName: player.playing ? "pause.fill" : "play.fill").frame(width: 14)
                }.help(player.playing ? "Pause" : "Play").keyboardShortcut(.space, modifiers: [])
                Slider(value: Binding(get: { player.time }, set: { player.seek($0) }), in: 0...SequencePlayer.duration)
                    .accessibilityLabel("Sequence position")
                Text(String(format: "%04.1f / 25s", player.time)).monospacedDigit().frame(width: 85)
            }
            HStack(spacing: 18) {
                Text(player.stage).foregroundStyle(.white.opacity(0.7)).frame(width: 130, alignment: .leading)
                Spacer()
                Toggle("Half speed", isOn: $player.slow)
                Toggle("Reduce motion", isOn: $previewReduceMotion)
                Toggle("Opaque surfaces", isOn: $previewOpaque)
                Text("VISUAL PREVIEW").font(.fluidSystem(size: 9, weight: .semibold)).tracking(1.4).foregroundStyle(.white.opacity(0.35))
            }
        }
        .font(.fluidSystem(size: 11)).toggleStyle(.checkbox).buttonStyle(.plain)
        .padding(.horizontal, 28).padding(.vertical, 18)
        .background(Color(red: 0.04, green: 0.045, blue: 0.065))
    }
}

@MainActor final class PreviewDelegate: NSObject, NSApplicationDelegate, NSWindowDelegate {
    let player = SequencePlayer()
    var window: NSWindow!
    var observers: [NSObjectProtocol] = []
    var previewKeyMonitor: Any?
    func applicationDidFinishLaunching(_ notification: Notification) {
        window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 1040, height: 810), styleMask: [.titled, .closable, .miniaturizable, .resizable], backing: .buffered, defer: false)
        window.title = "FluidVoice · Overlay Film"
        window.minSize = NSSize(width: 880, height: 758)
        window.delegate = self
        let args = ProcessInfo.processInfo.arguments
        let rendering = args.contains("--render-frames")
        if rendering {
            window.setFrameOrigin(NSPoint(x: -12000, y: -12000))
        } else {
            window.contentView = NSHostingView(rootView: PreviewScene(player: player))
            window.center()
            window.makeKeyAndOrderFront(nil)
            NSApp.activate(ignoringOtherApps: true)
            // Foreground preview only. Never install a global shortcut or connect to recording.
            previewKeyMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] event in
                guard let self, self.window.isKeyWindow, self.player.canActivate,
                      event.keyCode == 49,
                      event.modifierFlags.intersection([.option, .command, .control, .shift]) == .option else { return event }
                if !event.isARepeat { self.player.toggleDemo() }
                return nil
            }
        }
        for name in [NSWindow.didChangeOcclusionStateNotification, NSWindow.didMiniaturizeNotification, NSApplication.didHideNotification] {
            observers.append(NotificationCenter.default.addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in
                MainActor.assumeIsolated {
                    guard let self else { return }
                    if !self.window.occlusionState.contains(.visible) || self.window.isMiniaturized || NSApp.isHidden { self.player.pause() }
                }
            })
        }
        if let i = args.firstIndex(of: "--seek"), args.count > i + 1, let value = Double(args[i + 1]) { player.seek(value) }
        else if !rendering { player.play() }
        if let i = args.firstIndex(of: "--render-frames"), args.count > i + 1 {
            renderFrames(to: URL(fileURLWithPath: args[i + 1], isDirectory: true))
        }
        if let i = args.firstIndex(of: "--metrics"), args.count > i + 1 {
            let path = args[i + 1]
            DispatchQueue.main.asyncAfter(deadline: .now() + 18) { [weak self] in
                try? self?.player.report().write(toFile: path, atomically: true, encoding: .utf8)
            }
        }
    }
    func renderFrames(to directory: URL) {
        try? FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
        let landmarks: [(String, Double)] = [("01-angle", 0.9), ("02-reveal", 2.0), ("03-settle", 3.3), ("04-press", 4.25), ("05-unfold", 4.7), ("05-basic", 6), ("06-pointer-basic", 5.8), ("06-pointer-smart", 6.85), ("06-smart-click", 7.1), ("06-smart-selected", 7.4), ("07-dock", 11), ("08-vanishing", 12.3), ("08-shortcut", 13.4), ("09-correction", 16), ("10-numbered-list", 23)]
        let film = ProcessInfo.processInfo.arguments.contains("--film")
        let reference = ProcessInfo.processInfo.arguments.contains("--reference")
        let filmDuration = ProcessInfo.processInfo.arguments.contains("--intro-only") ? 12.8 : SequencePlayer.duration
        let frames = reference ? [("production-medium-smart", 16.0)] : (film ? (0...Int(filmDuration * 60)).map { (String(format: "%04d", $0), Double($0) / 60) } : landmarks)
        for (index, frame) in frames.enumerated() {
            DispatchQueue.main.asyncAfter(deadline: .now() + Double(index) * (film ? 0.04 : 0.55)) { [weak self] in
                self?.player.seek(frame.1)
                DispatchQueue.main.asyncAfter(deadline: .now() + (film ? 0 : 0.25)) { [weak self] in
                    guard let self else { return }
                    self.player.seek(frame.1)
                    if ProcessInfo.processInfo.arguments.contains("--activated") { self.player.toggleDemo() }
                    let content = reference
                        ? AnyView(BottomOverlayView(smart: true).fixedSize().padding(20).environment(\.colorScheme, .dark))
                        : AnyView(PreviewScene(player: self.player).stage.frame(width: 1040, height: 730).environment(\.colorScheme, .dark))
                    let renderer = ImageRenderer(content: content)
                    renderer.scale = reference ? 3 : 1.5
                    if let data = renderer.nsImage?.tiffRepresentation, let bitmap = NSBitmapImageRep(data: data) {
                        try? bitmap.representation(using: .png, properties: [:])?.write(to: directory.appendingPathComponent(frame.0 + ".png"))
                    }
                    if index == frames.count - 1 { NSApp.terminate(nil) }
                }
            }
        }
    }
    func windowWillClose(_ notification: Notification) {
        player.pause()
        if let previewKeyMonitor { NSEvent.removeMonitor(previewKeyMonitor) }
        previewKeyMonitor = nil
        NSApp.terminate(nil)
    }
    func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { true }
}

@main struct OverlayPreviewMain {
    static func main() {
        if ProcessInfo.processInfo.arguments.contains("--check-interaction") {
            let player = SequencePlayer()
            player.seek(12.7)
            player.toggleDemo()
            precondition(!player.demoActive, "Activation must wait for the introduction")
            player.seek(13.4)
            player.play()
            player.toggleDemo()
            precondition(player.demoActive && !player.playing, "Activation should reveal overlay and stop autoplay")
            player.toggleDemo()
            precondition(!player.demoActive, "Second activation should hide the demo")
            player.toggleDemo()
            player.seek(0)
            precondition(!player.demoActive, "Scrubbing or replay must reset activation")
            print("PASS: early input ignored; ready input toggles overlay; autoplay pauses; seek resets activation")
            return
        }
        let app = NSApplication.shared
        let delegate = PreviewDelegate()
        app.setActivationPolicy(ProcessInfo.processInfo.arguments.contains("--render-frames") ? .accessory : .regular)
        app.delegate = delegate
        withExtendedLifetime(delegate) { app.run() }
    }
}