Apple Platforms

Getting Started with Apple Platforms — the five platforms and their UI frameworks, year-based versions and the 27 baseline, developer account types, installing Xcode 27, and running FieldNotes on a simulator and a device.

Xcode Projects, Targets, Schemes and Previews — workspaces, projects, targets and schemes, build configurations and .xcconfig files, the concurrency build settings, #Preview and #Playground, and Device Hub.

Swift Packages and Modularizing an App — remote dependencies, splitting an app into local packages, Package.swift targets and resources, explicit modules and mergeable libraries.

App Structure and Life Cycle (SwiftUI, UIKit, AppKit) — the SwiftUI App and its scene types, scene phases, delegate adaptors, the now-mandatory UIKit scene life cycle, and AppKit’s NSApplication.

App Architecture the Apple Way — model-driven SwiftUI with @Observable models and the environment, a fair comparison with MVVM, injectable services, and the Swift API Design Guidelines.

Swift Concurrency in Apps — MainActor-by-default isolation, @concurrent, .task(id:) and cancellation, bridging callback APIs, the Swift 6.4 additions, and where Combine stands.

One Codebase for iOS, iPadOS, macOS, watchOS and visionOS — a multiplatform target, conditional compilation and availability checks, platform-specific scenes, and choosing between native macOS, Mac Catalyst and "Designed for iPad".

Mixing Swift, Objective-C and C++ in an App — bridging headers and the generated -Swift.h header, annotations that shape the imported API, C++ interoperability, and migrating Objective-C code step by step.

SwiftUI Views and Modifiers — the View protocol, why modifier order matters, custom ViewModifiers, ContentBuilder, view identity, and custom environment values with @Entry.

SwiftUI Layout — the propose-size-place negotiation, stacks and grids, alignment, ViewThatFits, the custom Layout protocol, adaptive layout and scroll APIs, and ArrangementView for iPhone Duo.

State and Data Flow with Observation — one source of truth, @State as a macro, @Binding, @Observable and @Bindable, the environment, and migrating from ObservableObject.

Lists, Tables and Collections — List and ForEach, selection and editing, swipe actions and reordering, Table, lazy scroll views, search, refresh and custom containers.

Navigation and Presentation — NavigationStack and NavigationPath, NavigationSplitView, TabView, sheets, popovers and inspectors, alerts, zoom transitions and toolbars.

Controls, Forms, Text, Images and SF Symbols — forms and controls, focus, rich text and text input, images and AsyncImage, SF Symbols and Dynamic Type.

Drawing, Animation and Gestures — shapes, Canvas and shaders, implicit and explicit animation, springs, transitions and phase and keyframe animators, and composing gestures.

Liquid Glass, Materials and Icons — Liquid Glass as the functional layer above content, custom glass effects in SwiftUI, UIKit and AppKit, accessibility settings, and layered app icons with Icon Composer.

UIKit and AppKit Essentials, and Mixing Them with SwiftUI — view controllers, diffable data sources and the trait system, windows and menus in AppKit, hosting SwiftUI and wrapping UIKit and AppKit views as representables.

Human Interface Guidelines in Practice — how the HIG is organized, its design principles and key foundations, and what each "Designing for …" platform page asks of an app.

Accessibility — VoiceOver labels, values and traits, accessibility elements and actions, Dynamic Type, display accommodations, auditing and testing, and Accessibility Nutrition Labels.

Localization with String Catalogs — String Catalogs, localized string types, plural and device variations, generated symbols, format styles, right-to-left layout, and the XLIFF export and import round trip.

Persisting Models with SwiftData — @Model and its attributes and relationships, containers and contexts, @Query, schema migrations, background model actors, history, and CloudKit sync.

Core Data, CloudKit and iCloud — the Core Data stack for existing apps, NSPersistentCloudKitContainer and sharing, CloudKit used directly, key-value storage, and migrating to SwiftData.

Preferences, Files and Document-Based Apps — UserDefaults and @AppStorage, the sandbox container layout and App Group containers, file coordination, and document-based apps with the new document protocols.

Networking: URLSession, Network Framework and ATS — async URLSession, decoding and retries, background sessions, path monitoring, the Network framework, App Transport Security and certificate pinning.

Background Execution — the suspension model, BGTaskScheduler and its task types, continued processing, background modes, long-running intents, and debugging scheduled tasks.

Notifications, APNs and Live Activities — permission, local and remote notifications, service and content extensions, and Live Activities on the Lock Screen, the Dynamic Island and beyond.

Widgets, Complications and Controls (WidgetKit) — timeline providers and families, interactive and push-updated widgets, Control Center controls, visionOS widgets and Smart Stack relevance.

App Intents, Siri, Shortcuts, Spotlight, Deep Links and Extensions — intents, entities and App Shortcuts, Spotlight and visual intelligence, the 27 additions, universal links, and app extensions.

Apple Intelligence and Machine Learning — the Foundation Models framework and its 27 additions, Core AI and Core ML, Vision, Natural Language, Speech and Translation, and system features such as Writing Tools.

Location and Maps — authorization sessions, live location updates, monitoring and geofences, and MapKit for SwiftUI.

Camera, Media and Photos — PhotosPicker and PhotoKit, AVFoundation capture and playback, the Now Playing framework, and ARKit on iOS.

Health, Motion and Accessories — HealthKit and workouts, Core Motion, Core Bluetooth and AccessorySetupKit, Core NFC, and which capability runs on which platform.

Security and Privacy — the Keychain, biometric authentication, CryptoKit, Sign in with Apple and passkeys, entitlements and the sandbox, privacy manifests, App Tracking Transparency and App Attest.

In-App Purchases and Subscriptions with StoreKit 2 — products and purchases, verified transactions and entitlements, merchandising views, StoreKit testing in Xcode, and App Review’s payment rules.

Augmented Reality with ARKit and RealityKit — RealityKit’s entity-component-system model and RealityView, ARKit on iOS and on visionOS, and Reality Composer Pro assets.

iPadOS: Windows, Multitasking, Pointer and Apple Pencil — resizable windows and multiple scenes, desktop-class menus and keyboard shortcuts, the adaptable sidebar, pointer input, and Apple Pencil.

macOS: Windows, Menus, Commands, Settings and Menu Bar Extras — window scenes, menus and commands, the Settings scene and menu bar extras, AppKit modernization, the App Sandbox, and choosing between native and Catalyst.

watchOS: App Structure, Connectivity, Workouts and the Smart Stack — the single-target watch app, navigation and input, WatchConnectivity, workouts, background sessions, and complications and the Smart Stack.

