# Swift Code for the App Entry of FluidVoice: Complete @main Implementation

> Explore the Swift code for the FluidVoice app entry using @main. Discover how SwiftUI state management, singleton services, and AppKit delegates are integrated for a robust application launch.

- Repository: [ALTIC/FluidVoice](https://github.com/altic-dev/FluidVoice)
- Tags: getting-started
- Published: 2026-06-30

---

**The FluidVoice macOS application launches through the `@main` attributed `FluidApp` struct defined in [`Sources/Fluid/fluidApp.swift`](https://github.com/altic-dev/FluidVoice/blob/main/Sources/Fluid/fluidApp.swift), which wires together SwiftUI state management, singleton service initialization, and AppKit delegate bridging.**

The entry point of the **FluidVoice** application, an open-source macOS voice interface from the **altic-dev/FluidVoice** repository, demonstrates modern SwiftUI architecture patterns for complex productivity tools. Examining the **Swift code for the app entry of FluidVoice** reveals how contemporary macOS apps integrate traditional AppKit requirements with declarative SwiftUI scene management.

## The @main Entry Point in fluidApp.swift

The primary launch sequence resides in [`Sources/Fluid/fluidApp.swift`](https://github.com/altic-dev/FluidVoice/blob/main/Sources/Fluid/fluidApp.swift), where the `FluidApp` struct conforms to SwiftUI's `App` protocol. The `@main` attribute marks this structure as the executable entry point, eliminating the need for a traditional [`main.swift`](https://github.com/altic-dev/FluidVoice/blob/main/main.swift) file.

```swift
import AppKit
import SwiftUI

@main
struct FluidApp: App {
    @StateObject private var menuBarManager = MenuBarManager()
    @StateObject private var appServices: AppServices
    @ObservedObject private var settings = SettingsStore.shared
    @NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

    init() {
        _appServices = StateObject(wrappedValue: AppServices.shared)
    }

    var body: some Scene {
        WindowGroup(id: "main") {
            AdaptiveAppTheme(accent: settings.accentColor) {
                ContentView()
                    .environmentObject(menuBarManager)
                    .environmentObject(appServices)
            }
        }
        .defaultSize(width: 1000, height: 700)
        .commands {
            CommandGroup(replacing: .appSettings) {
                Button("Settings…") {
                    menuBarManager.openPreferencesFromUI()
                }
                .keyboardShortcut(",", modifiers: .command)
            }
        }
    }
}

```

## Service Initialization and State Management

The `FluidApp` initializer and property declarations establish the dependency graph for the entire application lifecycle.

### Centralized Services via AppServices

The `appServices` property holds a singleton instance of `AppServices` initialized lazily within the `init()` method. This pattern ensures that core capabilities—audio processing, transcription engines, and AI services—are instantiated exactly once via `AppServices.shared` and injected into the SwiftUI environment.

### Menu Bar Integration

The `menuBarManager` property, marked as `@StateObject`, instantiates `MenuBarManager` to handle the macOS status bar icon, dropdown menus, and overlay user interfaces. This object persists throughout the app lifecycle, maintaining menu bar presence even when the main window is closed.

### Global Settings Persistence

Global user preferences propagate through `SettingsStore.shared`, an `@ObservedObject` that provides reactive theme data, hotkey configurations, and accent colors to the view hierarchy via the `settings` property.

### AppKit Lifecycle Bridging

The `appDelegate` property uses `@NSApplicationDelegateAdaptor` to bridge SwiftUI with traditional AppKit patterns defined in [`Sources/Fluid/AppDelegate.swift`](https://github.com/altic-dev/FluidVoice/blob/main/Sources/Fluid/AppDelegate.swift). This adaptor handles legacy events such as manual update checks and application-level notifications that fall outside SwiftUI's native scene management.

## Window Configuration and Custom Commands

The `body` property defines a single `WindowGroup` identified as `"main"`, which creates the primary application window. The scene wraps `ContentView` inside `AdaptiveAppTheme`, injecting both `menuBarManager` and `appServices` as environment objects for child view access.

The window defaults to **1000×700 points** via `.defaultSize()`, providing a consistent initial layout. The `.commands` modifier replaces the standard macOS **Preferences** menu item with a custom implementation that invokes `menuBarManager.openPreferencesFromUI()`, binding the **Command + ,** keyboard shortcut to the custom settings panel.

## Summary

- **Entry Point**: The `@main` struct `FluidApp` in [`Sources/Fluid/fluidApp.swift`](https://github.com/altic-dev/FluidVoice/blob/main/Sources/Fluid/fluidApp.swift) serves as the application launcher.
- **Service Architecture**: `AppServices.shared` initializes as a singleton within `init()`, centralizing audio, transcription, and AI capabilities.
- **State Management**: `@StateObject` properties manage `MenuBarManager` lifecycle, while `SettingsStore.shared` provides global preferences.
- **AppKit Bridge**: `@NSApplicationDelegateAdaptor` connects SwiftUI to `AppDelegate` for legacy macOS event handling.
- **Window Setup**: The `WindowGroup` renders `ContentView` at 1000×700 points with custom environment objects and an overridden Preferences command.

## Frequently Asked Questions

### Where is the main entry point defined in the FluidVoice codebase?

The main entry point is defined in [`Sources/Fluid/fluidApp.swift`](https://github.com/altic-dev/FluidVoice/blob/main/Sources/Fluid/fluidApp.swift) within the `FluidApp` struct marked with the `@main` attribute. This SwiftUI pattern replaces the traditional [`main.swift`](https://github.com/altic-dev/FluidVoice/blob/main/main.swift) file and declares the executable starting point for the macOS application.

### How does FluidVoice initialize its core services at launch?

Core services initialize through the `AppServices.shared` singleton pattern inside the `FluidApp` initializer. The code assigns `_appServices = StateObject(wrappedValue: AppServices.shared)`, ensuring that audio engines, transcription services, and AI components are instantiated once and injected into the SwiftUI environment for global access.

### Why does a SwiftUI app like FluidVoice use an AppDelegate?

FluidVoice uses `@NSApplicationDelegateAdaptor(AppDelegate.self)` to bridge SwiftUI with AppKit for handling legacy macOS events that SwiftUI does not natively support, such as manual update checks, application termination requests, and menu bar management tasks defined in [`Sources/Fluid/AppDelegate.swift`](https://github.com/altic-dev/FluidVoice/blob/main/Sources/Fluid/AppDelegate.swift).

### What determines the initial window size and settings shortcut in FluidVoice?

The `WindowGroup` applies `.defaultSize(width: 1000, height: 700)` to set the initial dimensions, while the `.commands` modifier replaces the default `.appSettings` command group with a custom `Button` that triggers `menuBarManager.openPreferencesFromUI()` and binds to the **Command + ,** keyboard shortcut.