Ios Development

Quick Reference

Modern Swift Stack (iOS 17+)

Glass Effect Quick Reference

// Basic glass
.glassEffect()

// Tinted + interactive
.glassEffect(.regular.tint(.blue).interactive())

// Group related elements
GlassEffectContainer { ... }

// Morphing sheet
.matchedTransitionSource(id: "x", in: namespace)
.navigationTransition(.zoom(sourceID: "x", in: namespace))

PART 1: LIQUID GLASS DESIGN SYSTEM

Design Philosophy

Liquid Glass is Apple's translucent material that reflects and refracts surroundings while dynamically transforming to bring focus to content.

Core Principles

1. Dynamic Transparency - Interfaces feel like overlapping sheets of glass
2. Glass is Overlay - Apply ONLY to elements on TOP of UI (toolbars, FABs, modals)
3. Fluid Interaction - Morphing transitions connect related elements
4. Depth and Context - Elements create sense of spatial hierarchy
5. Colorful Backgrounds - Vibrant content behind glass makes effects shine

Layout Rules

• Keep essential UI in central 70% of canvas
• Let tab bars auto-collapse on scroll
• Think in layers: content at bottom, glass controls on top
• Apply glass sparingly (key surfaces only)
• Use native Apple components (optimized for Liquid Glass)

What NOT to Do

• Don't create custom components (poor Liquid Glass compatibility)
• Don't align thin borders exactly with mask edges
• Don't overuse glass effects
• Don't apply glass to main content areas
• Don't stack multiple glass layers

MANDATORY by iOS 27 - Apple will remove option to retain old designs.

Glass Effect APIs

Basic Glass Effect

// Simple glass background
Button("Action") { }
    .glassEffect()

// Tinted glass with color
Button("Save") { }
    .glassEffect(.regular.tint(.blue))

// Interactive glass (grows + shimmers on touch)
Button("Tap Me") { }
    .glassEffect(.regular.tint(.purple.opacity(0.8)).interactive())

// Button style alternative
Button("Glass Button") { }
    .buttonStyle(.glass)

Glass Effect Container

Group elements to blend together:

GlassEffectContainer {
    HStack(spacing: 12) {
        Button(action: {}) {
            Image(systemName: "camera")
        }
        .glassEffect()

        Button(action: {}) {
            Image(systemName: "photo")
        }
        .glassEffect()
    }
}

Glass Effect Identity

Link related elements across view hierarchy:

@Namespace private var glassNamespace

VStack {
    Button("Expand") { }
        .glassEffectID("action", in: glassNamespace)

    if expanded {
        DetailPanel()
            .glassEffectID("action", in: glassNamespace)
    }
}

Custom Glass Shapes

// Circular glass
Circle()
    .glassEffect()
    .frame(width: 60, height: 60)

// Custom shape
CustomPath()
    .glassEffect(.regular, in: CustomShape())

Liquid Glass Sheets

Partial Height (Floating)

.sheet(isPresented: $showSheet) {
    ContentView()
        .presentationDetents([.medium, .large])
        // Auto-gets Liquid Glass background
}

Morphing Transitions

struct ContentView: View {
    @Namespace private var transition
    @State private var showInfo = false

    var body: some View {
        NavigationStack {
            MainContent()
                .toolbar {
                    ToolbarItem(placement: .bottomBar) {
                        Button("Info", systemImage: "info") {
                            showInfo = true
                        }
                    }
                    .matchedTransitionSource(id: "info", in: transition)
                }
                .sheet(isPresented: $showInfo) {
                    InfoView()
                        .presentationDetents([.medium, .large])
                        .navigationTransition(.zoom(sourceID: "info", in: transition))
                }
        }
    }
}

Component Patterns

Floating Action Bar

struct FloatingActionBar: View {
    let actions: [ActionItem]

    var body: some View {
        GlassEffectContainer {
            HStack(spacing: 16) {
                ForEach(actions) { action in
                    Button(action: action.handler) {
                        Image(systemName: action.icon)
                            .font(.title2)
                    }
                    .glassEffect(.regular.interactive())
                }
            }
            .padding(.horizontal, 20)
            .padding(.vertical, 12)
        }
        .glassEffect()
    }
}