visionOS: Windows, Volumes, Immersive Spaces and RealityKit — the Shared and Full Space, windows, volumes and ornaments, immersive spaces, spatial input, 3D content, and porting iPad and iPhone apps.

Unit Testing with Swift Testing — @Test and @Suite, expectations, parameterized tests and traits, attachments and exit tests, testing app models and intents, and XCTest interoperability.

UI Tests, Test Plans, Performance Tests and Coverage — UI automation with XCUIApplication, accessibility audits, performance tests, test plans, and code coverage.

Debugging with Xcode and LLDB — breakpoints, LLDB commands, stepping through concurrency, the view and memory graph debuggers, and the runtime sanitizers.

Logging, MetricKit, Crash Reports and Organizer — Logger and signposts, MetricKit, crash report anatomy and symbolication, and the Xcode Organizer.

Performance and Instruments — the measure-fix-verify loop, Time Profiler, hangs and hitches, the SwiftUI and concurrency instruments, memory, energy, launch time and app size.

Membership, Signing, Capabilities and Info.plist — program membership types, certificates, App IDs and provisioning profiles, capabilities and entitlements, Info.plist keys, and Developer Mode.

App Store Connect, TestFlight and App Review — uploading builds, internal and external TestFlight testing, the App Store listing and its compliance questionnaires, App Review, phased release and SDK deadlines.

Distributing Mac Apps with Developer ID and Notarization — Developer ID certificates, the hardened runtime, notarization with notarytool, Gatekeeper, and packaging.

CI/CD with Xcode Cloud and the Command Line — Xcode Cloud workflows, xcodebuild, simctl and devicectl, the App Store Connect API, and running on other CI services.

Cheat Sheets (PDF) — three downloadable one-page A4 summaries for quick memorization: SwiftUI & App Essentials; Data, Services & Shipping; and Platform Differences at a Glance.

SwiftUI — the framework every UI page is written against: App organization, Scenes, Migrating to the SwiftUI life cycle, View fundamentals, Declaring a custom view, Configuring views, Reducing view modifier maintenance, ContentBuilder and Entry().

SwiftUI layout — Layout fundamentals, Picking container views for your content, Building layouts with stack views, Composing custom layouts with SwiftUI, ViewThatFits, ArrangementView, LazyHStack and horizontalSizeClass.

SwiftUI state and data flow — Model data, Managing user interface state, Managing model data in your app, Migrating from the Observable Object protocol to the Observable macro, onChange(of:initial:_:) and task(id:name:priority:file:line:_:).

SwiftUI lists, navigation and presentation — Lists, Displaying data in lists, Tables, Scroll views, reorderContainer(for:isEnabled:move:), Creating custom container views, Reordering items in lists, stacks, grids, and custom layouts, Navigation, Understanding the navigation stack, Bringing robust navigation structure to your SwiftUI app, Migrating to new navigation types, Enhancing your app content with tab navigation, Modal presentations, Toolbars, fullScreenCover(isPresented:onDismiss:content:), NavigationStack, Tab, TabViewCustomization, sidebarAdaptable, verticalPage, Table, searchable(text:isPresented:placement:prompt:), contextMenu(forSelectionType:menu:primaryAction:) and inspector(isPresented:content:).

SwiftUI controls, text, images and graphics — Controls and indicators, Text input and output, Building rich SwiftUI text experiences, Applying custom fonts to text, Images, Fitting images into available space, Drawing and graphics, Shapes, Animations, Controlling the timing and movements of your animations, Gestures, Composing SwiftUI gestures, Drag and drop, Form, TextField, titleAndIcon, ImageRenderer, containerBackground(_:for:), HoverEffect, hoverEffect(_:isEnabled:), pointerStyle(_:), SpatialTapGesture, digitalCrownRotation(_:from:through:by:sensitivity:isContinuous:isHapticFeedbackEnabled:) and handGestureShortcut(_:isEnabled:).

SwiftUI design, accessibility, localization and previews — Applying Liquid Glass to custom views, Accessibility fundamentals, ScaledMetric, Preparing views for localization, Previews in Xcode, accessibilityIdentifier(_:) and isLuminanceReduced.

SwiftUI interoperability — UIKit integration, AppKit integration and Unifying your app’s animations.

SwiftUI windows, menus and commands — Windows, Customizing window styles and state-restoration behavior in macOS, Window, init(id:for:content:), UtilityWindow, Settings, SettingsLink, OpenSettingsAction, MenuBarExtra, menuBarExtraStyle(_:), OpenWindowAction, callAsFunction(id:value:), DismissWindowAction, PresentedWindowContent, WindowPlacement, WindowDragGesture, defaultLaunchBehavior(_:), defaultSize(width:height:), defaultWindowPlacement(_:), restorationBehavior(_:), windowIdealPlacement(_:), windowLevel(_:), windowResizability(_:), windowStyle(_:), windowToolbarStyle(_:), supportsMultipleWindows, Building and customizing the menu bar with SwiftUI, CommandGroup, CommandMenu, SidebarCommands, InspectorCommands, FocusedValue, FocusedValues, FocusedBinding, focusedValue(_:_:), focusedSceneValue(_:_:) and keyboardShortcut(_:modifiers:).

task(name:priority:file:line:_:) — the SwiftUI task modifier behind view-scoped concurrency.

UIKit — the iOS, iPadOS and visionOS UI framework: Managing your app’s life cycle, Transitioning to the UIKit scene-based life cycle, Specifying the scenes your app supports, Using SwiftUI with UIKit, Updating views automatically with observation tracking in UIKit, Automatic trait tracking, Mac Catalyst, Choosing a user interface idiom for your Mac app, UIDocument, beginBackgroundTask(withName:expirationHandler:), application(_:handleEventsForBackgroundURLSession:completionHandler:), application(_:didReceiveRemoteNotification:fetchCompletionHandler:), openSettingsURLString, Building a desktop-class iPad app, Multitasking on iPad, Mac, and Apple Vision Pro, Elevating your iPad app with a tab bar and sidebar, Enhancing your iPad app with pointer interactions, Handling input from Apple Pencil, UIApplicationDelegate, UISceneSession, UISceneClosureConfirmation, UISceneSizeRestrictions, isInteractivelyResizing, windowScene(_:didUpdateEffectiveGeometry:), UIMainMenuSystem, preferredImageVisibility, UIKeyCommand init(title:image:action:input:modifierFlags:propertyList:alternates:discoverabilityTitle:attributes:state:), UIPointerInteraction, zOffset, UIPencilInteraction and pencilInteraction(_:didReceiveSqueeze:).

AppKit — the macOS UI framework, with NSApplication as its entry point: Updating views automatically with observation tracking in AppKit, NSControl.Events, addTarget(_:action:for:) and preventsApplicationTerminationWhenModal.

