Swift & Apple Platform Development

Build native apps for iOS, macOS, tvOS, and iPadOS using Swift and SwiftUI.

Instructions

1. For SwiftUI views, modifiers, and state management, see references/swiftui-reference.md
2. For async/await, actors, and structured concurrency, see references/swift-concurrency.md
3. For MVVM, @Observable, and SwiftData patterns, see references/app-architecture.md
4. For iOS/macOS/tvOS/iPadOS specific APIs, see references/platform-apis.md
5. For Xcode configuration, signing, and App Store, see references/xcode-distribution.md
6. PROACTIVELY use WebSearch to find current Apple Developer Documentation when you need deeper information on any Apple framework or API not covered in local references
7. PROACTIVELY fetch https://www.swift.org/documentation/ for Swift language documentation and evolution proposals

Online Documentation Resources

When local references don't cover what you need:

Quick Start

# Create new Xcode project (use Xcode GUI or swift package init)
mkdir MyApp && cd MyApp
swift package init --type executable --name MyApp

# For iOS/macOS apps, use Xcode:
# File → New → Project → App
# Choose SwiftUI for Interface, Swift for Language

Reference Files

Load these based on the task at hand:

Project Structure

MyApp/
├── MyApp.xcodeproj           # Xcode project
├── MyApp/
│   ├── MyAppApp.swift        # @main App entry point
│   ├── ContentView.swift     # Root view
│   ├── Views/                # SwiftUI views
│   │   ├── HomeView.swift
│   │   └── DetailView.swift
│   ├── Models/               # Data models
│   │   └── Item.swift
│   ├── ViewModels/           # View models (@Observable)
│   │   └── HomeViewModel.swift
│   ├── Services/             # API, persistence, etc.
│   │   └── DataService.swift
│   ├── Resources/
│   │   └── Assets.xcassets
│   └── Info.plist
├── MyAppTests/
└── MyAppUITests/

Essential Patterns Quick Reference

App Entry Point

import SwiftUI

@main
struct MyAppApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

SwiftUI View with State

import SwiftUI

struct CounterView: View {
    @State private var count = 0

    var body: some View {
        VStack {
            Text("Count: \(count)")
                .font(.largeTitle)

            Button("Increment") {
                count += 1
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

@Observable ViewModel (iOS 17+)

import SwiftUI
import Observation

@Observable
class HomeViewModel {
    var items: [Item] = []
    var isLoading = false
    var error: Error?

    func loadItems() async {
        isLoading = true
        defer { isLoading = false }

        do {
            items = try await ItemService.shared.fetchItems()
        } catch {
            self.error = error
        }
    }
}

struct HomeView: View {
    @State private var viewModel = HomeViewModel()

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

Navigation (iOS 16+)

import SwiftUI

struct RootView: View {
    @State private var path = NavigationPath()

    var body: some View {
        NavigationStack(path: $path) {
            List {
                NavigationLink("Go to Detail", value: "detail-id")
            }
            .navigationDestination(for: String.self) { id in
                DetailView(id: id)
            }
            .navigationTitle("Home")
        }
    }
}

Async/Await

func fetchData() async throws -> [Item] {
    let url = URL(string: "https://api.example.com/items")!
    let (data, response) = try await URLSession.shared.data(from: url)

    guard let httpResponse = response as? HTTPURLResponse,
          httpResponse.statusCode == 200 else {
        throw APIError.invalidResponse
    }

    return try JSONDecoder().decode([Item].self, from: data)
}

// Usage in SwiftUI
.task {
    do {
        items = try await fetchData()
    } catch {
        self.error = error
    }
}

SwiftData Model (iOS 17+)

import SwiftData

@Model
class Item {
    var name: String
    var createdAt: Date
    var category: Category?

    init(name: String, createdAt: Date = .now) {
        self.name = name
        self.createdAt = createdAt
    }
}

// In App
@main
struct MyAppApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
        .modelContainer(for: Item.self)
    }
}

// In View
struct ItemsView: View {
    @Query var items: [Item]
    @Environment(\.modelContext) private var modelContext

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

    func addItem() {
        let item = Item(name: "New Item")
        modelContext.insert(item)
    }
}

Common Xcode Commands

# Build from command line
xcodebuild -project MyApp.xcodeproj -scheme MyApp -configuration Debug build

# Run tests
xcodebuild test -project MyApp.xcodeproj -scheme MyApp -destination 'platform=iOS Simulator,name=iPhone 15'

# Archive for distribution
xcodebuild archive -project MyApp.xcodeproj -scheme MyApp -archivePath MyApp.xcarchive

# List available simulators
xcrun simctl list devices

# Boot a simulator
xcrun simctl boot "iPhone 15"

# Install app on simulator
xcrun simctl install booted MyApp.app

Troubleshooting

Common Issues

"Cannot find type 'X' in scope"

• Check import statements
• Verify target membership of files
• Clean build folder: Cmd+Shift+K

SwiftUI preview not working

• Check for compile errors in the file
• Restart Xcode
• Clean derived data: rm -rf ~/Library/Developer/Xcode/DerivedData

Signing issues

• Open Signing & Capabilities in Xcode
• Select your team
• Let Xcode manage signing automatically

"Module 'X' was not compiled with library evolution support"

• Clean build folder
• Delete derived data
• Restart Xcode

Best Practices

1. Use SwiftUI for all new UI work
2. Prefer @Observable over ObservableObject (iOS 17+)
3. Use async/await instead of completion handlers
4. Follow Apple HIG for each platform
5. Support Dynamic Type for accessibility
6. Use SF Symbols for icons
7. Test on real devices before release
8. Use SwiftData over Core Data for new projects (iOS 17+)
9. Implement proper error handling with Result or throws
10. Keep views simple - extract logic to view models