Ios 26 Platform

iOS 26 Platform

iOS 26 introduces Liquid Glass, Apple's next-generation material design system that dynamically bends light, moves organically, and adapts automatically across all platforms.

Overview

iOS 26 modernizes UI with new materials (Liquid Glass), SwiftUI APIs (WebView, Chart3D, @Animatable), and advanced features (@BackoffAnimation, free-form windows). The core principle: modern UI gets updated automatically at compile time; most Liquid Glass benefits are "free" from recompiling with Xcode 26.

Reference Loading Guide

ALWAYS load reference files if there is even a small chance the content may be required. It's better to have the context than to miss a pattern or make a mistake.

Core Workflow

1. Check deployment target — iOS 26+ required for Liquid Glass 2. Recompile with Xcode 26 — Standard controls get glass automatically 3. Identify navigation layer — Apply glass to tab bars, toolbars, navigation (not content) 4. Choose variant — Regular (95% of cases) or Clear (media-rich backgrounds only) 5. Add @available guards — For backward compatibility with iOS 17/18 6. Test accessibility — Verify Reduce Transparency, Increase Contrast, Reduce Motion

Common Mistakes

1. Ignoring backward compatibility — Targeting iOS 26+ without @available guards breaks iOS 17/18 support. Always use if #available(iOS 26, *) for Liquid Glass or new APIs.

2. Over-using glass effect — Applying glass to content areas, not just navigation, creates visual noise. Glass works for: tab bars, toolbars, sheets, navigation. NOT for content areas.

3. Animation performance issues — Liquid Glass animations can be expensive. Respect Reduce Motion accessibility setting and profile with Instruments 26 before shipping.

4. Assuming Clear variant looks good — Clear is for media-rich backgrounds only (photos, video). Regular variant is correct 95% of the time. Only use Clear if you explicitly need the ultra-transparency.

5. Not testing on actual devices — Simulator rendering differs from hardware. Test glass effects on iPhone 15 Pro, iPad, and Mac to verify visual quality.

6. Using old UIView patterns with new glass — Mixing UIView-based navigation with iOS 26 glass creates inconsistent appearances. Migrate fully to SwiftUI or wrap carefully with UIViewRepresentable.

Automatic vs Explicit Adoption

iOS 26+

What Changes Automatically (Recompile Only)

Standard Components Get Liquid Glass

Simply recompile with Xcode 26 — no code changes:

// All these get glass automatically:
NavigationView { ... }
TabView { ... }
.toolbar { ... }
.sheet { ... }
.popover { ... }
List { ... }

Controls Get New Appearance

• Toggles, segmented pickers, sliders
• Knobs transform into glass during interaction
• Buttons morph into menus/popovers

Search Placement

NavigationSplitView {
    List { }
        .searchable(text: $searchText)
}
// Automatically:
// - Bottom-aligned on iPhone (ergonomic)
// - Top trailing on iPad

Performance Improvements

• 6x faster loading for 100k+ item lists (macOS)
• 16x faster updates for large lists
• Reduced dropped frames during scrolling
• Better nested ScrollView performance with lazy stacks

What Requires Code Changes

Toolbar Customization

.toolbar {
    ToolbarItemGroup(placement: .topBarTrailing) {
        Button("Up") { }
        Button("Down") { }

        Spacer(.fixed) // NEW: Separates button groups

        Button("Settings") { }
    }
}

Prominent Toolbar Buttons

Button("Add Trip") {
    addTrip()
}
.buttonStyle(.borderedProminent)
.tint(.blue) // Tinting in glass toolbars

Glass Effect for Custom Views

CustomPhotoGrid()
    .glassBackgroundEffect() // Reflects surrounding content

Search Tab Role

TabView {
    SearchView()
        .tabItem { Label("Search", systemImage: "magnifyingglass") }
        .tabRole(.search) // Separates from tabs, morphs into search
}

Tab Bar Minimization

TabView { ... }
    .tabBarMinimizationBehavior(.onScrollDown) // Recedes on scroll

Audit Checklist