Glass Card

struct GlassCard<Content: View>: View {
    @ViewBuilder let content: Content

    var body: some View {
        content
            .padding(20)
            .background {
                RoundedRectangle(cornerRadius: 24)
                    .glassEffect(.regular.tint(.white.opacity(0.1)))
            }
    }
}

Animated Counter

struct GlassCounter: View {
    let value: Int

    var body: some View {
        Text("\(value)")
            .font(.system(size: 48, weight: .bold, design: .rounded))
            .contentTransition(.numericText())
            .padding(24)
            .glassEffect(.regular.tint(.blue.opacity(0.3)).interactive())
            .animation(.spring(duration: 0.3), value: value)
    }
}

PART 2: MODERN SWIFT ARCHITECTURE

State Management: @Observable

CRITICAL: Always use @Observable (iOS 17+). ObservableObject is legacy.

import Observation

@Observable
final class MyViewModel {
    var title: String = ""
    var items: [Item] = []
    var isLoading: Bool = false

    // NO @Published needed!
    // Views auto-update when properties they READ change

    func loadItems() async {
        isLoading = true
        items = await fetchItems()
        isLoading = false
    }
}

In Views:

struct MyView: View {
    @State private var viewModel = MyViewModel()  // NOT @StateObject

    var body: some View {
        List(viewModel.items) { item in
            Text(item.name)
        }
        .task {
            await viewModel.loadItems()
        }
    }
}

Why @Observable?

• Performance: Views only re-render when properties they actually read change
• Simplicity: No @Published, @ObservedObject, @StateObject boilerplate
• Apple recommended: "For new development, using Observable is the easiest way"

SwiftData: ALWAYS Use VersionedSchema

Never ship unversioned SwiftData. Start with VersionedSchema from day one to avoid migration crashes.

import SwiftData

// ALWAYS start versioned
enum AppSchemaV1: VersionedSchema {
    static var versionIdentifier = Schema.Version(1, 0, 0)

    static var models: [any PersistentModel.Type] {
        [Item.self, Category.self]
    }

    @Model
    final class Item {
        var id: UUID
        var name: String
        var createdAt: Date

        init(name: String) {
            self.id = UUID()
            self.name = name
            self.createdAt = Date()
        }
    }

    @Model
    final class Category {
        var id: UUID
        var name: String

        @Relationship(deleteRule: .cascade)
        var items: [Item] = []

        init(name: String) {
            self.id = UUID()
            self.name = name
        }
    }
}

// Migration Plan (even for V1)
enum AppMigrationPlan: SchemaMigrationPlan {
    static var schemas: [any VersionedSchema.Type] {
        [AppSchemaV1.self]
    }

    static var stages: [MigrationStage] { [] }
}

Adding V2 Later

enum AppSchemaV2: VersionedSchema {
    static var versionIdentifier = Schema.Version(2, 0, 0)

    @Model
    final class Item {
        var id: UUID

        // RENAMING: Use @Attribute(originalName:)
        @Attribute(originalName: "name")
        var title: String

        var createdAt: Date

        // NEW PROPERTY: Provide default
        var priority: Int = 0
    }
}

enum AppMigrationPlan: SchemaMigrationPlan {
    static var schemas: [any VersionedSchema.Type] {
        [AppSchemaV1.self, AppSchemaV2.self]
    }

    static var stages: [MigrationStage] {
        [migrateV1toV2]
    }

    static let migrateV1toV2 = MigrationStage.lightweight(
        fromVersion: AppSchemaV1.self,
        toVersion: AppSchemaV2.self
    )
}

Migration Rules

Lightweight (automatic):

• Adding new models
• Adding properties with default values
• Deleting properties
• Renaming with @Attribute(originalName:)

Crashes if you:

• Ship unversioned, then add VersionedSchema
• Add .unique when duplicates exist
• Rename without @Attribute(originalName:)