Observation — the @Observable macro and observation tracking that drive SwiftUI from model data: withObservationTracking(_:onChange:).

Combine — still supported; cited for its current status beside Observation and AsyncSequence.

Swift Charts — the declarative charting framework used to visualize data in SwiftUI.

Adopting Liquid Glass — the technology overview for the 26-and-later design language, alongside Liquid Glass.

Xcode — Creating an Xcode project for an app, Configuring the build settings of a target, Build settings reference, Customizing the build schemes for a project, Adding a build configuration file to your project, Adding previews to your interface files, Interacting with previews in the canvas, Device Hub, Coding intelligence, Configuring a multiplatform app target, Running code on a specific platform or OS version, Creating your app icon using Icon Composer, Configuring app groups, Configuring background execution modes, Configuring the macOS App Sandbox, Defining a custom URL scheme for your app, Supporting associated domains, Build system, Xcode command-line tool reference, Adding capabilities to your app, Specifying your app’s launch screen, Running your app on simulated or physical devices, Managing your simulated and physical devices in Device Hub, Enabling Developer Mode on a device, Enabling enhanced security for your app, Distributing your app for beta testing and releases, Including notes for testers with a beta release of your app, Customizing the build phases of a target, Running custom scripts during a build, Updating your Xcode project configuration file format, Running code snippets using the Playground macro, Giving external agents access to Xcode, Managing assets with asset catalogs and Specifying your app’s color scheme.

Swift packages in Xcode — Swift packages, Adding package dependencies to your app, Organizing your code with local packages, Creating a standalone Swift package with Xcode, Bundling resources with a Swift package, Identifying binary dependencies, Distributing binary frameworks as Swift packages, Configuring your project to use mergeable libraries and Building your project with explicit module dependencies.

Testing in Xcode — Running tests and interpreting results, Improving code assessment by organizing tests into test plans and Determining how much code your tests cover.

XCTest — the older test framework, still used for UI and performance tests: Adding attachments to tests, activities, and issues, XCTAttachment init(screenshot:), measure(metrics:options:block:), XCTClockMetric and XCTApplicationLaunchMetric.

XCUIAutomation — driving the app from UI tests: Recording UI automation for testing, XCUIApplication, XCUIApplication.launchArguments, XCUIElementQuery, wait(for:toEqual:timeout:) and performAccessibilityAudit(for:_:).

Debugging — the Xcode debugger and LLDB: Diagnosing and resolving bugs in your running app, Setting breakpoints to pause your running app, Stepping through code and inspecting variables to isolate bugs, Diagnosing issues in the appearance of a running app, Diagnosing memory, thread, and crash issues early, Building your app to include debugging information, DebugDescription() and Disabling and enabling System Integrity Protection.

Crash reports — Diagnosing issues using crash reports and device logs, Acquiring crash reports and diagnostic logs, Analyzing a crash report, Examining the fields in a crash report and Adding identifiable symbol names to a crash report.

Logging — unified logging and signposts: Logger, OSLogPrivacy, Generating Log Messages from Your Code, Viewing Log Messages, OSLogStore, OSSignposter, withIntervalSignpost(_:id:around:) and Recording Performance Data.

MetricKit — on-device metrics and diagnostics from the field: MetricManager, MetricReport, DiagnosticReport, trackLaunchTask(id:onTrackingError:_:), MXMetricManager, Track performance by app state using MetricKit and Getting started with StateReporting.

Performance and metrics — measuring and improving performance: Improving your app’s performance, Analyzing the performance of your shipping app, Improving app responsiveness, Understanding hangs in your app, Understanding hitches in your app, Reducing your app’s launch time, Reducing your app’s memory use, Gathering information about memory use, Reducing your app’s size, Doing basic optimization to reduce your app’s size, Measuring your app’s power use with Power Profiler, Understanding and improving SwiftUI performance and Writing and running performance tests.

Swift Testing — the test framework, used for the persistence round-trip tests: Defining test functions, Organizing test functions with suite types, Expectations and confirmations, Testing for errors in Swift code, Testing asynchronous code, Implementing parameterized tests, Test(_:_:arguments:_:), Traits, Adding tags to tests, Enabling and disabling tests, Limiting the running time of tests, Running tests serially or in parallel, Known issues, Attachments, Exit testing, TestScoping, Migrating a test from XCTest and Swift Testing overview.

PackageDescription — the Package.swift manifest API.

Swift and concurrency — Concurrency, Adopting Swift 6, Updating an app to use strict concurrency, AsyncStream and TaskLocal.

Swift language interoperability — Importing Objective-C into Swift, Importing Swift into Objective-C, Mixing languages in an Xcode project, Calling APIs across language boundaries, Migrating your Objective-C code to Swift, Designating nullability in Objective-C APIs, Renaming Objective-C APIs for Swift, Improving Objective-C API declarations for Swift, Grouping related Objective-C constants, Making Objective-C APIs unavailable in Swift, Marking API availability in Objective-C and Calling Objective-C APIs asynchronously.

Multiplatform and porting — Running your iOS apps in macOS, Bringing your app to visionOS, Building a universal macOS binary, About the Rosetta translation environment and Preparing your app for iPhone Duo.

Apple Pencil and PencilKit — Handling squeezes from Apple Pencil, PKCanvasView, PKCanvasView.drawingPolicy, PKDrawing init(data:), PKDrawing dataRepresentation(), PencilHoverPose, PencilPreferredAction, onPencilDoubleTap(perform:) and onPencilSqueeze(perform:).

watchOS apps — the watchOS app model, built on WatchKit: Setting up a watchOS project, Creating independent watchOS apps, Designing your app for the Always On state, WKApplicationDelegate, WKExtensionDelegate, WKWatchConnectivityRefreshBackgroundTask, scheduleBackgroundRefresh(withPreferredDate:userInfo:scheduledCompletion:), WKApplicationDelegateAdaptor, WKNotificationScene and WKUserNotificationHostingController.

Watch Connectivity — data transfer between iPhone and Apple Watch: Transferring data with Watch Connectivity, WCSession, WCSessionDelegate, sendMessage(_:replyHandler:errorHandler:), session(_:didReceiveMessage:replyHandler:), transferUserInfo(_:), updateApplicationContext(_:), transferFile(_:metadata:), WCSessionFile, WCSession.hasContentPending and transferCurrentComplicationUserInfo(_:).

visionOS — the platform root: Creating your first visionOS app, Presenting windows and spaces, Positioning and sizing windows and Making your existing app compatible with visionOS.

Accessibility — the framework root, with Enhancing the accessibility of your SwiftUI app, Performing accessibility testing for your app, Optimizing your app for Assistive Access and Accessibility Inspector.

