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
/// Floating panels remain untitled so main-window navigation ignores them.
/// Caption panels do not take keyboard focus; source confirmation explicitly opts in
/// so Return and Escape work while the meeting app remains active.
final class MeetingFloatingCaptionsPanel: NSPanel {
var allowsKeyboardFocus = false
override var canBecomeKey: Bool {
self.allowsKeyboardFocus
}
}
/// Swallows first-mouse so clicks and drags work while FluidVoice is inactive — this panel's
/// normal state, since it exists precisely so captions stay visible while another app has focus.
final class MeetingFloatingHostingView: NSHostingView<AnyView> {
var overlayHitPadding: MeetingOverlayPadding?
override func acceptsFirstMouse(for event: NSEvent?) -> Bool {
true
}
override func hitTest(_ point: NSPoint) -> NSView? {
if let padding = self.overlayHitPadding {
let visible = NSRect(
x: self.bounds.minX + padding.left,
y: self.bounds.minY + padding.bottom,
width: self.bounds.width - padding.left - padding.right,
height: self.bounds.height - padding.top - padding.bottom
)
guard visible.contains(point) else { return nil }
}
return super.hitTest(point)
}
}
enum MeetingFloatingPanelFactory {
@MainActor
static func make(
size: NSSize,
resizable: Bool,
content: AnyView,
overlayHitPadding: MeetingOverlayPadding? = nil,
allowsKeyboardFocus: Bool = false
) -> MeetingFloatingCaptionsPanel {
var styleMask: NSWindow.StyleMask = [.borderless, .nonactivatingPanel]
if resizable { styleMask.insert(.resizable) }
let panel = MeetingFloatingCaptionsPanel(
contentRect: NSRect(origin: .zero, size: size),
styleMask: styleMask,
backing: .buffered,
defer: false
)
panel.allowsKeyboardFocus = allowsKeyboardFocus
panel.isFloatingPanel = true
panel.level = .floating
panel.collectionBehavior = [.canJoinAllSpaces, .fullScreenAuxiliary]
// Default true would hide the panel the instant the user clicks into Zoom — these panels
// exist precisely to stay visible while FluidVoice is not the active app.
panel.hidesOnDeactivate = false
panel.animationBehavior = .none
panel.isOpaque = false
panel.backgroundColor = .clear
panel.hasShadow = false
panel.isMovableByWindowBackground = true
// Must never appear in the user's own screen share.
panel.sharingType = .none
let hostingView = MeetingFloatingHostingView(rootView: content)
hostingView.overlayHitPadding = overlayHitPadding
hostingView.wantsLayer = true
hostingView.layer?.backgroundColor = .clear
panel.contentView = hostingView
return panel
}
}
/// The live overlay (pill or captions) is shown only while audio is actually being captured.
enum MeetingOverlayVisibility {
static func isVisible(for state: MeetingCoordinatorState) -> Bool {
switch state {
case .recording, .recordingDegraded:
return true
case .idle, .preparing, .stopping, .processing, .completed, .interrupted, .failed:
return false
}
}
}
@MainActor
final class MeetingFloatingCaptionsController: ObservableObject {
static let shared = MeetingFloatingCaptionsController()
private static let panelSize = NSSize(width: 400, height: 480)
private static let minimumSize = NSSize(width: 320, height: 240)
private static let autosaveName = "MeetingFloatingCaptions"
private static let defaultEdgeInset: CGFloat = 24
private var panel: MeetingFloatingCaptionsPanel?
private var stateSubscription: AnyCancellable?
private var screenParametersObserver: NSObjectProtocol?
private init() {}
/// Opens the captions window, growing out of `sourceFrame` (the pill) when motion is allowed.
func show(from sourceFrame: NSRect?) {
guard SettingsStore.shared.fluidMeetEnabled else { return }
let coordinator = AppServices.shared.meetingSessionCoordinator
guard MeetingOverlayVisibility.isVisible(for: coordinator.state) else { return }
let panel = self.panelOrCreate(coordinator: coordinator)
self.subscribeIfNeeded(coordinator: coordinator)
let reduceMotion = NSWorkspace.shared.accessibilityDisplayShouldReduceMotion
if let sourceFrame, !panel.isVisible, !reduceMotion {
let targetFrame = panel.frame
panel.setFrame(sourceFrame, display: false)
panel.orderFrontRegardless()
NSAnimationContext.runAnimationGroup { context in
context.duration = 0.55
context.timingFunction = CAMediaTimingFunction(controlPoints: 0.22, 1.0, 0.36, 1.0)
panel.animator().setFrame(targetFrame, display: true)
}
} else {
panel.orderFrontRegardless()
}
}
func hide() {
self.panel?.orderOut(nil)
}
func deactivate() {
self.hide()
self.stateSubscription?.cancel()
self.stateSubscription = nil
if let observer = self.screenParametersObserver {
NotificationCenter.default.removeObserver(observer)
}
self.screenParametersObserver = nil
self.panel = nil
}
private func panelOrCreate(coordinator: MeetingSessionCoordinator) -> MeetingFloatingCaptionsPanel {
if let panel { return panel }
let content = AnyView(
AdaptiveAppTheme(accent: SettingsStore.shared.accentColor) {
MeetingFloatingCaptionsContent(coordinator: coordinator)
}
)
let panel = MeetingFloatingPanelFactory.make(size: Self.panelSize, resizable: true, content: content)
panel.minSize = Self.minimumSize
panel.setFrameAutosaveName(Self.autosaveName)
// setFrameAutosaveName alone does not restore a saved frame; it only enables saving on move.
if !panel.setFrameUsingName(Self.autosaveName) {
self.placeAtDefaultPosition(panel)
}
self.clampIntoVisibleFrame(panel)
self.panel = panel
self.installScreenParametersObserverIfNeeded()
return panel
}
private func subscribeIfNeeded(coordinator: MeetingSessionCoordinator) {
guard self.stateSubscription == nil else { return }
self.stateSubscription = coordinator.$state
.receive(on: DispatchQueue.main)
.sink { [weak self] state in
guard MeetingOverlayVisibility.isVisible(for: state) else {
self?.hide()
return
}
}
}
private func placeAtDefaultPosition(_ panel: NSPanel) {
let screen = OverlayScreenResolver.screenForCurrentPointer() ?? NSScreen.main
guard let screen else { return }
let visible = screen.visibleFrame
let origin = NSPoint(
x: visible.maxX - Self.panelSize.width - Self.defaultEdgeInset,
y: visible.midY - Self.panelSize.height / 2
)
panel.setFrame(NSRect(origin: origin, size: Self.panelSize), display: false)
}
private func clampIntoVisibleFrame(_ panel: NSPanel) {
let visible = (panel.screen ?? NSScreen.main)?.visibleFrame
guard let visible else { return }
var frame = panel.frame
frame.origin.x = min(max(frame.origin.x, visible.minX), visible.maxX - frame.width)
frame.origin.y = min(max(frame.origin.y, visible.minY), visible.maxY - frame.height)
panel.setFrame(frame, display: false)
}
private func installScreenParametersObserverIfNeeded() {
guard self.screenParametersObserver == nil else { return }
self.screenParametersObserver = NotificationCenter.default.addObserver(
forName: NSApplication.didChangeScreenParametersNotification,
object: nil,
queue: .main
) { [weak self] _ in
Task { @MainActor [weak self] in
self?.repositionIfOffscreen()
}
}
}
private func repositionIfOffscreen() {
guard let panel else { return }
let stillOnScreen = NSScreen.screens.contains { $0.visibleFrame.intersects(panel.frame) }
guard !stillOnScreen else { return }
self.placeAtDefaultPosition(panel)
self.clampIntoVisibleFrame(panel)
}
}
/// The expanded live overlay: scrollable, resizable, with a persistent header that says who is
/// recording and offers Stop and Close. Close returns to the pill.
struct MeetingFloatingCaptionsContent: View {
@ObservedObject var coordinator: MeetingSessionCoordinator
@Environment(\.theme) private var theme
@State private var isStopping = false
private static let fluidVoiceIcon: NSImage = NSImage(named: "AppIcon") ?? NSApplication.shared.applicationIconImage
private var rows: [MeetingLiveBubbleComposer.Row] {
MeetingLiveBubbleComposer.rows(for: self.coordinator.liveTranscript)
}
private var isRecordingActive: Bool {
MeetingOverlayVisibility.isVisible(for: self.coordinator.state)
}
var body: some View {
let rows = self.rows
VStack(alignment: .leading, spacing: 10) {
self.header
if rows.isEmpty {
Text("Listening…")
.font(self.theme.typography.bodySmall)
.foregroundStyle(self.theme.palette.secondaryText)
.frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .center)
} else {
MeetingLiveBubbleScrollList(rows: rows, hidesPartialFromAccessibility: false)
}
}
.padding(14)
.frame(minWidth: 320, maxWidth: .infinity, minHeight: 240, maxHeight: .infinity, alignment: .topLeading)
.background(
RoundedRectangle(cornerRadius: 16, style: .continuous)
.fill(self.theme.palette.contentBackground.opacity(0.96))
)
.overlay(
RoundedRectangle(cornerRadius: 16, style: .continuous)
.stroke(self.theme.palette.separator.opacity(0.55), lineWidth: 1)
)
.shadow(color: .black.opacity(0.35), radius: 16, x: 0, y: 6)
.onChange(of: self.isRecordingActive) { _, active in
if active { self.isStopping = false }
}
.accessibilityElement(children: .contain)
.accessibilityLabel("FluidMeet live captions")
}
private var header: some View {
HStack(spacing: 8) {
HStack(spacing: 8) {
Image(nsImage: Self.fluidVoiceIcon)
.resizable()
.aspectRatio(contentMode: .fit)
.frame(width: 18, height: 18)
.clipShape(RoundedRectangle(cornerRadius: 4, style: .continuous))
.accessibilityHidden(true)
Text("FluidMeet")
.font(self.theme.typography.captionStrong)
.foregroundStyle(self.theme.palette.primaryText)
Spacer(minLength: 8)
}
.frame(maxWidth: .infinity, minHeight: 24, alignment: .leading)
.contentShape(Rectangle())
// Keep window dragging on the flexible header area, separate from its controls.
.gesture(WindowDragGesture())
.allowsWindowActivationEvents()
Button {
self.stopRecording()
} label: {
Label("Stop", systemImage: "stop.fill")
.font(.fluidSystem(size: 11, weight: .semibold))
.foregroundStyle(Color.white)
.padding(.horizontal, 10)
.frame(height: 24)
.background(Color(red: 0.93, green: 0.23, blue: 0.23), in: Capsule())
}
.buttonStyle(.plain)
.disabled(self.isStopping || !self.isRecordingActive)
.help("Stop recording and transcribe")
.accessibilityLabel("Stop meeting recording and transcribe")
Button {
MeetingRecordingPillController.shared.collapse()
} label: {
Image(systemName: "xmark")
.font(.fluidSystem(size: 10, weight: .bold))
.foregroundStyle(self.theme.palette.secondaryText)
.frame(width: 24, height: 24)
.background(self.theme.palette.primaryText.opacity(0.08), in: Circle())
}
.buttonStyle(.plain)
.help("Back to the small pill")
.accessibilityLabel("Close captions")
}
}
private func stopRecording() {
guard !self.isStopping, self.isRecordingActive else { return }
self.isStopping = true
let coordinator = self.coordinator
Task { _ = try? await coordinator.stopAndTranscribe() }
}
}