Remove These (Interfere with Glass)

// Remove custom backgrounds on navigation
NavigationView { }
    .background(Color.blue.opacity(0.5)) // Remove

// Remove custom blur effects
.background(
    VisualEffectView(effect: UIBlurEffect(style: .systemMaterial))
) // Remove — let system handle

// Remove hard-coded dimensions
Slider(value: $volume)
    .frame(width: 250, height: 44) // Remove — new metrics

Update These

// Section headers: Use title-style capitalization
Section(header: Text("User Settings")) { } // Not "user settings"

// Forms: Use grouped style
Form { ... }
    .formStyle(.grouped) // Platform-optimized metrics

Safe Area Considerations

// When glass extends edge-to-edge with .ignoresSafeArea()
// Use .safeAreaPadding() for content (not .padding())

ZStack {
    RoundedRectangle(cornerRadius: 12)
        .fill(.thinMaterial)
        .ignoresSafeArea()

    VStack {
        content
    }
    .safeAreaPadding(.horizontal, 20) // Respects notch/home indicator
}

Testing Required

1. Light/dark modes — Glass adapts independently 2. Reduce Transparency — Glass becomes frostier 3. Increase Contrast — Elements become black/white 4. Reduce Motion — Elastic properties disabled 5. Dynamic Type — Larger text sizes 6. Content scrolling — Verify scroll edge effects

Platform-Specific Changes

iPad

• Tab bar can adapt to sidebar
• Resizable windows (UIRequiresFullscreen deprecated)
• Menu bar via swipe down

macOS

• Synchronized window resize animations
• Window controls adapt automatically
• Glassy sidebars reflect content

watchOS

• Minimal changes, automatic adoption
• Use standard toolbar APIs and button styles

tvOS

• Focus-based glass appearance
• Apple TV 4K 2nd gen+ required for full effects

Backward Compatibility

iOS 17/18 + iOS 26

UIDesignRequiresCompatibility Key

Opt Out of Liquid Glass (Temporarily)

<!-- Info.plist -->
<key>UIDesignRequiresCompatibility</key>
<true/>

Effect:

• App built with iOS 26 SDK
• Appearance matches iOS 18 and earlier
• Liquid Glass effects disabled
• Previous blur/material styles used

Migration Strategy

1. Ship with UIDesignRequiresCompatibility enabled 2. Audit interface changes in separate build 3. Update interface incrementally 4. Remove key when ready for Liquid Glass

@available Patterns

Basic Check

if #available(iOS 26, *) {
    content
        .glassEffect()
} else {
    content
        .background(.ultraThinMaterial)
}

View Modifier Pattern

extension View {
    @ViewBuilder
    func adaptiveGlass() -> some View {
        if #available(iOS 26, *) {
            self.glassEffect()
        } else {
            self.background(.regularMaterial)
        }
    }
}

// Usage
Button("Action") { }
    .adaptiveGlass()

Toolbar Spacer Fallback

extension View {
    @ViewBuilder
    func adaptiveToolbar() -> some View {
        if #available(iOS 26, *) {
            self.toolbar {
                ToolbarItemGroup(placement: .topBarTrailing) {
                    Button("Up") { }
                    Button("Down") { }
                    Spacer(.fixed) // iOS 26 feature
                    Button("Settings") { }
                }
            }
        } else {
            self.toolbar {
                ToolbarItem(placement: .topBarTrailing) {
                    Button("Up") { }
                }
                ToolbarItem(placement: .topBarTrailing) {
                    Button("Down") { }
                }
                ToolbarItem(placement: .topBarTrailing) {
                    Button("Settings") { }
                }
            }
        }
    }
}

WebView Fallback

struct ArticleView: View {
    let url: URL

    var body: some View {
        if #available(iOS 26, *) {
            WebView(url: url)
        } else {
            WebViewRepresentable(url: url) // UIViewRepresentable wrapper
        }
    }
}

// iOS 17/18 fallback
struct WebViewRepresentable: UIViewRepresentable {
    let url: URL