Localization — Localization, Localizing and varying text with a string catalog, Using generated localizable symbols in your code, Localizing your app using agents, LocalizedStringResource, Exporting localizations, Importing localizations, Editing XLIFF and string catalog files, Localizing package resources, Preparing dates and numbers with formatters, Testing localizations when running your app, Previewing localizations and Creating screenshots of your app for localizers.

Foundation files and preferences — UserDefaults, register(defaults:), init(suiteName:), FileManager, containerURL(forSecurityApplicationGroupIdentifier:), documentsDirectory, applicationSupportDirectory, isExcludedFromBackup, Optimizing Your App’s Data for iCloud Backup, NSFileCoordinator, NSFilePresenter, PropertyListEncoder, Encoding and Decoding Custom Types, bookmarkData(options:includingResourceValuesForKeys:relativeTo:), init(resolvingBookmarkData:options:relativeTo:bookmarkDataIsStale:) and startAccessingSecurityScopedResource().

SwiftUI storage and documents — AppStorage, SceneStorage, defaultAppStorage(_:), Building a document-based app with SwiftUI, Updating your document-based app, DocumentGroup, FileDocument, ReadableDocument, WritableDocument, fileImporter(isPresented:allowedContentTypes:onCompletion:), fileExporter(isPresented:item:contentTypes:defaultFilename:onCompletion:onCancellation:) and AppStorage init(wrappedValue:_:store:).

Uniform Type Identifiers and Transferable — Defining file and data types for your app, init(exportedAs:conformingTo:), Transferable and CodableRepresentation.

URL Loading System — the Foundation networking stack: URLSession, data(for:delegate:), data(from:delegate:), bytes(from:delegate:), upload(for:from:delegate:), download(from:delegate:), download(for:delegate:), URLError, waitsForConnectivity, Downloading files in the background, background(withIdentifier:) and URLSessionDownloadDelegate.

Network — path monitoring and direct connections below URLSession: NWPathMonitor, NWPath, isExpensive, isConstrained, NetworkConnection, NetworkListener, Coder and NWConnection.

SwiftUI system integration — BackgroundTask, processingTask(_:), urlSession(_:), backgroundTask(_:action:), refreshable(action:), ScenePhase, OpenURLAction, userActivity(_:isActive:_:), onContinueUserActivity(_:perform:), ShareLink, environment(_:), environment(_:_:), isDynamicIslandLimitedInWidth and healthDataAccessRequest(store:shareTypes:readTypes:trigger:completion:).

Background Tasks — scheduled background work: BGTaskScheduler, BGAppRefreshTaskRequest, BGProcessingTaskRequest, BGContinuedProcessingTask, Choosing Background Strategies for Your App, Performing long-running tasks on iOS and iPadOS and Starting and Terminating Tasks During Development.

Other background execution APIs — NSBackgroundActivityScheduler, PKPushRegistry and WKExtendedRuntimeSession.

User Notifications — local and remote notifications: Asking permission to use notifications, Handling notifications and notification-related actions, UNUserNotificationCenterDelegate, UNNotificationCategory, UNCalendarNotificationTrigger, UNLocationNotificationTrigger, Registering your app with APNs, Establishing a token-based connection to APNs, Generating a remote notification, Sending notification requests to APNs, Sending broadcast push notification requests to APNs, Modifying content in newly delivered notifications, Customizing the appearance of notifications and UNNotificationContentExtension.

ActivityKit — Live Activities and the Dynamic Island: Displaying live data with Live Activities, Activity, request(attributes:content:pushType:style:alertConfiguration:start:), PushType, pushToStartTokenUpdates, Starting and updating Live Activities with ActivityKit push notifications, ActivityConfiguration, ActivityFamily and LiveActivityIntent.

WidgetKit — widgets, controls and complications: Developing a WidgetKit strategy, Creating a widget extension, Building widgets using WidgetKit and SwiftUI, TimelineEntry, AppIntentTimelineProvider, AppIntentConfiguration, Making a configurable widget, Keeping a widget up to date, WidgetCenter, Updating widgets with WidgetKit push notifications, WidgetPushHandler, Adding interactivity to widgets and Live Activities, Linking to specific app scenes from your widget or Live Activity, Creating controls to perform actions across the system, ControlWidgetToggle, Creating accessory widgets and watch complications, Adding StandBy and CarPlay support to your widget, Optimizing your widget for accented rendering mode and Liquid Glass, Updating your widgets for visionOS, RelevanceConfiguration, Widget suggestions in Smart Stacks, Previewing widgets and Live Activities in Xcode, Debugging widgets, TimelineProvider, TimelineEntryRelevance, WidgetFamily.accessoryCircular, WidgetFamily.accessoryCorner, ControlWidget, Migrating ClockKit complications to WidgetKit and CLKComplicationWidgetMigrator.

App Intents — exposing app actions and content to the system: Getting started with the App Intents framework, AppIntent, continueInForeground(_:alwaysConfirm:), OpenIntent, UndoableIntent, LongRunningIntent, AppEntity, AppEnum, EntityQuery, IndexedEntityQuery, SyncableEntity, the SiriKit system-domain intents INSendMessageIntent and INStartCallIntent, and Implementing communication notifications, UnionValue(), AppDependencyManager, App Shortcuts, AppShortcutsProvider, Making app entities available in Spotlight, App schema domains, Testing your App Intents code, App Intents Testing and IntentDefinitions.

App extensions and visual intelligence — App and system extensions, NSExtensionContext, NSExtension and Integrating your app with visual intelligence.

Foundation Models — the on-device language model behind Apple Intelligence: Generating content and performing tasks with Foundation Models, SystemLanguageModel, availability, LanguageModel, LanguageModelSession, respond(generating:includeSchemaInPrompt:options:prompt:), LanguageModelSession.ResponseStream, LanguageModelSession.DynamicProfile, Generating Swift data structures with guided generation, Expanding generation with tool calling, GenerationOptions.ToolCallingMode, SpotlightSearchTool, Analyzing images with multimodal prompting, Managing the context window, Improving the safety of generative model output, Updating prompts for new model versions, Analyzing the runtime performance of your Foundation Models app, Adding server-side intelligence with Private Cloud Compute, Running a Core AI model in a Foundation Models session and PrivateCloudComputeLanguageModel.

Evaluations — measuring model output quality: Evaluating language model responses.

Core AI — running custom on-device models: Integrating on-device AI models in your app with Core AI.

Core ML and Create ML — Core ML, Create ML and MLTextClassifier.

Vision — image and document analysis: RecognizeTextRequest, RecognizeDocumentsRequest, OCRTool, DataScannerViewController and ClassifyImageRequest.