MVVM Pattern with SwiftData

// VIEW: @Query for reactive data
struct ItemListView: View {
    @Query(sort: \Item.createdAt, order: .reverse)
    private var items: [Item]

    @State private var viewModel = ItemListViewModel()
    @Environment(\.modelContext) private var modelContext

    var body: some View {
        List(items) { item in
            ItemRow(item: item)
        }
        .toolbar {
            Button("Add") {
                viewModel.addItem(context: modelContext)
            }
            .glassEffect(.regular.interactive())
        }
    }
}

// VIEWMODEL: Operations only
@Observable
final class ItemListViewModel {
    var newItemName = ""

    func addItem(context: ModelContext) {
        let item = Item(name: newItemName)
        context.insert(item)
        try? context.save()
        newItemName = ""
    }

    func deleteItem(_ item: Item, context: ModelContext) {
        context.delete(item)
        try? context.save()
    }
}

Pattern:

• @Query in Views for reactive display
• ViewModels for business logic
• Pass ModelContext to methods (don't store as property)

App Entry Point

import SwiftUI
import SwiftData

@main
struct MyApp: App {
    var sharedModelContainer: ModelContainer = {
        let schema = Schema(versionedSchema: AppSchemaV1.self)
        let config = ModelConfiguration(schema: schema, isStoredInMemoryOnly: false)

        do {
            return try ModelContainer(
                for: schema,
                migrationPlan: AppMigrationPlan.self,
                configurations: [config]
            )
        } catch {
            fatalError("Could not create ModelContainer: \(error)")
        }
    }()

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(sharedModelContainer)
    }
}

PART 3: PROJECT STRUCTURE

ProjectName/
├── App/
│   ├── ProjectNameApp.swift           # @main, ModelContainer
│   └── AppConfig.swift                # Configuration constants
│
├── Models/
│   ├── Schemas/
│   │   ├── AppSchemaV1.swift          # VersionedSchema V1
│   │   └── AppMigrationPlan.swift     # SchemaMigrationPlan
│   └── Domain/
│       └── DomainModels.swift         # Non-persisted models
│
├── Views/
│   ├── ContentView.swift
│   ├── [Feature]/
│   │   ├── [Feature]View.swift
│   │   └── [Feature]Components.swift
│   └── Components/
│       ├── GlassCard.swift
│       └── FloatingActionBar.swift
│
├── ViewModels/
│   └── [Feature]ViewModel.swift       # @Observable ViewModels
│
├── Services/
│   ├── NetworkService.swift
│   └── [Domain]Service.swift
│
├── Utilities/
│   ├── Extensions/
│   └── Constants.swift
│
└── Resources/
    ├── Assets.xcassets
    ├── Localizable.xcstrings
    └── PrivacyInfo.xcprivacy          # Required since May 2024

PART 4: APP STORE VERIFICATION CHECKLIST

Run before EVERY App Store submission.

TIER 1: Critical (Prevents Rejections)

Build Quality

• Clean Release build succeeds
• ZERO warnings in Release configuration
• BUILD_ACTIVE_ARCHITECTURE_ONLY = NO for Release

Code Signing

• Team ID: YOUR_TEAM_ID
• Bundle identifier: reverse-DNS format
• Provisioning profile valid and not expired
• Deployment target iOS 17.0+

Privacy & Security

• PrivacyInfo.xcprivacy exists (required since May 2024)
• Required reason APIs declared:
  • UserDefaults API
  • File timestamp APIs
  • System boot time APIs
  • Disk space APIs
• Privacy descriptions in Info.plist
• All URLs use HTTPS
• No hardcoded credentials or API keys

Deprecated APIs

• No UIWebView (use WKWebView)
• No ObservableObject (use @Observable)
• No Core Data (use SwiftData)
• Third-party libraries iOS 26 compatible

Assets

• App icon 1024x1024px present
• App icon has NO transparency
• App icon has NO applied effects
• Launch screen configured

TIER 2: Quality

Code Quality