    func makeUIView(context: Context) -> WKWebView {
        WKWebView()
    }

    func updateUIView(_ webView: WKWebView, context: Context) {
        webView.load(URLRequest(url: url))
    }
}

@Animatable Fallback

#if swift(>=6.0)
@Animatable
struct ModernShape: Shape {
    var progress: Double

    @AnimatableIgnored
    var style: ShapeStyle
}
#else
struct LegacyShape: Shape {
    var progress: Double

    var animatableData: Double {
        get { progress }
        set { progress = newValue }
    }
}
#endif

Search Tab Role Fallback

TabView {
    if #available(iOS 26, *) {
        SearchView()
            .tabItem { Label("Search", systemImage: "magnifyingglass") }
            .tabRole(.search)
    } else {
        SearchView()
            .tabItem { Label("Search", systemImage: "magnifyingglass") }
    }
}

AttributedString TextEditor

struct CommentEditor: View {
    @State private var richText = AttributedString("Comment")
    @State private var plainText = "Comment"

    var body: some View {
        if #available(iOS 26, *) {
            TextEditor(text: $richText) // Rich text support
        } else {
            TextEditor(text: $plainText) // Plain text only
        }
    }
}

Migration from Previous Materials

From UIBlurEffect

// Before (UIKit)
let blurEffect = UIBlurEffect(style: .systemMaterial)
let blurView = UIVisualEffectView(effect: blurEffect)

// After (SwiftUI with fallback)
extension View {
    @ViewBuilder
    func adaptiveMaterial() -> some View {
        if #available(iOS 26, *) {
            self.glassEffect()
        } else {
            self.background(.regularMaterial)
        }
    }
}

From Custom Materials

Keep custom materials when:

• Backward compatibility with iOS < 26 required
• Specific artistic effect not achievable with glass
• Non-standard UI paradigm

Testing Checklist

iOS 26 Tests

• [ ] Liquid Glass appearance correct
• [ ] Scroll edge effects working
• [ ] Toolbar grouping renders properly
• [ ] Search placement is platform-appropriate
• [ ] Accessibility settings respected

iOS 17/18 Tests

• [ ] Fallback materials render correctly
• [ ] No runtime crashes from @available checks
• [ ] Functionality preserved without glass
• [ ] Layout doesn't break

Deprecated APIs

iPadOS 26

<!-- Remove entirely — deprecated in iPadOS 26 -->
<key>UIRequiresFullscreen</key>

Apps must support resizable windows on iPad.

SwiftUI Updates

// Old (deprecated)
.onChange(of: value, perform: { newValue in })

// New (iOS 17+)
.onChange(of: value) { oldValue, newValue in }

Performance Considerations

When supporting multiple iOS versions:

• Use @available checks at view level, not inside body
• Prefer conditional view modifiers over entire view branches
• Test performance on oldest supported version
• Profile with Instruments on both old and new iOS

Liquid Glass Design System

iOS 26+, iPadOS 26+, macOS Tahoe+, visionOS 3+

What is Liquid Glass?

Apple's next-generation material that dynamically bends light (lensing) rather than scattering it. Unlike blur effects, Liquid Glass:

• Moves organically like lightweight liquid
• Adapts automatically to size, environment, and light/dark modes
• Provides separation through instinctive visual cues

Visual Properties

Lensing (Primary Characteristic)

// Glass warps and bends light in real-time
Text("Hello")
    .glassEffect() // Lensing effect, not blur

• Concentrates and shapes light dynamically
• Elements feel ultra-lightweight yet distinguishable
• Materializes in/out by modulating light bending (not fading)

Motion & Fluidity

• Instant flex and energize on interaction
• Gel-like flexibility for transient UI
• Dynamic morphing between app states
• Lightweight transitions (menus pop open in-line)

Adaptive Behavior

• Shadows increase when text scrolls underneath
• Independently switches light/dark per element
• Larger elements (menus, sidebars) simulate thicker material
• Ambient environment subtly spills onto surface

Variants: Regular vs Clear

CRITICAL: Never mix Regular and Clear in the same interface.