Natural Language — tokenizing and tagging text: NLTokenizer and NLTagger.

Other Apple Intelligence frameworks — Translation, Image Playground, SpeechAnalyzer and writingToolsBehavior(_:).

Core Location — location updates, monitoring and authorization: Requesting authorization to use location services, Adopting live updates in Core Location, CLLocationUpdate, liveUpdates(_:), CLServiceSession, CLServiceSession (Objective-C), Handling location updates in the background, CLBackgroundActivitySession, Monitoring location changes with Core Location, CLMonitor and CLMonitor.CircularGeographicCondition.

MapKit — MapKit for SwiftUI, Map, MapCameraPosition, Marker, Annotation, MKMapItem, MKGeocodingRequest, MKReverseGeocodingRequest, LookAroundPreview and MKLookAroundSceneRequest.

AVFoundation capture — Capture setup, Requesting authorization to capture and save media, AVCaptureSession, AVCaptureDevice.RotationCoordinator, AVCapturePhotoOutput, AVCapturePhotoCaptureDelegate, AVCaptureVideoPreviewLayer, AVCaptureSystemZoomSlider, Building a responsive camera app that launches quickly, Enhancing your app experience with the Camera Control and Accessing the camera while multitasking on iPad.

Media playback and audio — AVPlayer, AVPlayerViewController, VideoPlayer, AVAudioSession, setCategory(_:mode:options:), MPNowPlayingInfoCenter, Now Playing and Publishing media sessions.

PhotoKit — the photo library and the system photo picker: Bringing Photos picker to your SwiftUI app, Implementing an inline Photos picker, PhotosPicker, PhotosPickerItem, PHPhotoLibrary, PHAccessLevel, PHAssetCreationRequest, PHImageManager, PHCachingImageManager and CGImageSourceCreateThumbnailAtIndex(_:_:_:).

SwiftData — the persistence layer behind FieldNotes 2: Preserving your app’s model data across launches, Adding and editing persistent data in your app, Model(), Attribute(_:originalName:hashModifier:), codable, Relationship(_:deleteRule:minimumModelCount:maximumModelCount:originalName:inverse:hashModifier:), Defining data relationships with enumerations and model classes, Unique(_:), Index(_:), Adopting inheritance in SwiftData, ModelContainer, ModelConfiguration, modelContainer(_:), modelContainer(for:inMemory:isAutosaveEnabled:isUndoEnabled:onSetup:), Reverting data changes using the undo manager, FetchDescriptor, Query, Filtering and sorting persistent data, Additional query macros, SectionedResults, VersionedSchema, SchemaMigrationPlan, MigrationStage, ModelActor, ModelActor(), PersistentIdentifier, Fetching and filtering time-based model changes, HistoryDescriptor, ResultsObserver, HistoryObserver, Syncing model data across a person’s devices and DataStore.

Core Data — the 1.x store and CloudKit mirroring: Setting up a Core Data stack, NSPersistentContainer, NSManagedObjectContext, FetchRequest, Mirroring a Core Data store with CloudKit, NSPersistentCloudKitContainer, Creating a Core Data model for CloudKit, Reading CloudKit records for Core Data, Sharing Core Data objects between iCloud users, Accepting share invitations in a SwiftUI app, Consuming relevant store changes and Adopting SwiftData for a Core Data app.

CloudKit — iCloud databases, sharing and sync: Deciding whether CloudKit is right for your app, Designing and creating a CloudKit database, CKContainer, CKDatabase, CKRecord, CKShare, CKShareTransferRepresentation, CKQuerySubscription, CKSyncEngine, Managing iCloud containers with the CloudKit Database app, Deploying an iCloud container’s schema and Integrating a text-based schema into your workflow.

iCloud key-value storage, documents and entitlements — NSUbiquitousKeyValueStore, url(forUbiquityContainerIdentifier:), Configuring iCloud services, iCloud Services entitlement, iCloud Key-Value Store entitlement and CKSharingSupported.

HealthKit — health data and workouts: Authorizing access to health data, requestAuthorization(toShare:read:), HKStatisticsQueryDescriptor, Building a workout app for iPhone and iPad, HKWorkoutSession, HKLiveWorkoutBuilder, HKWorkout, HKWorkoutZoneConfiguration, HKWorkoutZoneGroup, Running workout sessions, Building a multidevice workout app, startMirroringToCompanionDevice(completion:) and workoutSessionMirroringStartHandler.

WorkoutKit — planned and scheduled workouts on Apple Watch: WorkoutScheduler.

Core Motion — device and headphone motion: CMMotionManager, CMPedometer and CMHeadphoneMotionManager.

Core Bluetooth — Bluetooth Low Energy accessories: CBCentralManager and CBPeripheral.

AccessorySetupKit — privacy-preserving accessory pairing: Discovering and configuring accessories and ASAccessorySession.

Core NFC — reading NFC tags: Building an NFC Tag-Reader App, NFCNDEFReaderSession and NFCNDEFPayload.

HomeKit — home automation accessories.

Security framework and App Transport Security — Keychain Services, SecItemAdd(_:_:), SecItemCopyMatching(_:_:), SecItemUpdate(_:_:), SecItemDelete(_:), kSecAttrAccessibleAfterFirstUnlock, Restricting keychain item accessibility, SecAccessControlCreateWithFlags(_:_:_:_:), kSecUseAuthenticationContext, kSecUseDataProtectionKeychain, kSecAttrAccessGroup, Sharing access to keychain items among a collection of apps, Preventing Insecure Network Connections, Identifying the Source of Blocked Connections and Accessing files from the macOS App Sandbox.

LocalAuthentication — LAContext, LAPolicy.deviceOwnerAuthentication, LABiometryType, interactionNotAllowed and Accessing Keychain Items with Face ID or Touch ID.

Authentication Services — Sign in with Apple and passkeys: Implementing User Authentication with Sign in with Apple, SignInWithAppleButton, getCredentialState(forUserID:completion:), Supporting passkeys, ASAuthorizationPlatformPublicKeyCredentialProvider, ASAuthorizationAccountCreationProvider, AuthorizationController and ASCredentialUpdater.

Apple CryptoKit — hashing, encryption and Secure Enclave keys: SHA256, HPKE, SecureEnclave, SecureEnclave.P256.Signing.PrivateKey, SecureEnclave.MLDSA65, XWingMLKEM768X25519, Storing CryptoKit Keys in the Keychain, Enhancing your app’s privacy and security with quantum-secure workflows and P256.Signing.PrivateKey.

DeviceCheck — DCDevice, DCAppAttestService, Establishing your app’s integrity and Validating apps that connect to your server.