• No placeholder text ("lorem ipsum", "TODO: Replace")
• No TODO/FIXME comments in production
• No debug print statements
• No forced unwraps in production paths

Info.plist

• CFBundleVersion set
• CFBundleShortVersionString matches release
• CFBundleDisplayName set
• UISupportedInterfaceOrientations set

TIER 3: iOS 26 Specific

• Built with Xcode 16+
• Liquid Glass design implemented
• Essential UI in central 70% of canvas
• No dependencies blocking iOS 26

PART 5: DEPRECATED PATTERNS

PART 6: UIKit INTEGRATION

For camera apps and other UIKit requirements:

// SwiftUI wrapper for UIKit view
struct CameraPreview: UIViewRepresentable {
    let session: AVCaptureSession

    func makeUIView(context: Context) -> PreviewView {
        let view = PreviewView()
        view.videoPreviewLayer.session = session
        view.videoPreviewLayer.videoGravity = .resizeAspectFill
        return view
    }

    func updateUIView(_ uiView: PreviewView, context: Context) {}
}

class PreviewView: UIView {
    override class var layerClass: AnyClass {
        AVCaptureVideoPreviewLayer.self
    }

    var videoPreviewLayer: AVCaptureVideoPreviewLayer {
        layer as! AVCaptureVideoPreviewLayer
    }
}

UIKit Navigation Bar with SwiftUI Content

// In UIViewController
let hostingController = UIHostingController(rootView: SwiftUIToolbar())
hostingController.sizingOptions = [.intrinsicContentSize]
hostingController.view.setContentCompressionResistancePriority(.defaultHigh, for: .horizontal)
navigationItem.rightBarButtonItem = UIBarButtonItem(customView: hostingController.view)

PART 7: PERFORMANCE

Glass Effect Performance

• Glass uses CABackdropLayer - GPU intensive
• Test on target devices (iPhone XR, SE for baseline)
• Limit simultaneous glass surfaces to 3-5
• Avoid glass on rapidly-animating content
• Profile with Instruments if frame drops occur

SwiftData Performance

// Batch operations
modelContext.autosaveEnabled = false
for item in items {
    modelContext.insert(item)
}
try modelContext.save()
modelContext.autosaveEnabled = true

// Efficient queries with predicates
@Query(filter: #Predicate<Item> { $0.isActive })
private var activeItems: [Item]

@Observable Performance

Views only re-render when properties they actually read change:

@Observable
class ViewModel {
    var title: String = ""      // Change triggers re-render only if view reads title
    var internalState: Int = 0  // No re-render if view doesn't read this
}

PART 8: COMMON COMMANDS

# Build and run
xcodebuild -scheme ProjectName -destination 'platform=iOS Simulator,name=iPhone 16 Pro'

# Run tests
xcodebuild test -scheme ProjectName -destination 'platform=iOS Simulator,name=iPhone 16 Pro'

# Clean build
xcodebuild clean -scheme ProjectName

# Archive for App Store
xcodebuild archive -scheme ProjectName -archivePath build/ProjectName.xcarchive

# Show build settings
xcodebuild -showBuildSettings | grep -E "TEAM|BUNDLE|TARGET"

Quick Start Checklist

• Set deployment target iOS 17.0 minimum
• Configure Team ID: YOUR_TEAM_ID
• Create folder structure
• Define VersionedSchema from day one
• Use @Observable for all ViewModels
• Use @State for ViewModels in Views
• Use native Apple components (Liquid Glass optimized)
• Keep essential UI in central 70% of canvas
• Apply .glassEffect() only to overlay elements
• Create PrivacyInfo.xcprivacy
• Test on iOS 26 simulator
• Run verification checklist before submission

App Store Text Rules

• Never use emojis in "What to Test" or App Store texts
• Follow Liquid Glass design for iOS 26+ screenshots
• Ensure app icon follows current guidelines
• Test on multiple device sizes

Resources

• Apple: Liquid Glass Overview
• Apple: Applying Liquid Glass
• WWDC25: Build with New Design
• SwiftData Documentation
• Observable Macro
• Human Interface Guidelines