Regular Variant (Default - Use 95% of Time)

// Regular is the default — most versatile
NavigationView {
    Content()
}
.glassEffect() // Full adaptive effects, auto-legibility

// With custom shape
Button("Tap Me") { }
    .glassEffect(in: RoundedRectangle(cornerRadius: 12))

• Works in any size, over any content
• Provides legibility regardless of context
• Anything can be placed on top

Clear Variant (Special Cases Only)

// Use ONLY when ALL THREE conditions are met:
// 1. Over media-rich content
// 2. Dimming layer acceptable
// 3. Content above is bold and bright

ZStack {
    VideoPlayer(player: player)
        .overlay(.black.opacity(0.3)) // Required dimming layer

    PlayButton()
        .glassEffect(.clear) // Clear variant
}

WARNING: Clear without meeting all three conditions = poor legibility.

Layer Architecture

Navigation Layer (Use Glass Here)

// Correct — glass on navigation elements
.toolbar {
    ToolbarItem {
        Button("Add") { }
            .glassEffect()
    }
}

Content Layer (No Glass)

// Wrong — don't apply glass to content
List(items) { item in
    ItemRow(item)
        .glassEffect() // Never do this
}

DO: Best Practices

// Reserve glass for navigation layer
TabView { ... } // Gets glass automatically

// Use fills for elements ON TOP of glass
ZStack {
    NavigationBar()
        .glassEffect()

    FloatingButton()
        .foregroundStyle(.primary) // Fills, not glass
}

// Use adaptive tinting for primary actions
Button("View Bag") { }
    .tint(.red)
    .glassEffect()

DON'T: Common Mistakes

// Don't stack glass on glass
ZStack {
    Toolbar().glassEffect()
    Button().glassEffect() // Wrong
}

// Don't use solid fills on glass
Button("Action") { }
    .background(.red) // Breaks glass character
    .glassEffect()

// Don't tint everything
VStack {
    Button("A").tint(.blue).glassEffect()
    Button("B").tint(.green).glassEffect() // No hierarchy
}

Scroll Edge Effects

ScrollView {
    Content()
}
.scrollEdgeEffectStyle(.hard, for: .top) // Uniform effect

// .soft for gradual fade
// .hard for pinned accessories
// .automatic for system default

Accessibility

All features automatic when using glass:

• Reduced Transparency: Makes glass frostier
• Increased Contrast: Black/white with contrasting border
• Reduced Motion: Decreases effect intensity

GlassEffectContainer

Group multiple glass effects for performance and morphing animations:

GlassEffectContainer(spacing: 8) {
    HStack(spacing: 8) {
        Button { } label: { Image(systemName: "plus") }
            .glassEffect()
            .glassEffectID("add", in: namespace)

        Button { } label: { Image(systemName: "share") }
            .glassEffect()
            .glassEffectID("share", in: namespace)
    }
}

• Groups glass effects for better rendering performance
• Enables morphing transitions between elements
• Use spacing parameter to control when effects blend together

Morphing with glassEffectID

Use @Namespace and .glassEffectID() for smooth morphing transitions:

@Namespace var namespace

// Elements with same ID morph into each other during transitions
if isExpanded {
    ExpandedView()
        .glassEffect()
        .glassEffectID("panel", in: namespace)
} else {
    CollapsedView()
        .glassEffect()
        .glassEffectID("panel", in: namespace)
}

Interactive Glass

Add touch response with .interactive() chained on the glass variant:

// Correct - chain .interactive() on the variant
Button("Tap") { }
    .glassEffect(.regular.interactive())

// With tint
Button("Tap") { }
    .glassEffect(.regular.interactive().tint(.blue))

// With custom shape
Button("Tap") { }
    .glassEffect(.regular.interactive(), in: .rect(cornerRadius: 12))

Caution: Avoid .interactive() on draggable rows - it can interfere with drag gestures.

Known Limitations

Drag previews: Glass effects don't render correctly in drag previews. When using .contentShape(.dragPreview, ...), the glass material won't appear during the lift animation. Use simple shapes for drag previews:

// Glass won't show in drag preview - this is expected
MyGlassCard()
    .glassEffect()
    .contentShape(.dragPreview, RoundedRectangle(cornerRadius: 12))

API Reference

// Basic glass effect
func glassEffect<S: Shape>(
    _ glass: Glass = .regular,
    in shape: S = Capsule()
) -> some View

// Glass variant modifiers (chainable)
Glass.regular.interactive()           // Adds touch response
Glass.regular.tint(.color)            // Adds color tint
Glass.regular.interactive().tint(.color) // Both

// Morphing support
func glassEffectID<ID: Hashable>(_ id: ID, in namespace: Namespace.ID) -> some View

// Container for multiple effects
GlassEffectContainer(spacing: CGFloat) { content }

// For custom views (reflects surrounding content)
func glassBackgroundEffect() -> some View

// Scroll edge styling
func scrollEdgeEffectStyle(_ style: ScrollEdgeStyle, for edges: Edge.Set) -> some View

SwiftUI 26 New APIs

iOS 26+, iPadOS 26+, macOS Tahoe+

WebView & WebPage

Basic WebView

import WebKit

struct ArticleView: View {
    let articleURL: URL

    var body: some View {
        WebView(url: articleURL)
    }
}

WebPage (Observable Model)

import WebKit

struct BrowserView: View {
    @State private var webPage = WebPage()

    var body: some View {
        VStack {
            Text(webPage.title ?? "Loading...")

            WebView(page: webPage)

            HStack {
                Button("Back") { webPage.goBack() }
                    .disabled(!webPage.canGoBack)

                Button("Forward") { webPage.goForward() }
                    .disabled(!webPage.canGoForward)
            }
        }
    }
}

@Animatable Macro

Before (Manual animatableData)

struct HikingRouteShape: Shape {
    var startPoint: CGPoint
    var endPoint: CGPoint
    var elevation: Double

    // Tedious manual declaration
    var animatableData: AnimatablePair<CGPoint.AnimatableData,
                        AnimatablePair<Double, CGPoint.AnimatableData>> {
        get {
            AnimatablePair(startPoint.animatableData,
                          AnimatablePair(elevation, endPoint.animatableData))
        }
        set {
            startPoint.animatableData = newValue.first
            elevation = newValue.second.first
            endPoint.animatableData = newValue.second.second
        }
    }
}

After (@Animatable Macro)

@Animatable
struct HikingRouteShape: Shape {
    var startPoint: CGPoint
    var endPoint: CGPoint
    var elevation: Double

    @AnimatableIgnored
    var fillColor: Color // Excluded from animation

    // animatableData automatically synthesized!
}

Requirements:

• Properties must be VectorArithmetic (Double, CGFloat, CGPoint)
• Use @AnimatableIgnored for non-animatable properties

Chart3D

import Charts

struct ElevationChart: View {
    let hikingData: [HikeDataPoint]

    var body: some View {
        Chart3D {
            ForEach(hikingData) { point in
                LineMark3D(
                    x: .value("Distance", point.distance),
                    y: .value("Elevation", point.elevation),
                    z: .value("Time", point.timestamp)
                )
            }
        }
        .chartXScale(domain: 0...10)
        .chartYScale(domain: 0...3000)
        .chartZScale(domain: startTime...endTime)
    }
}

TextEditor with AttributedString

struct CommentView: View {
    @State private var comment = AttributedString("Enter your comment")

    var body: some View {
        TextEditor(text: $comment)
        // Built-in formatting controls (bold, italic, etc.)
    }
}

Features:

• Binding to AttributedString preserves formatting
• Automatic toolbar with formatting options
• Customizable paragraph styles and attribute constraints

New View Modifiers

sliderThumbVisibility

Slider(value: $progress)
    .sliderThumbVisibility(.hidden)
// For media players, progress indicators

safeAreaBar

List { ... }
    .safeAreaBar(edge: .bottom) {
        Text("Bottom Action Bar")
            .padding(.vertical, 15)
    }
    .scrollEdgeEffectStyle(.soft, for: .bottom)