App Tracking Transparency — the tracking-permission prompt: requestTrackingAuthorization(completionHandler:).

Trust Insights — on-device fraud and risk signals: InsightEvaluator.

Information property list, entitlements and privacy manifests — Protected resources, NSLocationWhenInUseUsageDescription, NSLocationTemporaryUsageDescriptionDictionary, NSLocalNetworkUsageDescription, NSPinnedDomains, UIBackgroundModes, Privacy manifest files, Describing use of required reason API, App Sandbox Entitlement, Keychain Access Groups Entitlement, Associated Domains Entitlement, Near Field Communication Tag Reader Session Formats Entitlement, com.apple.developer.private-cloud-compute, Information Property List, Entitlements, CFBundleIdentifier, CFBundleVersion, MinimumOSVersion, ITSAppUsesNonExemptEncryption, NSCameraUsageDescription, NSObservationTrackingEnabled, UIApplicationSupportsMultipleScenes, UILaunchScreen, UIRequiresFullScreen, WKBackgroundModes, Bundle.bundleIdentifier and object(forInfoDictionaryKey:).

StoreKit — In-App Purchase and subscriptions: In-App Purchase, Implementing a store in your app using the StoreKit API, products(for:), purchase(options:), Product.PurchaseResult, PurchaseAction, VerificationResult, Transaction, updates, currentEntitlements, finish(), revocationDate, isUpgraded, sync(), Product.SubscriptionInfo.Status, Product.SubscriptionInfo.RenewalState, Product.SubscriptionInfo.PricingTerms, Supporting monthly subscriptions with a 12-month commitment, Managing the life cycle of monthly subscriptions with a 12-month commitment, Transaction.CommitmentInfo, Supporting offer codes in your app, RedeemOption, External Purchase, Testing Apple In-App Purchases in Xcode, Testing at all stages of development with Xcode and the sandbox, SKTestSession, AppTransaction.environment, RequestReviewAction and Testing Apple In-App Purchases with sandbox.

StoreKit views and SwiftUI modifiers — StoreView, ProductView, SubscriptionStoreView, storeButton(_:for:), subscriptionStoreControlStyle(_:), preferredSubscriptionPricingTerms(_:), onInAppPurchaseCompletion(perform:), subscriptionStatusTask(for:priority:action:), manageSubscriptionsSheet(isPresented:subscriptionGroupID:), offerCodeRedemption(options:isPresented:onCompletion:) and requestReview.

ARKit — world tracking and scene understanding: ARWorldTrackingConfiguration, planeDetection, ARAnchor, ARPlaneAnchor, Tracking and visualizing planes, ARKitSession, WorldTrackingProvider, PlaneDetectionProvider, SceneReconstructionProvider, HandTrackingProvider, WorldAnchor and Setting up access to ARKit data.

RealityKit — rendering and simulating 3D content: RealityView, RealityViewContent, RealityViewCameraContent, spatialTracking, SpatialTrackingSession, AnchorEntity, ModelEntity, init(named:in:), Component, registerComponent(), System, registerSystem(), EntityQuery, entities(matching:updatingSystemWhen:), InputTargetComponent, BillboardComponent, TextComponent, LevelOfDetailComponent, Reality Composer Pro, Adding 3D content to your app, Model3D, init(make:update:attachments:), ViewAttachmentComponent and HoverEffectComponent.

SwiftUI for spatial content — ImmersiveSpace, realityViewCameraControls(_:), targetedToAnyEntity(), Immersive spaces, OpenImmersiveSpaceAction, DismissImmersiveSpaceAction, ImmersionStyle, progressive(_:initialAmount:), immersionStyle(selection:in:), WindowGroup, volumetric, defaultSize(width:height:depth:in:), frame(depth:alignment:), glassBackgroundEffect(displayMode:) and ornament(visibility:attachmentAnchor:contentAlignment:ornament:). === Human Interface Guidelines

Human Interface Guidelines — Apple’s design guidance for every platform, summarized and linked (never copied) by Human Interface Guidelines in Practice: Getting started, Design principles, Foundations, Color, Typography, Dark Mode, Layout, Materials, Motion, Writing, App icons, SF Symbols, Components, Patterns, Inputs, Gestures, Technologies, Accessibility, Right to left, Privacy, Sign in with Apple, Generative AI, Maps, In-app purchase, Immersive experiences, Keyboards, The menu bar, Apple Pencil and Scribble, Settings, Undo and redo, Ornaments and Eyes.

Apple Design Resources — the design templates and assets designers use alongside the HIG.

Designing for iOS — the iPhone’s layout, input and system-integration expectations.

Designing for iPadOS — larger canvases, multiple windows, pointer and Apple Pencil.

Designing for macOS — windows, menus, keyboard-first interaction and the menu bar.

Designing for watchOS — glanceable, brief interactions on the wrist.

Designing for visionOS — windows, volumes and immersive spaces in the wearer’s surroundings.

Designing for iPhone Duo — adapting layouts to the foldable iPhone and its hinge.

Develop in Swift — Apple’s beginner track through Swift, SwiftUI and Xcode.

SwiftUI Tutorials — the step-by-step Landmarks app, including Creating and combining views, Building lists and navigation, Animating views and transitions, Interfacing with UIKit, Working with UI controls, Creating a macOS app and Creating a watchOS app.

App Dev Training — the longer, project-based SwiftUI and UIKit curriculum.

SwiftUI Concepts — concept-focused lessons, including Specifying the view hierarchy of an app using a scene.

Landmarks: Building an app with Liquid Glass — sample code for adopting the 26-and-later design.

Food Truck: Building a SwiftUI multiplatform app — sample code for one codebase across iOS, iPadOS and macOS.

Backyard Birds sample — sample code for a data-driven SwiftUI app with SwiftData and widgets.

Xcode 27 Release Notes — the source for this section’s Xcode 27 and SDK-level changes.

SwiftUI updates — the year-by-year list of SwiftUI changes.

UIKit updates — the year-by-year list of UIKit changes.

Xcode updates — the year-by-year list of Xcode changes.

AVCam: Building a camera app — sample code for a complete capture app.

Emoji Rangers: Supporting Live Activities, interactivity, and animations — sample code for widgets and Live Activities.

SwiftData updates — the year-by-year list of SwiftData changes.

Foundation Models updates — the year-by-year list of Foundation Models changes.

TN3151: Choosing the right networking API — which networking API fits which job.

TN3135: Low-level networking on watchOS — the limits on low-level networking on the watch.

Profiling apps using Instruments — the hands-on Instruments tutorial.

Hello World — sample code for windows, volumes and an immersive space on visionOS.

iOS & iPadOS 27 Release Notes — the iPadOS 27 windowing, menu and API changes.

