Native macOS Patterns for Web Developers
This is a reference guide for the macOS-specific patterns that have no web equivalent. When building a native macOS app, these are the things that trip up everyone coming from web development. The AI should consult this before generating macOS code to avoid confidently producing patterns that don't work.
Menu Bar Apps
There are two approaches. Use MenuBarExtra for simple menus, NSStatusItem for full control.
SwiftUI MenuBarExtra (simple)
@main
struct MyApp: App {
var body: some Scene {
MenuBarExtra("MyApp", image: "MenuBarIcon") {
MenuBarView()
}
}
}
This creates a menu-bar-only app. The menu content is a standard SwiftUI view. For a popover-style menu bar app (richer UI than a plain menu), use the .window style:
MenuBarExtra("MyApp", image: "MenuBarIcon") {
PopoverContentView()
}
.menuBarExtraStyle(.window)
AppKit NSStatusItem (full control)
For custom menus, dynamic icons, or complex interactions:
let statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
if let button = statusItem.button {
let icon = NSImage(named: "MenuBarIcon")!
icon.size = NSSize(width: 18, height: 18)
icon.isTemplate = true // CRITICAL: adapts to dark/light mode automatically
button.image = icon
}
let menu = NSMenu()
menu.addItem(NSMenuItem(title: "Settings...", action: #selector(openSettings), keyEquivalent: ","))
statusItem.menu = menu
isTemplate = true is essential. Without it, your icon will be invisible in light mode or look wrong in dark mode.
NSPopover for Rich Menu Bar Content
For a popover attached to the menu bar icon (like Bartender, iStatMenus):
let popover = NSPopover()
popover.contentSize = NSSize(width: 300, height: 400)
popover.behavior = .transient // auto-closes when clicking outside
popover.contentViewController = NSHostingController(rootView: MyPopoverView())
// Show from the status item button:
if let button = statusItem.button {
popover.show(relativeTo: button.bounds, of: button, preferredEdge: .minY)
}
Activation Policy -- Dock Icon Toggling
A macOS app can dynamically show/hide its Dock icon and Cmd-Tab presence at runtime. Menu-bar-only apps start as .accessory (invisible in Dock) and temporarily become .regular when they open windows like Settings.
// At launch -- hide from Dock:
NSApp.setActivationPolicy(.accessory)
// When opening a window -- show in Dock:
NSApp.setActivationPolicy(.regular)
NSApp.activate(ignoringOtherApps: true)
// When closing the last window -- hide again:
NSApp.setActivationPolicy(.accessory)
Use reference counting if multiple windows can be open simultaneously:
@MainActor
enum AppActivationPolicy {
private static var count = 0
static func enter() {
count += 1
NSApp.setActivationPolicy(.regular)
NSApp.activate(ignoringOtherApps: true)
}
static func leave() {
count = max(0, count - 1)
guard count == 0 else { return }
Task { @MainActor in NSApp.setActivationPolicy(.accessory) }
}
}
NSPanel vs NSWindow
NSPanel is a subclass of NSWindow for auxiliary content that should not steal focus. Use it for:
- Floating overlays (preview cards, recording indicators)
- Palettes and tool windows
- Inspectors
- Anything that should stay visible while the user works in another app
Key configuration:
let panel = NSPanel(
contentRect: .zero,
styleMask: [.borderless, .nonactivatingPanel], // Does NOT steal focus
backing: .buffered,
defer: false
)
panel.isOpaque = false
panel.backgroundColor = .clear
panel.hasShadow = false
panel.hidesOnDeactivate = false // Stay visible when app loses focus
panel.isFloatingPanel = true // Float above normal windows
panel.ignoresMouseEvents = true // Clicks pass through to windows below
panel.collectionBehavior = [
.canJoinAllSpaces, // Visible on all virtual desktops
.fullScreenAuxiliary, // Visible over fullscreen apps
]
To host SwiftUI content in the panel:
let hostingView = NSHostingView(rootView: MySwiftUIView())
panel.contentView = hostingView
Override focus behavior when needed:
class MyPanel: NSPanel {
override var canBecomeKey: Bool { true } // Can receive keyboard input
override var canBecomeMain: Bool { false } // Never becomes the "main" window
}
Screen Capture Exclusion
If your app shows floating UI that shouldn't appear in screenshots/recordings:
panel.sharingType = .none // Invisible to screen capture APIs
Window Levels
macOS has a multi-tier window level system that controls where windows appear relative to the entire OS (not just your app):
normal (0) -- standard app windows
floating (3) -- tool palettes, floating panels
modalPanel (8) -- modal dialogs
mainMenu (24) -- menu bar
screenSaver (1000) -- above everything except...
CGShieldingWindowLevel() -- above absolutely everything (kiosk mode)
Set via:
window.level = .floating
// or for extreme cases:
window.level = NSWindow.Level(rawValue: Int(CGShieldingWindowLevel()))
Collection Behaviors
Control how windows interact with Spaces, fullscreen, and Cmd-Tab:
window.collectionBehavior = [
.canJoinAllSpaces, // Visible on all virtual desktops
.fullScreenAuxiliary, // Visible over fullscreen apps
.stationary, // Doesn't move with Space transitions
.ignoresCycle, // Hidden from Cmd-` window cycling
.transient, // Removed when app is hidden
]
Screen Geometry
macOS uses bottom-left origin coordinates. The Y axis is flipped compared to the web.
let screen = NSScreen.main!
// Full screen rectangle (includes menu bar and Dock area):
screen.frame // e.g., (0, 0, 1728, 1117)
// Usable area (excludes menu bar and Dock):
screen.visibleFrame // e.g., (0, 0, 1728, 1055)
// Notch detection (MacBook with notch has top safe area):
screen.safeAreaInsets.top > 0 // true on notch Macs
Use frame when positioning over the menu bar (notch overlays). Use visibleFrame for normal window placement.
Quartz vs AppKit Y-Axis
Core Graphics / Quartz uses top-left origin. AppKit uses bottom-left origin. When converting between the two:
let desktopFrame = NSScreen.screens.reduce(CGRect.null) { $0.union($1.frame) }
let appKitY = desktopFrame.maxY - quartzY - height // Quartz → AppKit
let quartzY = desktopFrame.maxY - appKitY - height // AppKit → Quartz
Multi-Monitor
Never assume a single screen. Always handle the case where NSScreen.main is not the only display:
// Find the screen containing the mouse pointer:
let mouseLocation = NSEvent.mouseLocation
let screen = NSScreen.screens.first { $0.frame.contains(mouseLocation) }
// Find the screen containing a specific window:
let screen = window.screen
Keyboard Shortcuts
There are 3 tiers, each for different use cases.
Tier 1: SwiftUI keyboard shortcuts (in-app, when focused)
Button("Settings") { openSettings() }
.keyboardShortcut(",", modifiers: [.command]) // Cmd+,
Tier 2: NSEvent monitors (app-wide or global)
// Local: fires only when YOUR app is active
let monitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { event in
if event.keyCode == 53 { /* Escape */ return nil /* consume */ }
return event // pass through
}
// Global: fires even when ANOTHER app is active
let monitor = NSEvent.addGlobalMonitorForEvents(matching: .keyDown) { event in
// Cannot consume the event -- read-only
}
// CRITICAL: Always remove monitors when done
NSEvent.removeMonitor(monitor)
Returning nil from a local monitor consumes the event (stops propagation). Global monitors cannot consume events.
Tier 3: Carbon hotkeys (system-wide, works when app is not focused)
The only way to register true global keyboard shortcuts. Uses the Carbon API (1990s-era, still not deprecated):
import Carbon.HIToolbox
var hotKeyRef: EventHotKeyRef?
let hotKeyID = EventHotKeyID(signature: OSType(0x4D594150), id: 1) // "MYAP"
RegisterEventHotKey(
UInt32(kVK_ANSI_1), // Key code
UInt32(optionKey), // Modifiers
hotKeyID,
GetApplicationEventTarget(),
0,
&hotKeyRef
)
The callback runs on an arbitrary thread -- always dispatch to main:
DispatchQueue.main.async { self.handleHotKey() }
File Pickers
Open (select files/directories)
let panel = NSOpenPanel()
panel.allowedContentTypes = [.image, .movie] // UTType filter
panel.allowsMultipleSelection = true
panel.canChooseDirectories = false
panel.canChooseFiles = true
panel.canCreateDirectories = true
panel.title = "Choose Images"
// Modal (blocks the thread):
if panel.runModal() == .OK {
let urls = panel.urls
}
// Or sheet-modal (attached to a window, async):
panel.beginSheetModal(for: window) { response in
guard response == .OK else { return }
let urls = panel.urls
}
Save
let panel = NSSavePanel()
panel.allowedContentTypes = [.png]
panel.nameFieldStringValue = "screenshot.png"
panel.canCreateDirectories = true
panel.begin { response in
guard response == .OK, let url = panel.url else { return }
// write file to url
}
Directory picker
let panel = NSOpenPanel()
panel.canChooseFiles = false
panel.canChooseDirectories = true
panel.directoryURL = URL(fileURLWithPath: NSHomeDirectory())
Clipboard / Pasteboard
macOS's pasteboard is fundamentally different from the web's navigator.clipboard. It is a multi-item, multi-type container.
let pasteboard = NSPasteboard.general
// CRITICAL: You MUST clear before writing. Forgetting this is a common bug.
pasteboard.clearContents()
// Write text:
pasteboard.setString("hello", forType: .string)
// Write image data:
let pngData = try Data(contentsOf: imageURL)
pasteboard.setData(pngData, forType: .png)
// Write a file URL (for Finder paste):
pasteboard.writeObjects([url as NSURL])
// Read (check what types are available):
if let string = pasteboard.string(forType: .string) { ... }
if let data = pasteboard.data(forType: .png) { ... }
A single pasteboard item can advertise multiple types. When reading, check types in priority order.
Drag and Drop
SwiftUI (simple)
// Make something draggable:
Image(nsImage: image)
.draggable(fileURL) {
// Custom drag preview
Image(nsImage: image).frame(width: 100, height: 75)
}
// Accept drops:
.dropDestination(for: URL.self) { urls, location in
handleDroppedFiles(urls)
return true
}
AppKit (full control)
Register as a drop target:
class MyView: NSView {
override init(frame: NSRect) {
super.init(frame: frame)
registerForDraggedTypes([.fileURL, .png, .tiff])
}
override func draggingEntered(_ sender: NSDraggingInfo) -> NSDragOperation {
.copy // Show the green + cursor
}
override func performDragOperation(_ sender: NSDraggingInfo) -> Bool {
guard let urls = sender.draggingPasteboard.readObjects(forClasses: [NSURL.self]) as? [URL] else {
return false
}
handleFiles(urls)
return true
}
}
NavigationSplitView + Inspector Layout
The native macOS pattern for a sidebar + detail + inspector layout:
struct ContentView: View {
@State private var selection: Item?
@State private var showInspector = true
var body: some View {
NavigationSplitView {
SidebarView(selection: $selection)
.navigationSplitViewColumnWidth(min: 200, ideal: 220, max: 300)
} detail: {
DetailView(item: selection)
}
.inspector(isPresented: $showInspector) {
InspectorView(item: selection)
.inspectorColumnWidth(min: 250, ideal: 280, max: 400)
}
.toolbar {
ToolbarItem {
Button { showInspector.toggle() } label: {
Image(systemName: "sidebar.right")
}
}
}
}
}
The .inspector() modifier creates a native right-side panel that slides in/out, automatically manages layout, and integrates with the window's toolbar.
Launch at Login
Use SMAppService (macOS 13+):
import ServiceManagement
// Check status:
switch SMAppService.mainApp.status {
case .enabled: /* running at login */
case .requiresApproval: /* registered but user must approve in System Settings */
case .notRegistered, .notFound: /* not registered */
}
// Register:
try SMAppService.mainApp.register()
// Unregister:
try SMAppService.mainApp.unregister()
The requiresApproval state is unique to macOS -- the app has asked to launch at login, but the user must manually approve it in System Settings > General > Login Items.
Always disable in debug builds to avoid polluting the login item list during development.
Quick Look Preview
Show a system Quick Look panel for any file (images, PDFs, videos, documents):
import QuickLookUI
class PreviewPresenter: NSObject, QLPreviewPanelDataSource {
var url: URL?
func show(url: URL) {
self.url = url
guard let panel = QLPreviewPanel.shared() else { return }
NSApp.activate() // MUST activate first or panel opens behind other windows
panel.dataSource = self
panel.reloadData()
panel.makeKeyAndOrderFront(nil)
}
func numberOfPreviewItems(in panel: QLPreviewPanel!) -> Int { url != nil ? 1 : 0 }
func previewPanel(_ panel: QLPreviewPanel!, previewItemAt index: Int) -> (any QLPreviewItem)! {
url as? NSURL
}
}
NSWorkspace -- OS Integration
// Open URL in default browser:
NSWorkspace.shared.open(URL(string: "https://example.com")!)
// Reveal file in Finder (selects it):
NSWorkspace.shared.activateFileViewerSelecting([fileURL])
// Get the frontmost application:
let app = NSWorkspace.shared.frontmostApplication
let name = app?.localizedName // e.g., "Safari"
// Check accessibility preferences:
NSWorkspace.shared.accessibilityDisplayShouldReduceMotion // Respect "Reduce Motion"
NSWorkspace.shared.accessibilityDisplayShouldReduceTransparency
UserDefaults + @AppStorage
Programmatic access
// Write:
UserDefaults.standard.set(true, forKey: "autoSave")
UserDefaults.standard.set(0.8, forKey: "quality")
// Read (returns false/0/nil if key doesn't exist):
let autoSave = UserDefaults.standard.bool(forKey: "autoSave")
let quality = UserDefaults.standard.double(forKey: "quality")
Reactive SwiftUI binding
struct SettingsView: View {
@AppStorage("autoSave") private var autoSave = false
@AppStorage("quality") private var quality = 0.8
var body: some View {
Toggle("Auto Save", isOn: $autoSave) // Auto-persisted
Slider(value: $quality, in: 0...1) // Auto-persisted
}
}
@AppStorage automatically reads from and writes to UserDefaults, and triggers SwiftUI view updates when the value changes.
ScreenCaptureKit
Capture screen content at native Retina resolution:
import ScreenCaptureKit
let content = try await SCShareableContent.excludingDesktopWindows(false, onScreenWindowsOnly: false)
guard let display = content.displays.first else { return }
let filter = SCContentFilter(display: display, excludingWindows: [])
let config = SCStreamConfiguration()
let scale = CGFloat(filter.pointPixelScale)
config.width = Int(CGFloat(display.width) * scale) // Points → pixels
config.height = Int(CGFloat(display.height) * scale)
config.showsCursor = false
let image = try await SCScreenshotManager.captureImage(contentFilter: filter, configuration: config)
The points-to-pixels conversion is critical. ScreenCaptureKit works in points, but output dimensions must be in pixels for Retina resolution.
Common Mistakes Web Devs Make
| What they try |
Why it fails |
What to do instead |
SwiftUI Window scene for floating UI |
Steals focus, shows in Dock, no transparency |
Use NSPanel with .nonactivatingPanel |
z-index thinking for window ordering |
macOS uses discrete window levels, not a flat stack |
Set window.level to .floating, .screenSaver, etc. |
window.innerHeight for positioning |
Doesn't account for menu bar, Dock, or notch |
Use NSScreen.visibleFrame or .frame depending on context |
navigator.clipboard.writeText() |
macOS requires clearContents() first |
Always call pasteboard.clearContents() before writing |
addEventListener('keydown') for global shortcuts |
Only works when app is focused |
Use Carbon RegisterEventHotKey for system-wide |
<input type="file"> mental model |
macOS has modal, sheet-modal, and async file pickers |
Use NSOpenPanel with the right presentation mode |
| Single-monitor assumptions |
macOS users commonly have 2-3 displays |
Always use NSScreen.screens and find the right one |
| CSS animation for everything |
macOS has spring physics, reduced motion, per-window animation |
Use SwiftUI .animation(.spring(...)) and check accessibilityDisplayShouldReduceMotion |