// Sticky bars with progressive blur

In-App URL Opening

@Environment(\.openURL) var openURL

Button("Open In-App") {
    openURL(website, prefersInApp: true) // SFSafariViewController style
}
// Default Link opens in Safari app

Button Roles

Button(role: .close) {
    showSheet = false
}
// Renders as X icon with glass effect in toolbars

Button(role: .confirm) {
    confirmAction()
}
// System-styled confirmation button

GlassButtonStyle (iOS 26.1+)

Button("Clear Glass") { }
    .buttonStyle(GlassButtonStyle(.clear))

Button("Regular Glass") { }
    .buttonStyle(GlassButtonStyle(.glass))

Button("Tinted Glass") { }
    .buttonStyle(GlassButtonStyle(.tint))
    .tint(.blue)

buttonSizing

Button("Fit") { }
    .buttonSizing(.fit)      // Shrinks to label

Button("Stretch") { }
    .buttonSizing(.stretch)  // Fills available width

Button("Flexible") { }
    .buttonSizing(.flexible) // Balanced

Drag and Drop Enhancements

struct PhotoGrid: View {
    @State private var selection: Set<Photo.ID> = []
    let photos: [Photo]

    var body: some View {
        LazyVGrid(columns: columns) {
            ForEach(photos) { photo in
                PhotoCell(photo: photo)
                    .draggable(photo)
            }
        }
        .dragContainer {
            // Return selected items
            selection.compactMap { id in
                photos.first { $0.id == id }
            }
        }
        .dragConfiguration(.init(supportedOperations: [.copy, .delete]))
        .dragPreviewFormation(.stack)
        .onDragSessionUpdated { session in
            if case .ended(.delete) = session.phase {
                deleteSelectedPhotos()
            }
        }
    }
}

visionOS Spatial Layout

Alignment3D

HikingRouteView()
    .overlay(alignment: sunAlignment) {
        SunView()
    }

var sunAlignment: Alignment3D {
    Alignment3D(horizontal: .center, vertical: .top, depth: .back)
}

Manipulable Objects

Model3D(named: "WaterBottle")
    .manipulable() // Users can pick up and move

Scene Snapping

@Environment(\.sceneSnapping) var sceneSnapping

var body: some View {
    Model3D(named: item.modelName)
        .overlay(alignment: .bottom) {
            if sceneSnapping.isSnapped {
                Pedestal()
            }
        }
}

GlassEffectContainer

// Optimize multiple glass effects
GlassEffectContainer {
    HStack {
        Button("Action 1") { }.glassEffect()
        Button("Action 2") { }.glassEffect()
        Button("Action 3") { }.glassEffect()
    }
}
// Benefits: Performance optimization, fluid morphing between shapes

Toolbar & Navigation

iOS 26+

Toolbar Spacer API

Separate Button Groups

.toolbar {
    ToolbarItemGroup(placement: .topBarTrailing) {
        // Navigation group
        Button("Up") { }
        Button("Down") { }

        Spacer(.fixed) // Separates groups visually

        // Action group
        Button("Settings") { }
    }
}

Visual Effect: Items within group share Liquid Glass background. .fixed creates clear separation.

Flexible Spacer

.toolbar {
    ToolbarSpacer(.flexible, placement: .topBarTrailing)

    ToolbarItem(placement: .topBarTrailing) {
        Button(role: .close) {
            dismiss()
        }
    }
}

Prominent Toolbar Buttons

.toolbar {
    ToolbarItem(placement: .topBarTrailing) {
        Button("Add Trip") {
            addTrip()
        }
        .buttonStyle(.borderedProminent)
        .tint(.blue) // Tinting works with Liquid Glass
    }
}

Best Practice: Use for primary actions. Don't over-tint.

Close & Confirm Buttons