macOS 27 Golden Gate Release Notes — the macOS 27 AppKit, SwiftUI and security changes.

watchOS 27 Release Notes — the watchOS 27 changes.

visionOS 27 Release Notes — the visionOS 27 changes.

TN3125: Inside Code Signing: Provisioning Profiles — what a provisioning profile contains and authorizes.

TN3161: Inside Code Signing: Certificates — the certificate types behind code signing. === WWDC sessions

App Review Guidelines — the rules every submission, purchase flow and privacy prompt is reviewed against.

App Store Connect Help — app records, builds, TestFlight and App Review: Add a new app, Upload builds, TestFlight overview, Invite external testers, View tester feedback, Manage app privacy, Set an app age rating, Age ratings values and definitions, Overview of submitting for review and Release a version update in phases.

App Store Connect API — automating App Store Connect and Xcode Cloud over REST: Creating API Keys for App Store Connect API, Generating Tokens for API Requests, List apps, List builds, List all diagnostic signatures for a build, Add builds to a beta group, Submit an app for beta review, Create a Review Submission, Create an app store version phased release, Xcode Cloud Workflows and Builds, CiWorkflow, CiAction, Start a build and Read Build Run Information.

Account Help — membership, certificates, identifiers, devices and signing: Enrollment, Apple Developer Program Roles, Certificates overview, Cloud-managed certificates, Automatic Signing Controls, Register an App ID, Devices overview, Register multiple devices, Provisioning with managed capabilities, Supported capabilities (macOS) and Synchronizing code signing identities with your developer account.

Membership and App Store Connect — Apple Developer Program, Overview of Accessibility Nutrition Labels, What’s included, Apple Developer Enterprise Program and Operating an alternative app marketplace in the EU.

App Store privacy requirements — User Privacy and Data Use, Upcoming third-party SDK requirements and App Privacy Details.

Upcoming Requirements — the dated list of SDK and submission requirements, with the Apple Developer News posts the pages cite: Upcoming SDK minimum requirements, App Store submissions now open for the latest OS releases, Updated Apple Developer Program License Agreement and App Review Guidelines now available, Age rating questionnaire now includes social media questions, Changes for apps in the European Union, 25 hours of Xcode Cloud now included with the Apple Developer Program and Updates to runtime protection in macOS Sequoia.

Xcode Cloud — the CI/CD service built into Xcode and App Store Connect: Getting started with Xcode Cloud, Xcode Cloud workflow reference, Configuring start conditions, Configuring your Xcode Cloud workflow’s actions, Writing custom build scripts, Environment variable reference, Sharing environment variables across Xcode Cloud workflows, Making dependencies available to Xcode Cloud, Setting the next build number for Xcode Cloud builds, Distributing your Xcode Cloud builds through TestFlight, Configuring requirements for merging a pull request, Configuring webhooks in Xcode Cloud, Xcode Cloud webhook payload reference, Reviewing Xcode Cloud usage data, Building Swift packages or apps that use them in continuous integration workflows and Xcode Cloud overview.

Developer ID — signing and notarizing Mac apps distributed outside the Mac App Store: Developer ID certificates, Creating distribution-signed code for macOS, Packaging Mac software for distribution, Hardened Runtime, Configuring the hardened runtime, Notarizing macOS software before distribution, Customizing the notarization workflow, Resolving common notarization issues and Notary API.

MarketplaceKit — alternative app marketplaces in the European Union: AppDistributor and Submit for Notarization.

Swift.org — Swift 6.4 Released — the release post for the language version this section targets.

Swift.org — API Design Guidelines — the naming and documentation conventions applied in App Architecture the Apple Way.

Swift.org — Mixing Swift and C++ — the C++ interoperability reference behind Mixing Swift, Objective-C and C++ in an App, including Project build setup.

Swift.org — Migrating to Swift 6 — the guide behind this section’s Swift 6 strict-concurrency adoption notes.

Swift.org — gRPC Swift 2 — the gRPC implementation the networking page uses for streaming RPCs.

Swift.org — REPL and Debugger — LLDB and the Swift REPL, behind Debugging with Xcode and LLDB.

apple/swift-collections and apple/swift-async-algorithms — the open-source Swift packages cited by Swift Packages and Modularizing an App.

Swift Evolution proposals — SE-0506: Advanced Observation tracking and SE-0475: Observed, behind State and Data Flow with Observation.

This site’s Swift Reference and Objective-C Reference — the language material this section links to instead of repeating.

GitHub — actions/runner-images README — the Xcode versions preinstalled on GitHub-hosted macOS runners, cited by CI/CD with Xcode Cloud and the Command Line.

Bello, Antonio, Bill Morefield, Audrey Tam & Sarah Reichelt. SwiftUI by Tutorials, 4th edition. Kodeco (raywenderlich.com), November 2021 — see the publisher’s book page, with the official code bundle at kodecocodes/sui-materials. The narrative source for the SwiftUI views, layout, navigation, controls, drawing and animation, accessibility and macOS/multiplatform material, targeting Xcode 13.1 and Swift 5.5; it teaches ObservableObject/@StateObject and the deprecated NavigationView, both predating the @Observable macro and NavigationStack, and uses XCTest rather than Swift Testing.

Cacheaux, René & Josh Berlin. Advanced iOS App Architecture. Kodeco (raywenderlich.com), 2019 — see the publisher’s book page, with the official code bundle at kodecocodes/arch-materials. The narrative source for the MVVM and Redux-style architecture material in App Architecture the Apple Way, targeting Xcode 10.2 and Swift 5; its manual view-controller wiring and hand-rolled Redux state management are UIKit-era and predate the @Observable macro, which now provides much of the same state plumbing for free.

Cacheaux, René & Josh Berlin. Advanced iOS App Architecture, 2022 edition. Kodeco (raywenderlich.com), 2022 — see the publisher’s book page, with the official code bundle at kodecocodes/arch-materials. The updated edition of the above, additionally consulted for UIKit and AppKit Essentials and State and Data Flow with Observation, targeting Xcode 13.2.1 and Swift 5.5.2; its proprietary "Elements" layering pattern is a book-specific construct, not a documented Apple or industry-standard architecture, and is not reproduced here.

Catalan, Juan C. SwiftUI Cookbook, 3rd edition. Packt Publishing, December 2023. ISBN 978-1-80512-173-2 — see the publisher’s book page, with the official code bundle at PacktPublishing/SwiftUI-Cookbook-3rd-Edition. The narrative source for recipes across SwiftUI layout, lists, navigation, controls, drawing, persistence, security, widgets and multiplatform material, targeting Xcode 15 and Swift 5.9; it is the only book in this library that covers the @Observable macro, though it still leads with ObservableObject first.

Clayton, Craig & Donny Wals. Complete iOS 12 Development Guide. Packt Publishing, March 2019. ISBN 978-1-83864-379-9 — see the publisher’s book page, with the official code bundle at PacktPublishing/Complete-iOS-12-Development-Guide. The narrative source touched by the largest number of pages in this section — app architecture, concurrency, UIKit, Core Data, networking, background execution, notifications, App Intents, Apple Intelligence, location, camera, health, AR and distribution — targeting Xcode 10, Swift 4.2 and iOS 12; its GCD-only concurrency, pre- BGTaskScheduler background fetch, SiriKit intents extension and Core ML/Vision-only machine learning chapters are all superseded by the current APIs this section documents.

Ferrer García, Raúl. iOS Architecture Patterns. Apress, 2023. ISBN 978-1-4842-9068-2 (print), 978-1-4842-9069-9 (ebook) — see the publisher’s book page, with the official code repository at Apress/iOS-Architecture-Patterns. Consulted in its entirety for the MVC/MVP/MVVM/VIPER/VIP architecture comparison in App Architecture the Apple Way; its description of The Composable Architecture is a 2023 snapshot of a fast-evolving third-party library and is likely dated.

Gardner, Scott, Shai Mishali, Florent Pillet & Marin Todorov. Combine: Asynchronous Programming with Swift. Kodeco (raywenderlich.com), 2019 (updated 2020) — see the publisher’s book page, with the official code bundle at kodecocodes/comb-materials. Consulted in its entirety for Swift Concurrency in Apps, targeting Xcode 11 and the iOS 13 SDK; it presents Combine as the async solution for SwiftUI apps, a framing this section’s == Where Combine Stands section replaces with async/await/AsyncSequence as the default and Combine as a still-supported, no-longer-primary tool.

Grosch, Scott. watchOS With SwiftUI by Tutorials. Kodeco (raywenderlich.com), 2021 — see the publisher’s book page, with the official code bundle at kodecocodes/wos-materials. Consulted in its entirety for watchOS: App Structure, Connectivity, Workouts and the Smart Stack, plus its background-execution, notifications, widgets, health and security chapters, targeting Xcode 13.1 and Swift 5.5; it predates the Double Tap gesture, the Smart Stack, the @Observable macro, passkeys and WidgetKit-based complications, still describing complications through the superseded ClockKit framework.

Moon, Keith, Chris Barker, Daniel Bolella & Nathan Lawlor. Swift Cookbook, 3rd edition. Packt Publishing, May 2024. ISBN 978-1-80323-958-3 — see the publisher’s book page, with the official code bundle at PacktPublishing/Swift-Cookbook-Third-Edition. The narrative source for recipes touching concurrency, networking, UIKit interop, testing, ObservableObject-based observation, Apple Intelligence, AR and visionOS, targeting Swift 5.9; it predates Swift 6 strict-concurrency checking, uses XCTest rather than Swift Testing, and its visionOS chapter predates matured native volumetric APIs.

Neuburg, Matt. iOS 15 Programming Fundamentals with Swift, 8th edition. O’Reilly Media, October 2021. ISBN 978-1-098-11850-1 (print), 978-1-098-11849-5 (ebook) — see the publisher’s book page, with the official code repository at mattneub/Programming-iOS-Book-Examples. The narrative source for App Structure and Life Cycle and parts of Mixing Swift, Objective-C and C++ in an App and UIKit and AppKit Essentials, targeting Xcode 13 and Swift 5.5; its life-cycle chapter is UIApplicationDelegate-only and predates the scene-based life cycle, and its nib-file material predates SwiftUI-first guidance.

Pillet, Florent, Junior Bontognali, Marin Todorov & Scott Gardner. RxSwift: Reactive Programming with Swift, 1st edition. Kodeco (raywenderlich.com), 2017 — see the publisher’s book page, with the official code bundle at kodecocodes/rxs-materials. Consulted for the app-architecture, UIKit-table-view, networking, location and gesture material it parallels, targeting Xcode 8 and Swift 3.x; RxSwift/RxCocoa is a third-party reactive library whose adoption has declined sharply since Combine and async/await became available, so this section documents Apple’s own tools instead.

Sahar, Ahmad. iOS 17 Programming for Beginners, 8th edition. Packt Publishing, October 2023. ISBN 978-1-83763-056-1 (print), 978-1-83763-989-2 (ebook) — see the publisher’s book page, with the official code bundle at PacktPublishing/iOS-17-Programming-for-Beginners-Eighth-Edition. The narrative source for a broad span of beginner-level material — getting started, Xcode projects, SwiftUI views, lists, UIKit interop, SwiftData, preferences, networking, location, camera, visionOS, signing and App Store Connect — targeting Xcode 15, Swift 5.9 and iOS 17; its distribution chapter centres on the manual archive-and-upload flow to App Store Connect and introduces Xcode Cloud only briefly.

Scalzo, Giordano & Edgar Nzokwe. SwiftUI Cookbook, 2nd edition. Packt Publishing, October 2021. ISBN 978-1-80323-445-8 — see the publisher’s book page, with the official code bundle at PacktPublishing/SwiftUI-Cookbook-2nd-Edition. The narrative source for recipes across Xcode projects, concurrency, multiplatform apps, SwiftUI layout and navigation, Core Data, widgets, macOS and security, targeting Xcode 13 and iOS 15; its widget recipes predate widget interactivity and Live Activities, and its NavigationView-based navigation predates NavigationStack.

Selander, Derek. Advanced Apple Debugging & Reverse Engineering. Kodeco (raywenderlich.com), November 2017 — see the publisher’s book page, with the official code bundle at kodecocodes/dbg-materials. Consulted in its entirety for Debugging with Xcode and LLDB and, for its malloc/leak-logging chapter, Performance and Instruments, targeting Xcode 9.1 and 2017-era LLDB; its Python-scripting-API chapters need adaptation for the Python 3 LLDB shipped with Xcode 27, and its DTrace chapters describe a technique largely blocked today by System Integrity Protection, for which Instruments is Apple’s modern replacement.

Tsadok, Avi. The Ultimate iOS Interview Playbook, 1st edition. Packt Publishing, August 2023. ISBN 978-1-80324-631-4 (print), 978-1-80324-720-5 (ebook) — see the publisher’s book page. Consulted narrowly for its Apple-specific chapters — Swift packages and modularization, app architecture, UIKit interop, Core Data and preferences, and SwiftUI state and data flow — with no fixed target Xcode/Swift/iOS version; its interview and career-process chapters, and its generic (non-Apple) design-pattern review, are out of scope for this section.