.sheet(isPresented: $showSheet) {
    NavigationStack {
        VStack { }
            .navigationTitle("Info")
            .toolbar {
                ToolbarSpacer(.flexible, placement: .topBarTrailing)

                ToolbarItem(placement: .topBarTrailing) {
                    Button(role: .close) { // X icon with glass
                        showSheet = false
                    }
                }
            }
    }
    .presentationDetents([.medium])
}

Search Placement

Automatic Platform Placement

NavigationSplitView {
    List { }
        .searchable(text: $searchText)
}
// iPhone: Bottom-aligned (ergonomic)
// iPad: Top trailing corner

Search Tab Role

TabView {
    SearchView()
        .tabItem { Label("Search", systemImage: "magnifyingglass") }
        .tabRole(.search) // Separated, morphs into search field

    TripsView()
        .tabItem { Label("Trips", systemImage: "map") }
}

Compact Search Toolbar

List { ... }
    .navigationTitle("Search Users")
    .searchable(text: $searchText)
    .searchToolbarBehavior(.minimize) // Compact when unfocused
    .toolbar {
        ToolbarSpacer(.flexible, placement: .bottomBar)
        DefaultToolbarItem(kind: .search, placement: .bottomBar)
    }

Prevent Title Hiding (iOS 17.1+)

.searchable(text: $searchText)
.searchPresentationToolbarBehavior(.avoidHidingContent)

Tab Bar Adaptations

Sidebar Adaptable

TabView {
    ContentView()
        .tabItem { Label("Home", systemImage: "house") }
}
.tabViewStyle(.sidebarAdaptable)
// iPad: Can switch to sidebar
// iPhone: Remains tab bar

Tab Bar Minimization

TabView { ... }
    .tabBarMinimizationBehavior(.onScrollDown)
// .onScrollDown - Minimize when scrolling down
// .onScrollUp - Minimize when scrolling up
// .automatic - System decides
// .never - Always visible

Navigation Hierarchy

Clear Layer Separation

Navigation Layer (Liquid Glass)
├── Tab bar
├── Navigation bar
├── Toolbar
└── Floating controls

Content Layer (No Glass)
└── Lists, tables, images, text

Split Views

NavigationSplitView {
    // Sidebar (gets glass automatically)
    List(folders, selection: $selectedFolder) {
        Label($0.name, systemImage: $0.icon)
    }
} content: {
    // Main content
    List(items, selection: $selectedItem) { ... }
} detail: {
    // Inspector
    InspectorView(item: selectedItem)
}

Menus

Standard Actions Get Icons Automatically

Menu("Actions") {
    Button(action: cut) { Text("Cut") }    // Gets scissors icon
    Button(action: copy) { Text("Copy") }   // Gets documents icon
    Button(action: paste) { Text("Paste") } // Gets clipboard icon
}

Match Swipe and Context Menu Actions

List(emails) { email in
    EmailRow(email)
        .swipeActions(edge: .trailing) {
            Button("Delete", systemImage: "trash", role: .destructive) {
                delete(email)
            }
        }
        .contextMenu {
            // Same actions at top of menu
            Button("Delete", systemImage: "trash", role: .destructive) {
                delete(email)
            }
            Divider()
            // Additional actions below
        }
}

iPad Menu Bar

.commands {
    TextEditingCommands()

    CommandGroup(after: .newItem) {
        Button("Add Note") {
            addNote()
        }
        .keyboardShortcut("n", modifiers: [.command, .shift])
    }
}
// Creates menu bar on iPad via swipe down

Icons vs Text in Toolbars

Consistent Style Per Group

// Correct: All icons in group
.toolbar {
    ToolbarItemGroup {
        Button { share() } label: {
            Image(systemName: "square.and.arrow.up")
        }
        Button { save() } label: {
            Image(systemName: "square.and.arrow.down")
        }
    }
}

// Wrong: Mixed icons and text
.toolbar {
    ToolbarItemGroup {
        Button("Save") { } // Text
        Button { } label: { Image(systemName: "...") } // Icon
    }
}

Accessibility Labels Required

Button {
    share()
} label: {
    Image(systemName: "square.and.arrow.up")
}
.accessibilityLabel("Share")