What’s new at WWDC 2026

major

Evaluations framework for AI feature quality measurement

A new Swift framework (available in Xcode 27, supported on iOS, macOS, watchOS, visionOS) provides structured evaluation pipelines with Evaluation protocol, Metric, Evaluator, ModelJudgeEvaluator, ScoreDimension, TrajectoryExpectation, ToolCallEvaluator, SampleGenerator (with synthetic data generation), and MetricsAggregator.custom() — formalizing a hill-climbing develop/run/analyze loop for AI feature development.

SessionsKeynotePlatforms State of the UnionWhat's new in the Foundation Models frameworkBuild agentic app experiences with the Foundation Models frameworkDebug and profile agentic app experiences with InstrumentsMeet the Evaluations frameworkCreate robust evaluations for agentic appsImprove your prompts by hill-climbing with EvaluationsInside Apple Intelligence and Xcode: Special Presentation

major

Core AI framework for custom on-device model deployment

Core AI is a new memory-safe Swift framework for deploying any custom model — from compact vision models to multi-billion parameter LLMs — on Apple Silicon, featuring Python-based PyTorch conversion (coreai-torch), config-driven compression (coreai-opt), ahead-of-time compilation (xcrun coreai-build / AIModelCache), stateful KV-cache support, custom Metal 4 kernel embedding via TorchMetalKernel, a visual debugger, multi-function .aimodel assets, and zero server dependencies.

SessionsKeynotePlatforms State of the UnionMeet Core AIDive into Core AI model authoring and optimizationIntegrate on-device AI models into your app using Core AIOptimize custom machine learning operations with Metal tensorsInside Apple Intelligence and Xcode: Special Presentation

major

Foundation Models framework — multimodal, server model support, open source, and Linux

The Foundation Models framework gains multimodal image input (UIImage, NSImage, CGImage, Core Image, pixel buffers), a unified LanguageModelSession that works with on-device, Private Cloud Compute, MLX, Core AI, and third-party models via the new LanguageModel protocol, and is being open-sourced with a Swift server API that also runs on Linux. A Python SDK (apple_fm_sdk) and an open-source Swift utilities package with emerging agentic patterns are also shipping.

SessionsKeynotePlatforms State of the UnionWhat's new in the Foundation Models frameworkBuild AI-powered scripts with the fm CLI and Python SDKBring an LLM Provider to the Foundation Models frameworkInside Apple Intelligence and Xcode: Special Presentation

major

PrivateCloudComputeLanguageModel API with reasoning levels and 32K context

A new PrivateCloudComputeLanguageModel type gives developers no-account, no-API-key access to Apple's larger Private Cloud Compute model (32,000-token context window, including on watchOS 27), with configurable reasoning levels (.light and .deep via ContextOptions(reasoningLevel:)) and token usage reporting including reasoningTokenCount.

SessionsKeynoteWhat's new in the Foundation Models frameworkBuild agentic app experiences with the Foundation Models frameworkMeet the Evaluations frameworkBring an LLM Provider to the Foundation Models framework

major

Dynamic Profiles API for agentic model orchestration

A new DynamicProfile protocol provides a declarative, SwiftUI-style way to manage per-prompt model, instructions, tools, and context for a LanguageModelSession, enabling multi-mode agentic apps that swap models mid-session while preserving conversation history; baton-pass and phone-a-friend multi-model orchestration patterns are formally named and supported.

SessionsKeynotePlatforms State of the UnionWhat's new in the Foundation Models frameworkBuild agentic app experiences with the Foundation Models frameworkDebug and profile agentic app experiences with Instruments

major

MLX distributed training and inference across multiple Macs via RDMA over Thunderbolt

Starting in macOS 26.2, RDMA over Thunderbolt 5 enables high-bandwidth direct memory transfers between Macs; MLX and MLX LM leverage this (plus the open-source JACCL collective communication library) for tensor-parallel and pipeline-parallel LLM inference and data-parallel fine-tuning across multi-Mac clusters, achieving near-3x throughput on 4-Mac setups and enabling trillion-parameter models. mlx.launch and mlx.distributed_config CLI tools orchestrate the cluster.

SessionsKeynotePlatforms State of the UnionExplore distributed inference and training with MLXInside Apple Intelligence and Xcode: Special Presentation

major

Image Playground — photorealistic generation on Private Cloud Compute

Image Playground's generative model is rebuilt on Private Cloud Compute and now produces high-quality photorealistic images in virtually any style from photos or natural language descriptions, with data never stored or shared even with Apple.

SessionsKeynoteAnnouncing Apple's next big step for Siri and iPhoneCreate high-quality images using Image Playground

major

Private Cloud Compute access for App Store Small Business Program members

Developers in Apple's App Store Small Business Program with fewer than 2 million downloads can access next-generation Apple Foundation Models via Private Cloud Compute at no cloud API cost, lowering the barrier for AI-powered features in smaller apps.

SessionsKeynotePlatforms State of the Union

major

Visual Intelligence API for third-party apps

A new VisualIntelligence framework and IntentValueQuery protocol lets apps receive a SemanticContentDescriptor (pixel buffer from camera or screenshot) and return matched app entities directly inside the system Visual Intelligence overlay; the API is now available on macOS and iPadOS in addition to iPhone.

SessionsBest practices for integrating visual intelligence in your app

major

MLX Swift — numerical computing and ML framework for Swift

A new MLX Swift package brings NumPy-style N-dimensional array computing to Swift with automatic GPU execution, lazy evaluation, automatic differentiation via grad(), linear algebra, FFTs, convolutions, and optimizers (SGD, Adam, RMSprop), all via Swift Package Manager; companion packages mlx-swift-lm and mlx-swift-examples add LLM inference and Stable Diffusion.

SessionsExplore numerical computing in Swift with MLX

notable

Official Anthropic Claude and Google Gemini Swift packages for Foundation Models

Apple is shipping official Swift packages from Anthropic and Google that plug Claude and Gemini into the Foundation Models LanguageModelSession API via OAuth/Keychain auth, allowing model swapping with a single line of code and per-token usage reporting.

SessionsPlatforms State of the UnionWhat's new in the Foundation Models frameworkBring an LLM Provider to the Foundation Models framework

notable

SpotlightSearchTool for Foundation Models — fully local RAG

A new built-in SpotlightSearchTool lets LanguageModelSession autonomously query the device's Core Spotlight index for Retrieval-Augmented Generation without any server calls; GuidanceProfile scopes exposed search capabilities to stay within on-device context limits, and CustomStage enables multi-stage on-device pipelines.

SessionsWhat's new in the Foundation Models frameworkLLM search using Core SpotlightPlatforms State of the Union

notable

Built-in Vision tools for Foundation Models (BarcodeReaderTool and OCRTool)

New Vision-framework-backed system tools — BarcodeReaderTool and an OCRTool supporting 30+ languages — can be passed directly to LanguageModelSession, letting the on-device model scan barcodes, QR codes, and dense text as part of structured generation tasks.

SessionsKeynoteWhat's new in the Foundation Models frameworkWhat's new in image understanding

notable

Foundation Models Python SDK (apple_fm_sdk) and fm CLI tool

A new pip-installable Python SDK (pip install apple_fm_sdk) and a pre-installed fm CLI (fm chat, fm respond, fm schema) let Python developers and shell scripts access Foundation Models on Apple Silicon Macs, including multimodal queries (--image flag), structured JSON output (--schema), and Private Cloud Compute (--model pcc).

SessionsPlatforms State of the UnionWhat's new in the Foundation Models frameworkBuild AI-powered scripts with the fm CLI and Python SDK

notable

Core AI Models open-source repository (github.com/apple/ai-models)

Apple published an open-source repository of curated, Apple-Silicon-ready model weights (including Qwen, Mistral, SAM 3) with conversion and optimization recipes and Swift packages, lowering the barrier to on-device deployment of popular open-source models.

SessionsMeet Core AIDive into Core AI model authoring and optimizationIntegrate on-device AI models into your app using Core AI

notable

ModelJudgeEvaluator with Cohen's kappa calibration and few-shot examples

ModelJudgeEvaluator uses a language model (including PrivateCloudComputeLanguageModel) to score AI outputs on subjective ScoreDimensions; Cohen's kappa aggregation measures alignment between model judge and human expert ratings, and ModelJudgePrompt supports few-shot worked examples for judge calibration.

SessionsMeet the Evaluations frameworkCreate robust evaluations for agentic appsImprove your prompts by hill-climbing with Evaluations

notable

LanguageModelExecutor protocol for plugging any LLM into Foundation Models

A new LanguageModelExecutor protocol lets developers package any local or server-based LLM — including community models from Hugging Face MLX-Community — into Foundation Models' LanguageModelSession API; custom Transcript.CustomSegment types can pass structured non-text data (audio, web results) through the pipeline.

SessionsBring an LLM Provider to the Foundation Models frameworkWhat's new in the Foundation Models framework

notable

Neural Accelerator in M5 GPU shader cores

Apple M5 introduces a dedicated Neural Accelerator block in each GPU shader core, making matrix multiplication four times faster than M4; the Metal Tensor API and MLX automatically target this new hardware, accelerating both custom ML kernels and LLM prompt processing with no code changes.

SessionsRun local agentic AI on the Mac using MLXOptimize custom machine learning operations with Metal tensors

notable

Updated on-device SystemLanguageModel with improved instruction following, tool calling, and image input

The on-device SystemLanguageModel is rebuilt with better logic, enhanced tool calling, refined guardrails with fewer false positives (iOS 26.4+), native multimodal image input (UIImage, NSImage, CGImage, etc.), and new introspection APIs (model.contextSize, model.tokenCount(for:)).

SessionsWhat's new in the Foundation Models frameworkBring an LLM Provider to the Foundation Models framework

notable

Reality Composer Pro AI Assistant for 3D content generation

A new AI Assistant panel in Reality Composer Pro 3 generates 3D objects and materials from natural language prompts and integrates Coding Intelligence for generating Swift event-subscription boilerplate (scene.subscribe calls and SwiftUI Attachments) to complement ScriptGraph scenes.

SessionsIterate your spatial scenes faster with Reality Composer Pro 3Design no-code games with Reality Composer Pro 3

notable

DynamicInstructions and Session Properties for composable agentic context

DynamicInstructions groups tools and instructions into nestable, composable units conditionally included based on app state; the @SessionPropertyEntry macro lets Tools and Profiles share typed state across an agentic graph without external state management.

SessionsBuild agentic app experiences with the Foundation Models frameworkDebug and profile agentic app experiences with Instruments

notable

Open-source Foundation Models utilities Swift package with agentic patterns

A companion open-source Swift package ships community utilities such as rollingWindow(), droppingCompletedToolCalls(), and a Skills API for modular on-demand knowledge injection, updated between OS releases to distribute experimental patterns faster than OS-linked APIs.

SessionsWhat's new in the Foundation Models frameworkBuild agentic app experiences with the Foundation Models framework

notable

MLX-LM Server — OpenAI-compatible HTTP server with continuous batching and distributed inference

MLX-LM Server is an OpenAI-compatible HTTP server exposing local models through a standard API, now supporting structured tool calling, reasoning models, and continuous batching for concurrent multi-agent requests; it also supports distributed inference via mlx.launch to shard large models across multiple Macs.

SessionsRun local agentic AI on the Mac using MLX

notable

CoreAIImageSegmenter API wrapping SAM 3 for on-device image segmentation

A new Swift API wrapping the Segment Anything Model 3 (SAM 3) performs text-prompted image segmentation entirely on-device with a simple segment(image:prompt:) call, available via the Core AI framework.

SessionsIntegrate on-device AI models into your app using Core AI

notable

Next-generation photo editing with Apple Intelligence in iOS 27

Apple Intelligence in iOS 27 adds new capabilities to extend, reframe, and clean up photos, going beyond prior generation editing tools.

SessionsAnnouncing Apple's next big step for Siri and iPhone

notable

Use Model action in Shortcuts with web retrieval

The Use Model action in Shortcuts is updated with access to newer Apple Intelligence models that can also retrieve up-to-date information from the web, enabling richer intelligent automation.

SessionsWhat's new in Shortcuts

notable

LanguageModelCapabilities API and LanguageModelError standardized error taxonomy

Models declare supported capabilities (toolCalling, guidedGeneration, reasoning) via LanguageModelCapabilities so the framework can route requests appropriately; a new LanguageModelError enum defines standard error cases (contextSizeExceeded, rateLimited, refusal, guardrailViolation, timeout, etc.) for consistent error handling across all executor implementations.

SessionsBring an LLM Provider to the Foundation Models framework

notable

historyTransform modifier and TranscriptErrorHandlingPolicy for context engineering

The historyTransform modifier applies stateless per-request transformations to session history before model submission (filtering, trimming) without permanently mutating the transcript; TranscriptErrorHandlingPolicy.preserveTranscript enables mid-response cancellation and resumption.

SessionsBuild agentic app experiences with the Foundation Models framework

notable

toolCallingMode API and lifecycle modifiers (onResponse, onToolCall)

A new toolCallingMode modifier (.allowed / .disallowed / .required) gives explicit control over tool calling per prompt, critical for agentic loops; onResponse and onToolCall lifecycle modifiers let developers run imperative code at response boundaries to update UI state or mutate session history.

SessionsBuild agentic app experiences with the Foundation Models framework

notable

Visual Intelligence system-level actions (Contacts, Calendar, HealthKit)

Visual Intelligence now supports system-level actions including adding to Contacts, saving calendar events via EventKit, and logging medical device readings via HealthKit, with guidance on observing store-change notifications (e.g., EKEventStoreChanged).

SessionsBest practices for integrating visual intelligence in your app

notable

ImageReference and image-based tool calling in Foundation Models

A new ImageReference type and @SessionProperty(..history) allow Tool-protocol-conforming types to receive and resolve image arguments from the session transcript, enabling LLM-orchestrated workflows where the model invokes app-defined image processing functions.

SessionsWhat's new in image understanding

notable

Spotlighting API for prompt injection mitigation

A new probabilistic mitigation technique exposed via .historyTransform wraps untrusted tool output segments with special delimiter tags (e.g., <<UNTRUSTED>>) so the on-device model can recognize and handle external data with appropriate suspicion, reducing prompt injection risk in agentic apps.

SessionsSecure your app: mitigate risks to agentic features

notable

JACCL open-source collective communication library for Apple Silicon

Apple released JACCL, an open-source collective communication library built on RDMA over Thunderbolt that provides all-reduce, all-sum, and other primitives for distributed workloads via a C++ API, usable independently of MLX.

SessionsExplore distributed inference and training with MLX

notable

TrajectoryExpectation and argument matchers for agentic tool-call evaluation

TrajectoryExpectation lets developers verify the model's tool-call decision path (which tools must be called, in what order, with what arguments, and which must never be called); a rich set of argument matchers (exact, naturalLanguage, contains, oneOf, pattern, range, keyOnly) provides flexible validation, and TrajectoryExpectation is Generable for synthetic dataset generation.

SessionsCreate robust evaluations for agentic apps

minor

SampleGenerator synthetic data generation with random and slidingWindow strategies

SampleGenerator's async stream API generates evaluation samples from a seed dataset using on-device or cloud models; two built-in sampling strategies control seed example presentation — random for unordered datasets and slidingWindow for datasets with meaningful order.

SessionsMeet the Evaluations frameworkCreate robust evaluations for agentic apps

minor

LanguageModelSession runtime updates and Server-side tool transparency levels

LanguageModelSession now supports continuous runtime updates to models, tools, and instructions; executors can surface server-side tool calls (e.g., web search) at three transparency levels — privately grounded, metadata-enriched, or fully surfaced as custom segments.

SessionsPlatforms State of the UnionBring an LLM Provider to the Foundation Models framework

minor

save_intermediates API and Core AI Debugger for model conversion debugging

A new coreai API executes a PyTorch model and captures intermediate tensor values at every operation into an Intermediates File, which can be loaded into Core AI Debugger's comparison mode to identify where quantization or conversion diverges from the original.

SessionsDive into Core AI model authoring and optimization

minor

coreai-opt weight compression with int4/int8/FP4/FP8 presets

The coreai-opt library ships preset compression configurations (e.g., presets.w4 for 4-bit symmetric quantization) and lower-level Quantizer and KMeansPalettizer APIs supporting EAGER and GRAPH execution modes for fine-grained per-layer compression.

SessionsDive into Core AI model authoring and optimization

minor

MLX_METAL_FAST_SYNCH and nn.layers.distributed APIs

A new MLX_METAL_FAST_SYNCH=1 environment variable enables faster GPU-to-CPU synchronization critical for distributed JACCL communication; new Python APIs shard_linear() and sharded_load() provide fine-grained control over model sharding across a cluster.

SessionsExplore distributed inference and training with MLX

minor

ImagePlayground integration with PaperKit

Developers can now launch ImagePlaygroundViewController from a PaperKit adornment tap, receive a generated image URL via delegate, and insert it directly into canvas markup as an ImageMarkup element.

SessionsUnwrap PaperKit

minor

Custom DynamicProfileModifier and open-source orchestration patterns

Developers can conform to DynamicProfileModifier and extend DynamicProfile to create shareable, named modifiers (mirroring SwiftUI's view modifier pattern); baton-pass and phone-a-friend are formally documented as reusable multi-model orchestration blueprints.

SessionsBuild agentic app experiences with the Foundation Models framework

minor

Foundation Models framework support extended to Linux

Custom executor Swift packages can now target Linux in addition to iOS, macOS, visionOS, and watchOS, broadening the Foundation Models ecosystem to server-side Swift deployments.

SessionsBring an LLM Provider to the Foundation Models framework

major

App Schemas (domain-based contracts for Siri integration)

New domain-based App Schemas (covering messages, mail, photos, calendar, and more) provide structured end-to-end contracts between apps and Siri, eliminating custom NLU training phrases. Developers conform to schema-defined entities and intents so Siri gains semantic understanding of app actions and content without per-app NLP work.

SessionsKeynotePlatforms State of the UnionBuild intelligent Siri experiences with App SchemasCode-along: Make your app available to SiriSecure your app: mitigate risks to agentic featuresInside Apple Intelligence and Xcode: Special Presentation

major

View Annotations API for on-screen entity awareness

New SwiftUI modifiers — .appEntityIdentifier(for:) for individual views, .appEntityIdentifier(forSelectionType:) for collections, and an updated .userActivity(with: EntityIdentifier) — let developers annotate on-screen views with their App Entities so Siri can contextually resolve references like 'send this photo to Kevin' or 'update that event'.

SessionsKeynotePlatforms State of the UnionBuild intelligent Siri experiences with App SchemasCode-along: Make your app available to SiriExplore advanced App Intents features for Siri and Apple IntelligenceModernize your UIKit app

major

IndexedEntity protocol for Spotlight semantic search

A new IndexedEntity protocol (and companion IndexedEntityQuery) lets @AppEntity types appear in the system's semantic Spotlight index via indexAppEntities() and deleteAppEntities() calls, enabling Siri to answer natural-language questions about in-app content by meaning rather than exact keyword match.

SessionsKeynotePlatforms State of the UnionBuild intelligent Siri experiences with App SchemasCode-along: Make your app available to SiriExplore advanced App Intents features for Siri and Apple Intelligence

major

IntentValueQuery and Visual Intelligence integration

A new IntentValueQuery protocol accepts a SemanticContentDescriptor (carrying the pixel buffer and image context from Visual Intelligence) and returns typed entity results, letting apps surface content matched against what the camera or a screenshot sees. The companion semanticContentSearch schema (.visualIntelligence.semanticContentSearch) provides a 'Continue in app' action to launch a pre-populated in-app search.

SessionsBest practices for integrating visual intelligence in your appExplore advanced App Intents features for Siri and Apple Intelligence

major

AppIntentsTesting framework for out-of-process intent testing

A new AppIntentsTesting framework lets developers run App Intents in an XCUITest bundle against the real App Intents stack without mocks or UI automation. It includes IntentDefinitions for bundle-based lookup, makeIntent().run() for typed execution, entity query testing APIs, spotlightQuery() for indexing verification, viewAnnotations() to validate on-screen entity bindings, test-only intents with isDiscoverable = false, and multi-intent chaining.

SessionsKeynoteValidate your App Intents adoption with AppIntentsTesting

major

Siri AI with conversational natural language and dedicated app

iOS 27 upgrades Siri to 'Siri AI', supporting natural back-and-forth conversation, editing and writing emails, texts, and documents. A new standalone Siri AI app gives users access to full conversation history for follow-ups.

SessionsAnnouncing Apple's next big step for Siri and iPhone

major

Automatic risk-based confirmation and IntentAuthenticationPolicy

App Intents now include a built-in risk evaluation pipeline that automatically triggers user confirmation for high-risk actions (deletions, data-exfiltrating operations). Intents can declare a static authenticationPolicy (e.g., .requiresAuthentication), and schema-based intents automatically inherit their schema's risk metadata and default authentication policy — stricter overrides only, enforced at build time.

SessionsSecure your app: mitigate risks to agentic features

notable

Cross-app entity sharing via IntentValueRepresentation and Transferable

New IntentValueRepresentation (exporting) and IntentValueQuery (importing) APIs let app entities move between apps via Siri, enabling multi-app workflows such as 'Text my wife this conversation from UnicornChat'. Developers adopt by conforming their entity to Transferable and providing an exporting closure or key-path shorthand.

SessionsBuild intelligent Siri experiences with App SchemasDiscover new capabilities in the App Intents framework

notable

@UnionValue macro for multi-type parameters and results

The new @UnionValue macro lets developers annotate a Swift enum so a single intent parameter or IntentValueQuery can accept or return multiple entity types (e.g., albums and concerts). Siri handles disambiguation automatically, and display names per case are configured via typeDisplayRepresentation and caseDisplayRepresentations.

SessionsBest practices for integrating visual intelligence in your appDiscover new capabilities in the App Intents framework

notable

ShowsSnippetView for custom Siri result cards

Apps can now return a ShowsSnippetView from intents to surface custom, branded SwiftUI result cards directly within the Siri UI, giving users rich visual confirmation without leaving the Siri surface.

SessionsCode-along: Make your app available to SiriExplore advanced App Intents features for Siri and Apple Intelligence

notable

SyncableEntity protocol for cross-device Siri conversations

Conforming an AppEntity to SyncableEntity declares that its identifier is stable across devices, enabling Siri conversations started on one device to correctly resolve entities on another. Supports both natively stable IDs and paired local/stable IDs via SyncableEntityIdentifier.

SessionsDiscover new capabilities in the App Intents framework

notable

LongRunningIntent and CancellableIntent protocols

LongRunningIntent allows intents to run beyond the 30-second limit by wrapping work in performBackgroundTask(perform:onCancel:), displaying progress as a Live Activity and supporting background GPU access with an entitlement. CancellableIntent provides an onCancel handler with a CancellationReason for graceful cleanup of partial work.

SessionsDiscover new capabilities in the App Intents framework

notable

TransientAppEntity protocol for ephemeral entities

A new TransientAppEntity protocol supports app entities that have no independent identity or persistent storage — such as attendees embedded within events — requiring no ID, query, or index, and simplifying modeling of ephemeral or composite data.

SessionsCode-along: Make your app available to Siri

notable

RelevantEntities API for contextual entity suggestions

RelevantEntities.shared lets apps register entities alongside an AppEntityContext describing when they are relevant (e.g., during a running workout), making app content proactively discoverable in Siri and Spotlight. Supports add, remove-specific, and remove-all operations.

SessionsDiscover new capabilities in the App Intents framework

notable

EntityCollection for high-performance large entity sets

A new generic parameter type EntityCollection<EntityType> passes only entity identifiers to an intent's perform() method rather than fully resolving every entity, significantly reducing overhead when an intent operates on thousands of items.

SessionsDiscover new capabilities in the App Intents framework

notable

ExecutionTargets for explicit intent process control

A new allowedExecutionTargets static property (an OptionSet) lets developers target .main, .appIntentsExtension, or .widgetKitExtension per intent rather than relying on system heuristics, ensuring correct data access and performance per operation.

SessionsDiscover new capabilities in the App Intents framework

notable

ProvidesDialog protocol for custom Siri spoken responses

A new ProvidesDialog protocol enables App Intents to provide fully customized spoken and displayed dialog strings, including separate full (voice-only) and supporting (UI display) variants, plus in-perform clarifying questions via DialogRequest.

SessionsExplore advanced App Intents features for Siri and Apple Intelligence

notable

IntentDonationManager for interaction-based donations

An expanded donation API lets apps donate schema-conforming App Intents at the moment of UI interaction, so Siri learns user preferences and maintains awareness of ongoing activities such as navigation or stopwatches.

SessionsExplore advanced App Intents features for Siri and Apple Intelligence

notable

OwnershipProvidingEntity protocol for auto-confirmation

A new OwnershipProvidingEntity protocol lets app entities declare their ownership level (.shared, .public, .unknown) so Siri can auto-confirm intents with meaningful side effects on shared or public content without requiring explicit user confirmation.

SessionsExplore advanced App Intents features for Siri and Apple Intelligence

notable

Calendar App Schema domain

A new calendar schema domain provides standardized schemas for calendar entities (calendar_calendar, calendar_attendee, calendar_event) and intents (calendar_createEvent, calendar_updateEvent, calendar_deleteEvent), letting calendar apps integrate with Siri's Apple Intelligence features with minimal custom code.

SessionsCode-along: Make your app available to Siri

notable

System framework entity annotations (Notifications, MusicContent, AlarmKit)

New appEntityIdentifiers property on UNMutableNotificationContent and MusicContent (Now Playing), and appEntityIdentifier on AlarmConfiguration (AlarmKit), let apps annotate system objects with App Entities for deeper Siri and Apple Intelligence integration.

SessionsExplore advanced App Intents features for Siri and Apple Intelligence

notable

Ask Siri button automatically appears in UIKit menus

In iOS 27, UIKit menus automatically display an Ask Siri button when relevant app content is present, providing a contextual entry point to Siri directly from app menus without developer code.

SessionsModernize your UIKit app

notable

Siri loading resources via drag-and-drop handlers

When Apple Intelligence invokes context menus, it can call available drag delegate methods to load content from the app, enabling Siri to access the same resources a user would drag. Developers should avoid triggering animations or modal UI in sessionWillBegin.

SessionsModernize your UIKit app

notable

LiveCommunicationKit integration with App Intents

LiveCommunicationKit now integrates with App Intents, letting users start communication sessions via Siri and connecting the framework to the broader system intelligence layer.

SessionsCreate live communication experiences

notable

IntentParameter.valueState for precise partial-update intents

A new valueState property on IntentParameter lets update intents distinguish between a parameter that was explicitly set (including set to nil to clear it) versus one that was simply not mentioned in the request, enabling correct partial-update behavior in Siri interactions.

SessionsCode-along: Make your app available to Siri

notable

IntentPerson type for cross-app person resolution

A new standard IntentPerson type in App Intents represents a person with name and contact information, used in schema-conforming attendee entities to enable Siri to resolve people across apps.

SessionsCode-along: Make your app available to Siri

notable

Union value properties in App Entity schemas

App entity schema properties can now be declared as union values (e.g., location: PlaceDescriptor | String, alarms: Duration | Date), allowing a single property to hold multiple types and enabling Siri to handle ambiguous or flexible input gracefully.

SessionsCode-along: Make your app available to Siri

minor

New native parameter types: Duration and PersonNameComponents

App Intents now natively supports Duration and PersonNameComponents as parameter types, providing automatic Siri understanding, localization, and picker UI without custom entity work.

SessionsDiscover new capabilities in the App Intents framework

minor

.system.searchInApp schema (renamed from .system.search)

The .system.search schema is renamed to .system.searchInApp, letting Siri re-run searches within the app's custom UI regardless of domain adoption or entity indexing.

SessionsExplore advanced App Intents features for Siri and Apple Intelligence

minor

DisplayRepresentation.Components for fast on-screen entity queries

A new DisplayRepresentation.Components type enables text-only display representation queries that skip image loading, enabling faster responses when Siri needs to identify on-screen entities without full visual assets.

SessionsExplore advanced App Intents features for Siri and Apple Intelligence

minor

Model transcript inspector for debugging App Entity data

Developers can inspect the exact raw data passed to the Use Model action from App Intent entities via the Transcript property in a Show Content action, making it straightforward to diagnose unexpected model results.

SessionsWhat's new in Shortcuts

minor

Stable entity identifier requirement for cross-device shortcut storage

App Entities stored in shortcuts must now use device-independent stable identifiers (such as a database row ID) so that an entity saved on one device is correctly recognized by the app on another device.

SessionsWhat's new in Shortcuts

minor

Declarative MDM configurations for Apple Intelligence and Siri

New declarative configurations give IT administrators granular control over individual Apple Intelligence features, Siri capabilities, and keyboard settings on managed devices.

SessionsWhat's new in managing Apple devices

major

Liquid Glass two-layer UI architecture

iOS 26 introduces a two-layer model where UI controls (tab bars, toolbars, navigation bars) float above a content canvas using Liquid Glass. Apps automatically adopt the updated Liquid Glass visual design on new OS releases without code changes, and brand color should now live in the content layer so Liquid Glass controls dynamically pick it up.

SessionsCommunicate your brand identity on iOSModernize your UIKit appWhat's New in SwiftUI

major

iPhone apps fully resizable in iOS 27

iPhone apps are now fully resizable when used with iPhone Mirroring on Mac and when running on iPad, requiring UISceneDelegate adoption (apps without it will no longer launch). A resizable iOS simulator and Previews support help developers test layouts across dynamic size ranges.

SessionsPlatforms State of the UnionModernize your UIKit app

major

Observation tracking in AppKit and UIKit

AppKit and UIKit now automatically track @Observable objects and invalidate views without manual needsDisplay calls, supported in draw(_:), updateConstraints(), layout(), updateLayer(), and UIKit controls like UIButton and UICollectionViewCell. Enabled by default in 2026 OS releases and back-deployable to macOS 15 / iOS 18 via an Info.plist key.

SessionsUse SwiftUI with AppKit and UIKit

major

ContentBuilder unification replacing ViewBuilder

A unified @ContentBuilder replaces @ViewBuilder across Section, Group, ForEach, and other containers, delivering substantial type-checking performance improvements in Xcode 27 while remaining compatible with any minimum deployment target.

SessionsWhat's New in SwiftUI

notable

Reorderable container APIs for any SwiftUI container

New .reorderable() on ForEach and .reorderContainer(for:) on containers like List and LazyVGrid enable drag-to-reorder in any layout — not just List — including watchOS for the first time. The ReorderDifference type integrates with OrderedCollections for efficient data updates.

SessionsKeynotePlatforms State of the UnionCode-along: Build powerful drag and drop in SwiftUIWhat's New in SwiftUI

notable

Swipe actions on arbitrary views in scroll containers

The .swipeActions() modifier now works beyond List on any view in a scroll container, and a companion .swipeActionsContainer() modifier on the scroll view coordinates swipe behavior across all items.

SessionsKeynotePlatforms State of the UnionDive into lazy stacks and scrolling with SwiftUIWhat's New in SwiftUI

notable

Toolbar visibility priority, overflow menu, and minimization

New .visibilityPriority(.high) modifier, ToolbarOverflowMenu container, and topBarPinnedTrailing placement give fine-grained control over toolbar item visibility. The .toolbarMinimizeBehavior(.onScrollDown) modifier and UINavigationItem.barMinimizationBehavior property enable navigation bars to auto-minimize during scroll on iOS 27.

SessionsKeynotePlatforms State of the UnionWhat's New in SwiftUIModernize your UIKit app

notable

SwiftUI document infrastructure: WritableDocument, ReadableDocument, and DocumentCreationSource

New WritableDocument and ReadableDocument protocols enable background async writing with snapshot-based diffing and Foundation Subprogress progress reporting. DocumentCreationSource API allows custom new-document flows, and SwiftUI document apps gain first-class URL access and observable document configuration with full Swift concurrency and Observation support.

SessionsKeynotePlatforms State of the UnionWhat's New in SwiftUI

notable

@State macro lazy initialization for Observable types

@State is now implemented as a macro that lazily initializes @Observable class instances only once for the lifetime of a view, preventing redundant allocations on view reinitializations. This is a source-breaking change back-ported to iOS 17 / macOS 14.

SessionsPlatforms State of the UnionWhat's New in SwiftUI

notable

AsyncImage HTTP caching and custom URLSession support

AsyncImage now enables standard HTTP caching by default, respecting server cache headers and only re-fetching when content changes. New AsyncImage(request:) and .asyncImageURLSession(_:) APIs allow custom URLRequest cache policies and URLSession configurations with dedicated URLCache instances.

SessionsPlatforms State of the UnionWhat's New in SwiftUI

notable

PencilKit character recognition, Bezier path conversion, and UIFindInteraction for handwriting search

PencilKit now supports character recognition and stroke-to-Bézier-path conversion, and PencilKit strokes are first-class markup elements within PaperKit. By implementing UIFindInteractionDelegate backed by PKStrokeRecognizer.search(_:), developers get the full system find-and-replace UI inside a PencilKit canvas.

SessionsUnwrap PaperKitRead between the strokes with PencilKit

notable

Metal shader modifiers in SwiftUI (layerEffect, colorEffect, distortionEffect)

Three new SwiftUI view modifiers apply Metal [[stitchable]] shaders directly to views: colorEffect() transforms pixel colors, distortionEffect() remaps pixel sampling positions, and layerEffect() provides full access to the entire view layer via the new SwiftUI::Layer type, enabling advanced per-pixel effects like domain warping.

SessionsCompose advanced graphics effects with SwiftUI

notable

Multi-item drag-and-drop APIs (dragContainer, dragPreviewsFormation, dropConfiguration)

New SwiftUI modifiers enable dragging multiple items simultaneously via dragContainer(for:_:), customize drag/drop visual formations with dragPreviewsFormation(_:) and dropPreviewsFormation(_:) (.pile, .list, .stack), declare move/copy semantics via dragConfiguration(_:), and validate drops with dropConfiguration(handler:) returning .move, .copy, or .forbidden.

SessionsCode-along: Build powerful drag and drop in SwiftUI

notable

UIWindowScene.Geometry API for scene geometry

A new UIWindowScene.Geometry API and windowScene(_:didUpdateEffectiveGeometry:) delegate callback let apps respond to changes in available scene space, replacing the deprecated UIScreen.main.bounds pattern for apps adapting to resizable environments.

SessionsModernize your UIKit app

notable

Sidebar support for iPhone via UITabBarController

iPhone apps can opt into a sidebar layout using tabBarController.sidebar.preferredPlacement = .sidebar, with availability gated by horizontal size class so the sidebar only appears when there is enough space. A new prominentTabIdentifier property designates which tab stays visible when the tab bar collapses during scrolling.

SessionsModernize your UIKit app

notable

NSHostingMenu for SwiftUI-powered AppKit menus

NSHostingMenu is a new NSMenu subclass that wraps SwiftUI views, allowing developers to build main-menu items — including Picker with palette style and keyboard shortcuts — entirely in SwiftUI and integrate them into an existing AppKit menu bar.

SessionsUse SwiftUI with AppKit and UIKit

notable

NSHostingSceneRepresentation for SwiftUI scenes in AppKit apps

A new type that lets AppKit apps with NSApplicationDelegate add complete SwiftUI scenes (MenuBarExtra, Settings) dynamically from applicationWillFinishLaunching without restructuring the app's architecture, and exposes an environment-based openSettings() action.

SessionsUse SwiftUI with AppKit and UIKit

notable

NSGestureRecognizerRepresentable protocol

A new SwiftUI protocol lets developers reuse existing NSGestureRecognizer subclasses directly in SwiftUI views on macOS, bridging AppKit gesture recognizers into the SwiftUI gesture system with just two required methods.

SessionsUse SwiftUI with AppKit and UIKit

notable

UITextView and NSTextView public NSTextViewportLayoutControllerDelegate conformance

UITextView and NSTextView now publicly conform to NSTextViewportLayoutControllerDelegate, so developers can subclass these views and override willLayout, configureRenderingSurface, and didLayout delegate methods to add behaviors like line numbers and collapsible sections without building a custom text view from scratch.

SessionsElevate your app's text experience with TextKit

notable

NSTextSelectionManager for custom AppKit views

New in macOS 27, NSTextSelectionManager brings classic macOS text selection behaviors — including bidirectional selection, drag and drop, and toggling — to any custom NSView via a text selection data source.

SessionsModernize your AppKit app

notable

Nested stack layout up to 2x faster

A unified SwiftUI, AppKit, and UIKit architecture across controls, combined with algorithmic improvements, makes nested stack layout resolution up to 2x faster, improving performance for complex view hierarchies.

SessionsPlatforms State of the Union

notable

SwiftUI Zoom Transitions

SwiftUI Zoom Transitions create fluid animations that connect a tap target to the transition state, enabling delightful interactions such as expanding a detail view from its tap point.

SessionsCommunicate your brand identity on iOS

notable

PaperKit canvas APIs (PaperMarkup, MarkupOrderedSet, ShapeMarkup, ImageMarkup, MarkupAdornment)

PaperKit gains a comprehensive programmatic canvas API: PaperMarkup.subelements exposes all canvas elements as a MarkupOrderedSet, with concrete ShapeMarkup and ImageMarkup element types, allowedInteractions/readOnly locking, and MarkupAdornment for attaching overlay UI anchored to canvas coordinates with tap callbacks.

SessionsUnwrap PaperKit

notable

imagePlaygroundGenerationStyle modifier with externalProvider style

A new .imagePlaygroundGenerationStyle() view modifier lets developers set default and allowed style presets (Animation, Illustration, Sketch, Genmoji) including a new .externalProvider style that surfaces third-party providers like ChatGPT within the Image Playground UI. A companion supportsImageGeneration environment value and onAdaptiveImageGlyphCreation callback enable adaptive Genmoji generation.

SessionsCreate high-quality images using Image Playground

notable

Text selection enhancements across platforms

Text selection on iOS now has full fidelity matching TextField behavior; macOS gains custom text renderer support; and vertical text selection is now supported, expanding rich text interaction capabilities across platforms.

SessionsPlatforms State of the Union

minor

Prominent tab role for Tab views

A new .prominent tab role on Tab lets developers visually distinguish special tabs (like a shopping cart) from standard navigation tabs in SwiftUI tab bars.

SessionsWhat's New in SwiftUIModernize your UIKit app

minor

appearsActive environment value for window state

A new appearsActive environment value lets SwiftUI views conditionally adjust their appearance based on whether the window is active, enabling proper dimming of content in inactive iPadOS windows.

SessionsWhat's New in SwiftUI

minor

Item-binding overloads for confirmationDialog and alert

New overloads for confirmationDialog(_:item:actions:) and alert(_:item:actions:) accept a binding to an optional item, simplifying the pattern for presenting item-specific dialogs without extra state management.

SessionsWhat's New in SwiftUI

minor

accessibilityLinkedGroup SwiftUI modifier

New in iOS 27, this SwiftUI modifier links multiple Text elements together so VoiceOver navigates between them as a single continuous reading flow, using a namespace and shared ID.

SessionsEnhance the accessibility of your reading app

minor

NSViewCornerConfiguration and concentricity API

New NSViewCornerConfiguration API lets NSView subclasses declare their corner radius using NSViewCornerRadius.containerConcentric(_:), so nested views automatically match and adapt to the container's corner radius for a harmonious visual appearance.

SessionsModernize your AppKit app

minor

NSControl.Events and addTarget(_:action:for:) in AppKit

AppKit now supports NSControl.Events with addTarget(_:action:for:), including new events like .trackingEndedOutside, enabling developers to register control event handlers without relying on subclassing or manual tracking loops.

SessionsModernize your AppKit app

minor

NSWindow.autorecalculatesKeyViewLoop

Setting autorecalculatesKeyViewLoop to true on NSWindow enables automatic recalculation of the Tab/Shift+Tab key view loop, reducing manual maintenance of focus order.

SessionsModernize your AppKit app

minor

UIRequiresFullscreen discrete resizing for games

In iOS 27, UIRequiresFullscreen no longer fully opts apps out of resizing; instead it enables discrete resizing that honors supported interface orientations, so games always render at full quality in available space.

SessionsModernize your UIKit app

minor

Scroll edge appearance .automatic style updated visuals

The .automatic scroll edge effect style has updated visuals as part of the refined Liquid Glass look; apps that previously matched system appearance by setting .soft should re-evaluate their designs.

SessionsModernize your UIKit app

minor

Menu images hidden by default with Liquid Glass (preferredImageVisibility)

With the refined Liquid Glass design, menu element images no longer show by default in menu bars on iPadOS and macOS; developers can restore them using the new preferredImageVisibility property on menu elements.

SessionsModernize your UIKit app

minor

NSTextViewportRenderingSurface and NSTextViewportRenderingSurfaceKey protocols

New protocols allow UIView, NSView, or CALayer to serve as a visual rendering surface inside a text viewport, with a companion key protocol uniquely identifying surfaces across layout cycles for caching via NSTextLayoutFragment.

SessionsElevate your app's text experience with TextKit

minor

Text attachment view provider reuse policies

Two new reuse policies — onEditingInlineParagraphs and onScrollingOutOfViewport — can be registered via register(_:forTextAttachmentViewProviderType:) to prevent view providers from being torn down and recreated on every keystroke or scroll, fixing animation restart issues and improving performance.

SessionsElevate your app's text experience with TextKit

minor

onScrollTargetVisibilityChange and prefetch-aware State initialization for lazy stacks

onScrollTargetVisibilityChange is the recommended API for monitoring visible subviews during scrolling (preferred over onScrollGeometryChange). A new pattern uses State(initialValue:) in the view initializer to start async data loading during LazyStack prefetch, enabling smoother scrolling by distributing work across frames.

SessionsDive into lazy stacks and scrolling with SwiftUI

minor

SubscriptionStoreView SwiftUI modifiers for pricing and management

New .preferredSubscriptionPricingTerms modifier filters which pricing term is presented in SubscriptionStoreView, and .manageSubscriptionsSheet allows presenting the system subscription management sheet scoped to a specific subscription group ID.

SessionsWhat's new in Apple In-App Purchase

minor

Content Unavailable view for empty search states

A new ContentUnavailableView is introduced as the recommended component for empty search states, displaying a search symbol, title, and subtitle to prevent blank screens.

SessionsDesign intuitive search experiences

minor

UIView Body protocols for CoreMotion and CoreLocation coordinate correctness

UIView now conforms to new Body protocols from CoreMotion and CoreLocation, ensuring motion and heading data are always delivered in the correct coordinate space regardless of interface orientation or scene configuration.

SessionsModernize your UIKit app

major

Swift 6.4 language release

Swift 6.4 ships a broad set of language improvements including warning suppression controls via the @diagnose attribute, the anyAppleOS availability attribute, async calls in defer blocks, weak let properties, ~Sendable syntax, module selector disambiguation (::), improved type-checking performance, and better compiler diagnostics that eliminate the 'unable to type check in reasonable time' fallback.

SessionsKeynotePlatforms State of the UnionWhat's new in Swift

major

Noncopyable and nonescape type system improvements

Equatable, Comparable, and Hashable now support ~Copyable and ~Escapable types; a new Iterable protocol enables borrow-based for loops over collections of noncopyable elements; and new UniqueBox, UniqueArray, Ref, and MutableRef standard library types provide safe noncopyable containers and reference handles without reference counting overhead.

SessionsWhat's new in Swift

major

@C attribute and Swift-to-C interoperability

The new @C attribute exposes Swift functions directly to C with compiler-enforced type safety, automatic Span-to-C array bridging, and support for implementing C functions via @implementation, enabling seamless Swift-C interop without manual bridging boilerplate.

SessionsWhat's new in Swift

major

Safer compile-time-checked Continuation type

A new Continuation type is compile-time checked to ensure it is resumed exactly once, replacing the runtime-checked CheckedContinuation for safer async bridging from callback-based APIs.

SessionsWhat's new in Swift

major

@concurrent task attribute for Swift Concurrency

A new @concurrent attribute on Task initializers moves work off the Main Actor onto the global concurrent executor with compiler-enforced safety checks for race conditions, directly addressing Main Actor saturation and UI hangs.

SessionsProfile, fix, and verify: Improve app responsiveness with Instruments

notable

Exit tests with #expect(processExitsWith:) in Swift Testing

A new Swift Testing macro runs a test body in an isolated child process to verify code paths that crash (e.g., preconditionFailure), checks exit status, and includes the covered code in Code Coverage. Supported on macOS, Linux, FreeBSD, and Windows.

SessionsMigrate to Swift Testing

notable

Swift Testing FreeBSD platform support

Swift Testing now fully supports FreeBSD as a platform, expanding the officially supported list to macOS, Linux, FreeBSD, and Windows.

SessionsMigrate to Swift Testing

notable

borrow and mutate property accessors

New borrow and mutate property accessors provide read-only shared access and exclusive in-place mutation respectively, replacing get/set in performance-critical paths and enabling use with noncopyable values.

SessionsWhat's new in Swift

notable

@inline(always) and @specialized optimizer control attributes

@inline(always) forces the compiler to inline a function even when the optimizer would not, and @specialized(where ...) generates a specialized version of a generic function for specific concrete types, giving developers direct control over hot-path performance.

SessionsWhat's new in Swift

notable

withTaskCancellationShield for concurrency cleanup

A new withTaskCancellationShield function shields a region of code from Swift Concurrency task cancellation checks so that cancellation status returns false inside the shield, useful for finalization or cleanup logic that must complete regardless of cancellation.

SessionsWhat's new in Swift

notable

Embedded Swift existential types and untyped throws

Embedded Swift now supports existential types (protocol-typed storage in arrays and function parameters) and untyped throws using existential machinery, significantly expanding the language subset available on embedded targets.

SessionsWhat's new in Swift

notable

Swift-Java async and protocol interoperability

The Swift-Java package now supports calling async and throwing Swift functions from Java/Kotlin, constrained generic extensions, and conforming Java classes to Swift protocols, deepening cross-language integration.

SessionsWhat's new in Swift

notable

JavascriptKit safe bridging (35-40x faster) and WebGL support

JavascriptKit gains a new safe bridging layer that is 35-40x faster than dynamic bridging, plus WebGL bindings that let Swift code call WebGL through JavaScript with native-looking syntax when compiling to WebAssembly.

SessionsWhat's new in Swift

notable

FilePath type in the Swift standard library

The FilePath type (based on Swift System) is now available cross-platform in the standard library, providing safe, idiomatic file path handling without depending on Foundation.

SessionsWhat's new in Swift

notable

Task error warnings for silently ignored throws

The compiler now emits a warning when an error thrown from a Swift Concurrency task is silently ignored, helping developers catch unhandled failure paths in structured and unstructured concurrency code.

SessionsWhat's new in Swift

notable

Multi-language MLX with Swift front-end

MLX now has four official front-ends — Swift, Python, C++, and C — sharing the same lazy-evaluation model and operations, so developers can prototype in Python and ship in Swift with minimal changes.

SessionsExplore numerical computing in Swift with MLX

minor

Struct memberwise initializer for mixed-access properties

Structs with mixed internal and private properties now automatically generate a second memberwise initializer accessible from other files, eliminating the need to hand-write initializers in this common pattern.

SessionsWhat's new in Swift

minor

Dictionary.mapKeyedValues standard library method

A new mapKeyedValues method on Dictionary maps values while providing both key and value to the closure, simplifying a common transformation that previously required manual iteration.

SessionsWhat's new in Swift

minor

RPCAsyncSequence and RPCWriter for bidirectional streaming

New RPCAsyncSequence<Request, Error> and RPCWriter<Response> types enable server-side implementation of bidirectional streaming RPCs using async/await and AsyncIterator, making real-time two-way communication straightforward to implement.

SessionsBuild real-time apps and services with gRPC and Swift

minor

@ReportableMetadata macro for custom state metadata

The new @ReportableMetadata Swift macro lets developers define custom structured types that can be attached to state transitions, providing rich context alongside per-state metrics.

SessionsMeet the new MetricKit

major

Xcode 27 Coding Agents with Full IDE Integration

Xcode 27 ships redesigned coding agents that act as collaborators across the entire codebase, supporting planning (/plan command), parallel sub-agent orchestration, image attachments, inline annotations, queued messages, artifact diff panels, SwiftUI preview self-verification, and agent-generated unit tests. Agents integrate MCP (Figma, GitHub), Agent Client Protocol (ACP), and support providers from Anthropic, OpenAI, and Google.

SessionsKeynotePlatforms State of the UnionCreate UI prototypes using agents in XcodeRun local agentic AI on the Mac using MLXWhat's new in Xcode 27Xcode, agents, and youInside Apple Intelligence and Xcode: Special Presentation

major

Xcode Device Hub — Unified Simulator and Device Management

A new standalone app shipping with Xcode 27 that replaces the old Simulator app with a unified interface for managing physical devices and simulators. It includes compact and full window modes, live interactive canvas, contextual device controls per device type, resize mode, wireless pairing, configuration profile drag-and-drop, sysdiagnose capture, app data container download/restore, diagnostic reports panel, and CarPlay Simulator support.

SessionsKeynotePlatforms State of the UnionWhat's new in Xcode 27Get the most out of Device HubModernize your UIKit appRev up your CarPlay app

major

Foundation Models Evaluation Framework in Xcode 27

Xcode 27 ships a new evaluation framework with visual report UI, side-by-side comparison of control vs. experimental runs, an assistant editor showing inputs/outputs/expected values per sample, JSON export, and Swift Testing integration via the .evaluates trait. Evaluations measure and track prompt accuracy across iterations and integrate directly into the Swift Testing @Test macro.

SessionsBuild AI-powered scripts with the fm CLI and Python SDKCreate robust evaluations for agentic appsImprove your prompts by hill-climbing with EvaluationsMeet the Evaluations frameworkLLM search using Core Spotlight

major

Xcode Cloud Speed Improvements and Vision Pro Support

Xcode Cloud delivers up to 2x build speed improvements and adds Apple Vision Pro and Metal on Apple silicon support, with a streamlined onboarding assistant, webhook support for build lifecycle events, additional repository management, direct TestFlight distribution workflow setup, and integration with Xcode agents for automated build-and-test of agent-written code.

SessionsKeynotePlatforms State of the UnionWhat's new in Xcode 27Build, deliver, and automate with Xcode Cloud

major

Agent-Powered Localization with Parallel Sub-Agents in Xcode 27

A single prompt triggers the Xcode coding agent to add a language, build to discover strings, batch strings to parallel sub-agents with language-aware plural handling, translate String Catalogs, render UI to detect truncation and layout issues, and maintain cross-conversation terminology consistency. Translations are tracked via the leveraged-mt XLIFF state qualifier, and a TRANSLATION.md file can supply glossaries and tone guidance.

SessionsTranslate your app using agents in XcodeWhat's new in Xcode 27Xcode, agents, and you

major

Core AI Debugger, Model Viewer, and Instruments Template in Xcode

Xcode 27 gains a standalone Core AI Debugger for visualizing model graphs, inspecting intermediate tensor outputs against PyTorch references, and tracing issues to Python source; a built-in .aimodel file viewer showing metadata, function signatures, and compute unit distribution; a Debug Gauge for real-time streaming activity; and a dedicated Core AI Instruments template for profiling inference latency across CPU, GPU, and Neural Engine.

SessionsDive into Core AI model authoring and optimizationMeet Core AIIntegrate on-device AI models into your app using Core AI

major

Xcode 27 Comprehensive UI and Workspace Redesign

Xcode 27 overhauls the IDE with a fully customizable toolbar (items from jump bar migrated), redesigned workspace layout with a 3-way Editor Mode Selector, per-project theme assignment, new built-in themes (Neon Noir, Emerald, Coral Reef), iCloud settings sync across Macs, instant untitled project creation, standalone Swift file windows with Canvas support, and subtle inline issue rendering.

SessionsPlatforms State of the UnionWhat's new in Xcode 27

major

Instruments 27: Top Functions, Run Comparisons, Swift Executors, and Inspector Panel

Instruments 27 adds four major features: Top Functions view surfaces functions sorted by self-time; Run Comparisons lets developers diff two profiling runs side-by-side with per-node deltas highlighted in red/green; Swift Executors instrument visualizes Main Actor, global concurrent executor, and custom executors; and a new Inspector panel surfaces context-aware details and actions for the current timeline selection.

SessionsWhat's new in Xcode 27Profile, fix, and verify: Improve app responsiveness with Instruments

major

Enhanced Foundation Models Instrument for LLM Pipeline Profiling

Xcode 27 ships an updated Foundation Models profiling template in Instruments with a multi-lane timeline, tree-view hierarchy (sessions, requests, inferences, tool calls, prompts, responses), per-inference TTFT/TPS/latency metrics, color-coded processing bars, KV-cache invalidation detection, and multi-session LanguageModelSession visibility — providing deep observability into agentic LLM pipelines.

SessionsBuild agentic app experiences with the Foundation Models frameworkDebug and profile agentic app experiences with Instruments

notable

Agent Skills for SwiftUI, UIKit Modernization, and Game Porting

Xcode 27 ships exportable agent skills — SwiftUI Specialist, What's New In SwiftUI, and UIKit Adaptivity Modernization (auto-converting UIScreen.main, orientation checks, scene lifecycle) — exportable via xcrun agent skills export. Game porting skills can be installed into Claude Code via a plugin marketplace.

SessionsWhat's New in SwiftUIModernize your UIKit appSpeedrun your game port with agentic coding

notable

XCTest and Swift Testing Two-Way Interoperability

Xcode 27 enables safe cross-framework API calls between XCTest and Swift Testing in the same test suite, with four configurable interoperability modes (None, Limited, Complete, Strict). New projects default to Complete mode; Swift packages need swift-tools-version 6.4 or newer. Test.cancel() from Swift Testing is now usable in XCTestCase.

SessionsMigrate to Swift TestingWhat's new in Swift

notable

Swift Testing: Issue Severity, Test.cancel(), and Flaky Test Repetition

Swift Testing gains Issue.record() with a severity parameter for non-fatal warnings, Test.cancel() for dynamically skipping parameterized test cases at runtime, and a flaky-test repetition mode in swift test that repeats tests until pass or fail with a configurable maximum.

SessionsWhat's new in SwiftMigrate to Swift Testing

notable

usdcrush and usdrecord Command-Line Tools

usdcrush compresses USDZ textures with typically 4x file size reduction at no quality loss, while usdrecord generates thumbnail or fallback images from 3D files; both ship with macOS as part of the USD tool suite and help optimize immersive environments for web delivery.

SessionsExplore immersive website environments in visionOSGet started with the HTML Model Element

notable

Reality Composer Pro 3 Git Merge Tool and Auto-Generated Xcode Project

Reality Composer Pro 3 ships a built-in custom git merge tool for its JSON-based content file format to reduce team conflicts, and can now auto-generate a companion Xcode project when switching to 'Run with Xcode' preview mode.

SessionsExtend Reality Composer Pro 3 functionality with XcodeDesign no-code games with Reality Composer Pro 3

notable

Redesigned Organizer with Storage/Animation Hitch Metrics and Agent Recommendations

The Xcode Organizer now shows diagnostics and metrics together with highest-impact issues first, adds Storage and Animation Hitches as new performance metrics, provides per-app achievable metric goals calibrated by app similarity, and includes an agent-powered 'Generate Recommendations...' feature that analyzes diagnostic data and produces actionable fix suggestions.

SessionsWhat's new in Xcode 27

notable

AppIntentsTesting Framework for Unit Testing App Intents

A new AppIntentsTesting framework lets developers invoke App Intents in isolation — passing parameters and validating results without involving Siri — enabling fast unit-style testing of intent business logic, alongside Xcode build-time schema completeness validation with Fix-It stub generation.

SessionsBuild intelligent Siri experiences with App Schemas

notable

fm Command-Line Tool for On-Device Model Access on macOS 27

A new fm CLI on macOS 27 provides terminal access to the on-device Foundation Model and Private Cloud Compute, supporting interactive chat, shell script piping, document summarization, and image-based file naming.

SessionsWhat's new in the Foundation Models framework

notable

Swift Build as Default SPM Backend

Swift Build is now the default backend for Swift Package Manager, improving build performance and consistency across platforms as part of the open-source Swift ecosystem.

SessionsWhat's new in Swift

notable

VSCode Swift Extension on OpenVSX Marketplace

The VSCode Swift extension is now available on the OpenVSX marketplace, bringing Swiftly toolchain management, testing, and documentation generation to VSCodium, Cursor, Kiro, and other compatible editors.

SessionsWhat's new in Swift

notable

Xcode Previews Property Variation Support

Xcode Previews now accept enum values to display all UI state variants simultaneously in a grid, enabling developers to preview accessibility sizes, orientations, localizations, and any custom property at once.

SessionsPlatforms State of the Union

notable

devicectl CLI Enhancements

The devicectl command-line tool now supports managing apps, capturing diagnostics, changing system settings (e.g., dark/light mode), and producing structured JSON output for CI and scripting workflows.

SessionsGet the most out of Device Hub

notable

grpc-swift-protobuf Xcode Build Plugin

A new grpc-swift-protobuf package includes an Xcode build plugin that automatically generates type-safe Swift client and server stubs from .proto service definitions, eliminating hand-crafted networking code.

SessionsBuild real-time apps and services with gRPC and Swift

notable

Background Assets Mock Server in Xcode 27

Xcode 27 automatically starts a Background Assets mock server during debug sessions, enabling developers to test asset pack downloading without a live CDN or App Store Connect configuration. A Steam Asset Converter CLI (xcrun ba-package convert) also converts Steam depot files into Apple asset pack manifests.

SessionsUnlock in-game content with StoreKit and Background Assets

notable

Xcode Local Intelligence Chat Provider for On-Device Coding

Xcode includes an Intelligence tab in Settings with an 'Add Chat Provider' dialog that lets developers connect agentic coding to a locally running MLX-LM Server, keeping all code on-device.

SessionsRun local agentic AI on the Mac using MLX

notable

Web Inspector Support for CSS Grid Lanes

Safari's Web Inspector now fully supports CSS Grid Lanes, displaying column/row lines, per-item order numbers, and gap indicators via an overlay for debugging masonry layouts.

SessionsLearn CSS Grid Lanes

notable

Pass Designer macOS App

A new WYSIWYG macOS tool at developer.apple.com/pass-designer renders Wallet passes exactly as they appear on iOS while developers configure identity, signing, images, barcodes, fields, and featured actions; templates are saved as .pkpasstemplate files.

SessionsWhat's new in Wallet

minor

Foveated Streaming Instrument in Xcode

A new Xcode instrument profiles foveated streaming sessions for visionOS, measuring stream bandwidth, pose latency, and frame rate to help developers diagnose and optimize streaming performance.

SessionsUse foveated streaming to bring immersive content to visionOS

minor

Immersive Model Add-On for Blender

Apple released a Blender extension that lets artists add RealityKit annotations (video docking regions, light spill baking, Scene Understanding components) directly in Blender and export optimized USDZ files for immersive web environments.

SessionsExplore immersive website environments in visionOS

minor

Extended Training Mode in Create ML Object Tracker

A new --training-mode extended flag in the createml objecttracker command significantly improves tracking accuracy and robustness for objects held in hand, recommended alongside high frame rate tracking.

SessionsExplore enhancements to visionOS object tracking

minor

StoreKit Configuration Billing Plan Picker in Xcode 26.5

The StoreKit testing environment in Xcode 26.5 adds a Billing Plan picker for one-year auto-renewable subscriptions, letting developers select and test the Monthly with 12-month commitment plan and inspect commitmentInfo in the Transaction inspector.

SessionsWhat's new in Apple In-App Purchase

minor

Xcode Build Scheme Overrides for Trust Insights Sandbox Testing

New Xcode build scheme overrides and a sandbox testing environment allow developers to simulate different Trust Insights outcomes and test decision logic and UX variations before App Store distribution.

SessionsMeet Trust Insights

major

SwiftData model class inheritance support

SwiftData now supports class inheritance hierarchies for models, allowing a base class (e.g., Goal) to be subclassed (TripGoal, ActivityGoal) and stored persistently. This enables richer domain modeling without flattening everything into a single table.

SessionsCode-along: Add persistence with SwiftData

major

ResultsObserver for observing SwiftData query results outside SwiftUI

ResultsObserver<Model, SectionIdentifier> is a new generic type that fetches data and observes the store for changes using Swift Observation, independent of SwiftUI views. It supports the same filtering, sorting, and sectioning primitives as @Query, enabling non-view state objects driven by live model data.

SessionsWhat's New in SwiftData

notable

HistoryObserver for persistent history transactions

HistoryObserver exposes an observable eventCounter property that increments whenever new history transactions are available, filterable by model type and transaction author. It works with ModelContext.fetchHistory() to let app extensions and sync services react precisely to model changes.

SessionsWhat's New in SwiftData

notable

Sectioned fetching with @Query sectionBy parameter

The @Query macro gains a new sectionBy: parameter accepting a KeyPath to a string property, enabling grouped results accessed via _property.sections. This allows SwiftUI lists to be driven by sections without manual grouping logic.

SessionsWhat's New in SwiftData

notable

@Attribute(.codable) for persisting custom and third-party types

A new .codable option on @Attribute lets developers persist types that SwiftData cannot natively model — such as MKMapItem.Identifier — by delegating serialization to the type's own Codable implementation. Contents are treated as opaque blobs and cannot be used in predicates or sorting.

SessionsWhat's New in SwiftData

notable

withContinuousObservation for reactive SwiftData updates

A new withContinuousObservation function enables real-time observation of SwiftData model properties, allowing side effects like updating a dateEdited timestamp to propagate automatically when observed values change.

SessionsCode-along: Add persistence with SwiftData

notable

Dynamic @Query construction with captured parameters at runtime

SwiftData's @Query property wrapper now supports dynamic initialization with captured parameters, enabling views to construct queries at runtime based on user input such as search terms.

SessionsCode-along: Add persistence with SwiftData

minor

localizedStandardContains in SwiftData #Predicate for locale-aware search

Predicates used with SwiftData's #Predicate macro can now leverage localizedStandardContains for locale-aware, case-insensitive search across model properties, simplifying search feature implementation.

SessionsCode-along: Add persistence with SwiftData

minor

CSSearchableIndexDelegate hydration method for full item recovery

A new delegate method, searchableItems(forIdentifiers:), lets apps recover full CSSearchableItem objects by unique identifier so the model receives complete metadata rather than compact index representations, enabling richer reasoning over search results.

SessionsLLM search using Core Spotlight

major

Reality Composer Pro 3

A complete rebuild of Reality Composer Pro, now a standalone app (no longer bundled with Xcode), featuring an AI assistant for 3D model generation, a node-based Script Graph visual scripting system, an Animation Graph state machine, a Behavior Tree editor, Navigation Mesh tooling, a Compute Graph for GPU-driven particle simulation, a Prototypes and Instancing system, Lightmaps baking, a Live Preview mode for connected Apple Vision Pro, and a Plugin Trust Dialog for third-party security.

SessionsKeynotePlatforms State of the UnionBuild next-generation experiences with visionOS 27Iterate your spatial scenes faster with Reality Composer Pro 3Supercharge your spatial workflows with Reality Composer Pro 3Design no-code games with Reality Composer Pro 3

major

Spatial Preview Framework

A new macOS 27 framework that creates a live connection between a Mac app and Apple Vision Pro, enabling real-time streaming and bidirectional editing of spatial photos, Apple Immersive Video, 3D USD scenes, PDFs, and documents. Key APIs include DocumentPreviewSession, USDPreviewSession, ConnectedSpatialEndpointObserver, SpatialPreviewDevicePicker, and support for SharePlay collaboration via CollaborationSupport.

SessionsKeynotePlatforms State of the UnionBuild next-generation experiences with visionOS 27Discover the Spatial Preview frameworkDiscover USDKit and what's new in OpenUSD

major

JavaScript Immersive API for Websites on visionOS

A new web API modeled on the Fullscreen API lets websites call requestImmersive() on an HTML <model> element to place Apple Vision Pro users inside full 3D USDZ environments, supporting video docking onto scene surfaces, video light spill simulation, spatial photos and panoramas, and stereoscopic rendering.

SessionsExplore immersive website environments in visionOSGet started with the HTML Model ElementWhat's new in WebKit for Safari 27

major

RealityKit Lighting Enhancements

RealityKit gains a suite of rendering upgrades: LightmapComponent for precomputed indirect lighting and ambient occlusion, configurable soft shadows via SpotLightComponent.Shadow, projective textures (caustics, window patterns) via SpotLightComponent.ProjectiveTexture, and physical space lighting via SpotLightComponent.SurroundingsLight so virtual lights interact with the real-world environment.

SessionsBuild next-generation experiences with visionOS 27Explore advances in RealityKitIterate your spatial scenes faster with Reality Composer Pro 3

major

RealityKit 3D Gaussian Splat Rendering

RealityKit now supports rendering real-world volumetric captures as 3D Gaussian splats via GaussianSplatResource and GaussianSplatComponent, with per-splat position, scale, rotation, opacity, and spherical harmonics (degrees 0–3) for view-dependent coloring. OpenUSD also gains a new Particle Fields primitive type to standardize Gaussian splats within the USD ecosystem.

SessionsBuild next-generation experiences with visionOS 27Explore advances in RealityKitDiscover USDKit and what's new in OpenUSD

major

Foveated Streaming Framework

Introduced in visionOS 26.4 and fully available in visionOS 27, this framework lets Apple Vision Pro stream immersive OpenXR content wirelessly from a PC or cloud using NVIDIA CloudXR with eye-tracking-based foveated video compression. Key APIs include FoveatedStreamingSession, ImmersiveSpace(foveatedStreaming:), bidirectional message channels, an OpenXR-to-ARKit coordinate frame conversion API, and an open-source TCP-based Foveated Streaming Protocol.

SessionsBuild next-generation experiences with visionOS 27Use foveated streaming to bring immersive content to visionOS

major

ARKit Object Tracking Enhancements and iOS Expansion

Object tracking (previously visionOS-only) is now available on iOS with a platform-agnostic Create ML training workflow. visionOS 27 adds high-frame-rate tracking for moving objects (highFrameRateTrackingEnabled), a Metric Space Pose API providing raw coordinates unaffected by display corrections for precision use cases like surgical navigation, and an updateAccessories(_:) API for swapping tracked accessories without restarting the ARKit session.

SessionsBuild next-generation experiences with visionOS 27Explore enhancements to visionOS object tracking

major

Spatial Accessories API

New APIs allow developers to build and integrate custom electronic accessories using LED constellation tracking, IMU, and Bluetooth that pair with Apple Vision Pro for high-frequency, low-latency spatial input. The API integrates with the Game Controller framework, RealityKit, and ARKit; off-the-shelf reference hardware from DFRobot and MIKROE is available for prototyping.

SessionsBuild next-generation experiences with visionOS 27Explore enhancements to visionOS object tracking

major

USDKit — Swift-native USD Framework

A new first-party system framework giving Swift apps direct access to USD stages, prims, attributes, schemas, and transform operations with deep RealityKit and Spatial Preview integration, including an exportPackage API with mesh compression (developed with the Alliance for Open Media) and AVIF texture compression yielding up to 90% smaller USDZ assets.

SessionsDiscover USDKit and what's new in OpenUSD

major

RealityKit Plugin Architecture for Reality Composer Pro 3

Developers can now build project-specific dynamic library plugins in Xcode using the RealityComposerProPlugin protocol and RealityComposerPro Swift package, enabling custom components editable in the editor UI, custom systems running live in the editor, custom EntityAction animations, and the @Scriptable macro for Script Graph integration.

SessionsExtend Reality Composer Pro 3 functionality with Xcode

notable

RealityKit NavMesh Pathfinding

RealityKit introduces NavigationMeshResource, NavigationComponent, and NavigationController APIs for defining traversable areas, custom movement costs, off-mesh connections (e.g. ladders), and computing paths synchronously or asynchronously — also fully integrated into Reality Composer Pro 3's Navigation Mesh tool.

SessionsBuild next-generation experiences with visionOS 27Explore advances in RealityKitSupercharge your spatial workflows with Reality Composer Pro 3

notable

RealityKit High-Quality Character Rendering

RealityKit adds subsurface scattering for skin and advanced hair shaders (including a dedicated Hair Surface shader node in Shader Graph) for higher-fidelity avatar and character-based experiences, along with PBR Surface 2 adding sheen and more accurate diffuse and occlusion shading.

SessionsBuild next-generation experiences with visionOS 27Explore advances in RealityKitSupercharge your spatial workflows with Reality Composer Pro 3

notable

RealityKit Cloth Simulation

New physics-based cloth simulation via ClothBodyComponent and ClothSimulationComponent enables real-time creasing, folding, collision, and kinematic vertex pinning for realistic fabric in spatial experiences.

SessionsBuild next-generation experiences with visionOS 27Explore advances in RealityKit

notable

Portal Customizations with Custom Materials

Portals in RealityKit now support custom materials for per-pixel opacity control and vertex-animated portal geometry, allowing more creative and tailored portal rendering in mixed reality apps.

SessionsExplore advances in RealityKitSupercharge your spatial workflows with Reality Composer Pro 3

notable

RealityKit ClippingComponent for Interactive 3D Cross-Sections

ClippingComponent (new in visionOS 26) enables interactive cross-sectional plane functionality on 3D models with a three-state machine (off, on, editing) where the editing state surfaces six draggable plane entities for hands-on inspection of complex assemblies.

SessionsCollaborate on structured 3D models in visionOS

notable

High-Quality 4K Capture on Apple Vision Pro

Apple Vision Pro now supports 4K video capture directly from the device without a connected Mac, accessible via a new Control Center option.

SessionsBuild next-generation experiences with visionOS 27

notable

Redesigned Control Center on visionOS 27

visionOS 27 introduces a streamlined Control Center that consolidates notifications, system status, controls, and environment switching in a single location.

SessionsBuild next-generation experiences with visionOS 27

notable

Godot Engine Full visionOS Support

Godot now has full visionOS support with a CompositorServices rendering plugin, a RealityKit rendering plugin, and a PHASE audio plugin for spatial audio, expanding the third-party game engine ecosystem on visionOS.

SessionsBuild next-generation experiences with visionOS 27

notable

RealityKit Mesh Level of Detail (LOD)

LevelOfDetailComponent introduces camera-distance-based and screen-area-based LOD switching strategies, allowing developers to swap entity detail levels dynamically to maintain performance.

SessionsExplore advances in RealityKit

notable

3D Editing in Preview for Mac

The macOS Preview app gains direct 3D scene editing including object manipulation, property and lighting editing, full hierarchy editing, and asset conversion and compression. Preview now ships three renderer options — RealityKit, Storm, and a new high-fidelity Raytracer — all supporting the OpenPBR material standard.

SessionsDiscover USDKit and what's new in OpenUSD

notable

SwiftUSD — Open-Source Swift Package Manager Bindings for OpenUSD

SwiftUSD provides open-source Swift bindings for the full OpenUSD C++ library via Swift Package Manager, targeting developers who need capabilities beyond USDKit or cross-platform workflows.

SessionsDiscover USDKit and what's new in OpenUSD

notable

Immersive Media Support (IMS) Framework

A new framework introduced in visionOS 26 purpose-built for handling Apple Immersive Video metadata, including lens calibration objects, camera IDs, metadata object creation, and preview capabilities for creative workflows.

SessionsBuild live production tools for Apple Immersive Video

notable

Photoreal visionOS Environments for Websites and SharePlay

Developers can now create custom photoreal immersive environments not just for native apps but also for websites and SharePlay experiences, with new end-to-end design guidelines covering pre-production, production, and post-production phases and concrete specs such as a 14,400x7,200px 360° panorama resolution.

SessionsDesign immersive environments for visionOS apps and the spatial web

notable

RealityKit Custom Reverb Mesh

New APIs allow developers to define how sound is absorbed and scattered by materials (wood, metal, stone) in RealityKit, enhancing spatial audio presence and acoustic authenticity in virtual environments.

SessionsBuild next-generation experiences with visionOS 27

notable

USD Annotations and spatialEditable Metadata

A new AppleTextAnnotation USD spec enables collaborative text annotations on 3D models with bidirectional sync between macOS and visionOS, and a new spatialEditable USD metadata flag marks individual prims as user-manipulable in Quick Look on visionOS.

SessionsDiscover the Spatial Preview framework

minor

Volume-Weighted Variance for Assembly Exploded-View Animations

A new algorithmic approach selects the most meaningful axis for exploded-view animations by computing volume-weighted position variance across sub-assemblies, ensuring the expansion axis reflects the most spatially significant dimension.

SessionsCollaborate on structured 3D models in visionOS

minor

Real-Time Shader Techniques Guidance for visionOS Environments

New guidance covers UV flow maps for clouds and vegetation, flip book textures for pre-rendered shadows, layered sine wave vertex animation, and scrolling normal maps for water — providing a budget-conscious toolkit for dynamic environment rendering.

SessionsDesign immersive environments for visionOS apps and the spatial web

minor

Spatial Audio Emitter Placement Guidelines for Environments

New design guidance for positioning spatial audio emitters at specific scene locations (e.g., water sounds tied to visible river areas) to reinforce immersion in custom visionOS environments.

SessionsDesign immersive environments for visionOS apps and the spatial web

minor

Automatic USD Optimization with Opt-Out in Spatial Preview

Spatial Preview automatically applies mesh decimation, texture downsampling, and scene reconstruction for performance; developers can pass the .unmodified parameter to disable this and share the USD stage as-is.

SessionsDiscover the Spatial Preview framework

minor

Session Progress Reporting via ProgressReporter in Spatial Preview

A new session.progress.fractionCompleted API lets developers observe upload or sync progress and surface it in SwiftUI ProgressView overlays.

SessionsDiscover the Spatial Preview framework

minor

Alpha Channel and Depth Buffer Support in Foveated Streamed Frames

The foveated streaming pipeline supports alpha channel compositing and depth buffer data, enabling streamed content to be mixed with physical surroundings and occlude or be occluded by native RealityKit objects.

SessionsUse foveated streaming to bring immersive content to visionOS

major

Game Porting Toolkit 4 with Agentic AI Coding Skills

Game Porting Toolkit 4 (available on GitHub) ships expert and workflow skills for AI coding agents, enabling autonomous discovery, planning, and execution of game ports from D3D12/Windows to Metal/Apple platforms. The update also adds new Metal command-line tools (gpucapture and gpudebug) for GPU frame capture and analysis without the Xcode GUI, plus best-practice guidance and screen-capture comparison against reference frames integrated at every step.

SessionsKeynotePlatforms State of the UnionBringing Cyberpunk 2077 to MacSpeedrun your game port with agentic coding

major

Touch Controller Framework for On-Screen Game Controls

A new Touch Controller framework (TCTouchController) extends GCController support to touch input, letting developers create native-feeling on-screen game controls — including buttons (TCButtonDescriptor), thumbsticks (TCThumbstickDescriptor), and touchpads (TCTouchpadDescriptor) — that appear as standard GCController objects via a unified input API. A nine-anchor flexible layout system integrates with UIKit safe area insets to automatically adapt layouts for Dynamic Island, notches, and varying screen sizes across iPhone and iPad.

SessionsMake your game great with touch

major

Neural Rendering in Metal Shaders via TensorOps and ML Command Encoder

Metal 4 introduces a new ML Command Encoder that runs pre-trained ML models (exported as MTLPackage) inline within a command buffer alongside rendering passes, enabling neural tone mapping and post-processing without CPU round-trips. A new TensorOps API provides cooperative tensor primitives for building and running tiny neural networks (MLPs) directly inside GPU shaders, including support for online per-frame training, with hardware acceleration on the new Neural Accelerator on M5 and A19 Pro GPUs.

SessionsBuild real-time neural rendering pipelines with Metal

major

StateReporting API for Game Performance Correlation

A new StateReporting framework (Swift and Objective-C) lets developers describe game behavior as finite state machines with domains, states, labels, and metadata, enabling direct correlation of Metal performance metrics to runtime game state. It integrates with the Metal Performance HUD, Instruments' Game Performance Overview template, and MetricKit (which now reports per-state frame rate breakdowns on macOS 26 and iOS 26).

SessionsFind and fix performance issues in your Metal games

major

MTLTensor Quantized Data Types and Multi-Plane Support

macOS 26 and iOS 26 add 4-bit and 8-bit integer and floating-point tensor data types to MTLTensor, reducing memory bandwidth and improving throughput for on-device ML inference. A single MTLTensor can now hold both quantized element data and block-wise scale factors as separate planes (MTLTensorAuxiliaryPlaneDescriptor), with native support for the FP8 UE8M0 format to express MXFP8 microscaling quantization used in large models.

SessionsOptimize custom machine learning operations with Metal tensors

major

MetalFX Denoising Enhancements: Transparency Overlay, Denoiser Strength Mask, and Primary Surface Replacement

MetalFX gains three new denoising inputs: a Transparency Overlay Input for compositing noise-free effects (particles, fog, volumetrics) on top of denoised output; a per-pixel Denoiser Strength Mask for fine-grained artistic control over denoising intensity; and a Primary Surface Replacement technique for keeping mirror and glass reflections sharp by storing reflected surface geometry properties as the primary surface input.

SessionsBuild real-time neural rendering pipelines with Metal

notable

Metal Frame Rate Metric in MetricKit

MetricKit on macOS 26 and iOS 26 now includes Metal frame rate information in its daily diagnostic reports, including per-StateReporting-state frame rate breakdowns, enabling field-scale render performance monitoring without a connected Mac.

SessionsMeet the new MetricKitFind and fix performance issues in your Metal games

notable

"For this Mac" Automatic Graphics Preset System

A new device-based graphics preset detects the specific Mac hardware at launch and automatically configures optimal settings — resolution, MetalFX Upscaling, Dynamic Resolution Scaling targets, VSync, and HDR — so players get the best visual fidelity and frame rate without manual tuning. Apple is encouraging all game developers to adopt this pattern.

SessionsBringing Cyberpunk 2077 to Mac

notable

Automatic HDR Calibration via Apple EDR Pipeline

Games can query maximumPotentialExtendedDynamicRangeColorComponentValue to automatically enable HDR and poll maximumExtendedDynamicRangeColorComponentValue to continuously calibrate the tone mapper, eliminating the manual HDR calibration screen traditionally required in games.

SessionsBringing Cyberpunk 2077 to Mac

notable

Custom Metal Kernel Support in Core AI

Developers can author custom GPU operations using Metal 4 and register them as Core AI ops, enabling hardware-accelerated custom compute that integrates seamlessly into Core AI inference graphs.

SessionsMeet Core AI

notable

Metal 4 Explicit Synchronization and Argument Table Patterns

Metal 4 introduces an explicit producer-consumer barrier model (barrierAfterStages with MTL4::VisibilityOptionDevice) and argument-table address binding via IRRootSignatureGetResourceLocations, replacing the broader Metal 3 barrier patterns and manual descriptor offset calculations for more precise GPU synchronization.

SessionsSpeedrun your game port with agentic coding

notable

Cooperative Tensors as Direct Matrix Multiplication Inputs

In macOS 26, cooperative tensors can be passed directly as inputs to matrix multiplication operations without a threadgroup memory round-trip, reducing latency and register pressure. New MSL API methods is_compatible_as_left_input() and is_compatible_as_right_input() let developers verify compatibility before reuse.

SessionsOptimize custom machine learning operations with Metal tensors

notable

TensorOps reduce_rows(), map_iterator(), and execution_simdgroup Additions

The Metal Performance Primitives TensorOps library gains reduce_rows() for row-wise reductions, map_iterator() for mapping between differently shaped tensors (enabling efficient in-kernel SoftMax), and a new execution_simdgroup operation scope for defining custom per-SIMD-group tensor mappings to enable fine-grained tiling strategies such as FlashAttention.

SessionsOptimize custom machine learning operations with Metal tensors

notable

metalperftrace Command-Line Tool for Performance Trace Collection

A new CLI tool (macOS 26) lets developers collect, inspect, and aggregate Metal performance traces from the always-on metrics buffer, supporting lookback collection (hours to days), per-domain StateReporting aggregation, and JSON output for pipeline integration.

SessionsFind and fix performance issues in your Metal games

notable

Control Center Performance Trace Button for iOS

A new iOS 26 workflow lets developers trigger lookback Metal performance trace collection directly from Control Center on a device in the field; after gameplay, tapping the button processes and saves the trace for transfer and analysis in Instruments.

SessionsFind and fix performance issues in your Metal games

notable

Metal HUD MetalFX Diagnostic Extensions

The Metal HUD on macOS 26 gains new runtime displays and overrides for MetalFX Upscaling and Frame Interpolation, including the upscaler's exposure parameter, a jitter scatter plot (with out-of-range jitters highlighted), jitter multiplier overrides, and motion vector scale overrides.

SessionsSpeedrun your game port with agentic coding

notable

MetalFX Frame Interpolation Dedicated Present-Thread Pattern

A new expert skill for MetalFX Frame Interpolation codifies the correct pattern for a dedicated present thread, precise frame-spacing timing, and proper interleaved-frame presentation order — previously undocumented patterns that caused subtle rendering artifacts.

SessionsSpeedrun your game port with agentic coding

minor

Metal Argument Buffers and Indirect Command Buffers in macOS Virtual Machines

macOS virtual machines now support Metal argument buffers and indirect command buffers, enabling more advanced GPU workloads inside virtualized macOS environments.

SessionsExpand the capabilities of your Virtualization app

major

Center Stage Front Camera Hardware on iPhone 17 and iPhone Air

iPhone 17 and iPhone Air introduce a new 18MP front camera with a square sensor, 95-degree field of view, and Center Stage support, delivering multi-frame fused images at Quality prioritization. iOS 26 brings new AVFoundation APIs so third-party apps can fully exploit auto zoom, rotate, and framing capabilities for photos, video recordings, and video calls.

SessionsSupport the Center Stage front camera in your iOS appImplement high resolution photo capture

major

AVCaptureSession Deferred Start API

New in iOS 26, the Deferred Start system allows camera apps to defer initialization of expensive capture outputs (e.g., photo output) until after preview has already started streaming, roughly halving launch time. Developers can opt into automatic mode via the new automaticallyRunsDeferredStart property, or manual mode by calling runDeferredStartWhenNeeded() explicitly; per-output opt-in is controlled via isDeferredStartEnabled on AVCaptureOutput and AVCaptureVideoPreviewLayer, and the new AVCaptureSessionDeferredStartDelegate protocol provides callbacks for preparing resources before and after deferred initialization.

SessionsBuild a responsive camera app that launches quickly

major

RAW 9 Processing Pipeline in Core Image

RAW 9 is a new CoreML-based demosaic-and-denoise pipeline running on the Apple Neural Engine, delivering significantly sharper images, better noise reduction, and more accurate colors. Available in iOS 27, iPadOS 27, macOS 27, and visionOS 27, it is activated by setting CIRAWFilter.decoderVersion = .version9 and supports hundreds of camera models with over-the-air expansion; the new supportedCameraModels(forDecoderVersion:) class method allows apps to query compatibility.

SessionsEnhance RAW image processing with Core Image

major

AVProVideoStorage for High-Bitrate Video Capture

New in iOS 27, AVProVideoStorage provides a system-wide pre-allocated storage pool for high data-rate video codecs like ProRes, eliminating non-deterministic I/O latency caused by file system fragmentation during movie capture. Opt in via new usesProVideoStorage and isProVideoStorageSupported properties on AVCaptureMovieFileOutput (also supported via AVAssetWriter).

SessionsBuild a responsive camera app that launches quickly

major

GenerateIterativeSegmentationRequest (Tap-to-Segment) in Vision

A new Vision framework request lets users interactively segment objects in images using point taps, bounding boxes, lasso strokes, or scribbles, with iterative refinement via addIncludedPoint(). This enables apps to build interactive object selection and cutout features entirely on-device.

SessionsWhat's new in image understanding

notable

48MP Ultra Wide Camera Capture on iPhone 17

iPhone 17 supports 48MP full-sensor-resolution capture on the Ultra Wide camera, expanding high-resolution photography beyond the Main and Telephoto cameras. Developers can target this via AVCapturePhotoOutput maxPhotoDimensions.

SessionsImplement high resolution photo capture

notable

24MP Telephoto Capture on iPhone 16 Pro and Later

24MP multi-frame fused capture is now supported on the Telephoto camera starting with iPhone 16 Pro, extending the high-resolution option to the tele lens for the first time.

SessionsImplement high resolution photo capture

notable

Dynamic Aspect Ratio API for Front Camera

AVCaptureDevice gains a new dynamicAspectRatio property and async setter that lets apps switch between 3x4, 4x3, 9x16, 16x9, and 1x1 aspect ratios seamlessly without rebuilding the capture session, enabled by the square image sensor on iPhone 17, iPhone 17 Pro, and iPhone Air.

SessionsSupport the Center Stage front camera in your iOS app

notable

AVCaptureSmartFramingMonitor

A new AVCaptureSmartFramingMonitor class provides periodic framing recommendations — including suggested aspect ratio and zoom factor — based on automatic face and gaze detection, helping apps intelligently reframe shots for the Center Stage front camera.

SessionsSupport the Center Stage front camera in your iOS app

notable

ImagePlayground API Updates

The ImagePlayground API gains three new capabilities: ImagePlaygroundConcept.drawing(_:) accepts a PKDrawing as a visual concept input; ImagePlaygroundOptions.sizeSpecification adds a .closest(to: CGSize) option for requesting specific aspect ratios; and .personalization = .disabled suppresses people-personalization where not appropriate. The older ImageCreator non-UI API is deprecated in favor of the updated sheet APIs.

SessionsCreate high-quality images using Image Playground

notable

Low-Latency Video Stabilization Mode

AVCaptureConnection.preferredVideoStabilizationMode gains a new .lowLatency option on iOS 26, enabling real-time stabilization optimized for video calls with reduced latency compared to existing cinematic modes.

SessionsSupport the Center Stage front camera in your iOS app

notable

Vision Framework Now Available on watchOS

Vision is now available on watchOS for the first time, including GenerateObjectnessBasedSaliencyImageRequest for identifying and cropping to prominent subjects, enabling features like automatic smart cropping on Apple Watch.

SessionsWhat's new in image understanding

notable

GenerateImageFeaturePrintRequest in Vision

A new Vision API produces a compact FeaturePrintObservation from a CGImage, enabling fast similarity-based image matching inside an app's own catalog for Visual Intelligence queries.

SessionsBest practices for integrating visual intelligence in your app

notable

AVCapturePhotoOutput.cameraSensorOrientationCompensationEnabled

A new property on AVCapturePhotoOutput (iOS 26) automatically compensates for the Center Stage front camera's portrait-mounted sensor orientation, physically rotating HEIC, JPEG, and uncompressed processed photos to match the expected landscape-left orientation of previous iPhone front cameras.

SessionsSupport the Center Stage front camera in your iOS app

notable

AVCapturePhotoOutput.isResponsiveCaptureEnabled

A new property (with companion read-only isResponsiveCaptureSupported) adds buffering between a capture request and processing, so users can take a photo immediately even if photo output initialization has not fully completed during deferred start.

SessionsBuild a responsive camera app that launches quickly

notable

Deferred Photo Processing Extended to Balanced Fast Captures

On iOS 27 with iPhone 16 and iPhone 17, Balanced fast captures are now also processed via deferred photo processing, further minimizing the processing time that blocks the next capture and improving shot-to-shot responsiveness.

SessionsImplement high resolution photo capture

notable

CIImageProcessor Explicit Output Tile Sizes and Temporary Pixel Buffers

A new apply(withTiledExtent:inputs:arguments:) method lets developers specify custom CGRect tile arrays for CIImageProcessorKernel, enabling fine-grained tile size control for performance optimization. A companion output.temporaryPixelBuffer(...) method lets processors request scratch buffers managed by Core Image's cache, automatically recycled to reduce memory pressure in multi-step pipelines.

SessionsEnhance RAW image processing with Core Image

minor

AVCaptureSession.hardwareCost API

A new property returning a 0–1 value representing how much of the device's camera hardware the current session configuration consumes, helping developers detect unsustainable configurations before starting a session.

SessionsBuild a responsive camera app that launches quickly

minor

AVCaptureDevice.systemPressureState KVO for Performance Monitoring

Developers can now observe systemPressureState on AVCaptureDevice via KVO to receive real-time feedback when the device is under thermal or performance pressure, enabling adaptive responses such as reducing frame rate or throttling GPU work.

SessionsBuild a responsive camera app that launches quickly

minor

Deprecated CIRAWFilter Noise Reduction Properties Under RAW 9

colorNoiseReductionAmount, detailAmount, and moireReductionAmount are deprecated under RAW 9 because the CoreML model now handles those tasks internally, simplifying the editing API surface.

SessionsEnhance RAW image processing with Core Image

major

Apple Immersive Video Live Production Pipeline APIs

A suite of new APIs for Apple Immersive Video live production: the IMS framework gains Set Camera Command Overrides in visionOS 27; a new ImmersivePreviewRenderer enables real-time Apple Immersive Video preview on Apple Vision Pro from a Mac during editorial workflows; VideoToolbox gains kVTCompressionPropertyKey_ProjectionKind and kVTProjectionKind_AppleImmersiveVideo for real-time encoding; SMPTE 2110-based live transport is supported for immersive video (ProRes via 2110-22), spatial audio (ASAF via 2110-30), and per-frame JSON metadata (via 2110-41); and AVAssetWriter supports MEBX tracks for per-frame JSON metadata including lens calibrations and motion data.

SessionsBuild next-generation experiences with visionOS 27Build live production tools for Apple Immersive Video

major

Music Understanding Framework

A brand-new Apple framework that performs on-device analysis of audio across six musical dimensions — key, rhythm, structure, pace, instrument activity, and loudness — using a MusicUnderstandingSession initialized with an AVAsset or custom AudioProvider. All signal processing and model inference runs offline and privately on device, returning strongly typed result structs (KeyResult, RhythmResult, StructureResult, PaceResult, InstrumentActivityResult, LoudnessResult) tied to CMTime values, with a real-time AsyncSequence loudness API delivering values every 100ms.

SessionsMeet the Music Understanding framework

major

NowPlaying Swift Framework

A new first-party Swift framework that connects app media playback to system surfaces including Lock Screen, Control Center, Dynamic Island, StandBy, and CarPlay via the MediaSessionRepresentable protocol and MediaSession<T>. It replaces MPNowPlayingInfoCenter and MPRemoteCommandCenter with a Swift-native, @Observable-compatible model, and adds a RemoteMediaSessionExtension extension point for representing playback on external devices (smart speakers, TVs) driven by APNs push notifications.

SessionsMeet the Now Playing framework

major

On-Device Generated Subtitles via Speech-to-Text and Translation Models

iOS 27, macOS 27, tvOS 27, and visionOS 27 introduce on-device AI models that automatically generate subtitles from spoken audio or translate existing subtitles into another language, working for HLS streams, file-based content, and user-created content with no additional implementation required in most cases.

SessionsDiscover generated subtitles and subtitle styles

notable

Custom Reverb Meshes with ReverbMeshResource and Audio.Material

Developers can define custom geometric room shapes and per-material acoustic properties — including frequency-dependent absorption and scattering coefficients — via ReverbMeshResource and Audio.Material, giving precise programmatic control over spatial audio reverb in immersive visionOS spaces.

SessionsExplore advances in RealityKit

notable

MusicKit Catalog and Playback API Updates

MusicKit gains several new APIs: a .musicPicker SwiftUI view modifier for browsing the Apple Music catalog and personal library; a .musicSubscriptionOffer modifier for in-app subscription offer sheets; a .findEquivalents option on MusicCatalogResourceRequest for automatic cross-storefront equivalency resolution; pagination support via hasNextBatch/nextBatch() and item(for:) lookup on MusicCatalogResourceResponse; and ApplicationMusicPlayer.queue and .state are now observable properties for reactive SwiftUI playback UIs.

SessionsIntegrate MusicKit into your app

notable

Subtitle Style Preview and Selection APIs

AVPlayerLayer gains setCaptionPreviewProfileID(_:position:text:) and stopShowingCaptionPreview() for live subtitle style previews during playback; the Media Accessibility framework adds MACaptionAppearanceCopyProfileIDs() and MACaptionAppearanceSetActiveProfileID() for programmatic style profile management; and a new AVLegibleMediaOptionsMenuController provides an embeddable subtitle selection UI for custom player interfaces.

SessionsDiscover generated subtitles and subtitle styles

notable

Media Sharing Extensions for Third-Party Device Routing

A new extension point in the NowPlaying framework lets apps integrate with a unified system device picker to route audio/video to third-party speakers and TVs, eliminating the need to bundle protocol-specific SDKs directly in the app.

SessionsMeet the Now Playing framework

notable

Head-Tracked Spatial Audio via AVAudioEnvironmentNode

Setting AVAudioEnvironmentNode.listenerHeadTrackingEnabled = true in AVAudioEngine enables AirPods head-tracked spatial audio in games with no additional setup, providing positional audio that updates in real time with head movement.

SessionsBringing Cyberpunk 2077 to Mac

notable

ASAF Production Suite Updates

The Apple Spatial Audio Format Production Suite receives new AAX plugins for object positioning relative to reference video, an improved ambisonics workflow, a new Scene Compressor plugin, enhanced heat map drawing tools, and an improved spatial filtering algorithm.

SessionsBuild next-generation experiences with visionOS 27

minor

Wide-Aspect-Ratio Portal Support in AVKit and RealityKit

AVPlayerViewController and RealityKit's VideoPlayerComponent gain custom aspect ratio configuration so apps can maintain very wide portals when transitioning from full immersive to portal mode for Apple Immersive Video content.

SessionsBuild next-generation experiences with visionOS 27

minor

Static Foveation Sample Code for Apple Immersive Video

New Apple sample code demonstrates how to apply a smooth static foveation function before encoding Apple Immersive Video, enabling high-acuity video delivery at practical streaming bandwidths.

SessionsBuild next-generation experiences with visionOS 27

minor

Music Understanding Framework Codable Results and Sample App

All Music Understanding result types conform to Codable, enabling apps to serialize full analysis data to JSON for pre-computation and bundling. Apple also ships the Music Understanding Lab sample app on developer.apple.com that visualizes all six analysis dimensions in real time as a reference implementation.

SessionsMeet the Music Understanding framework

major

HTML <model> Element for 3D/USDZ Content on the Web

The native HTML <model> element for embedding interactive USDZ 3D content ships in visionOS 26 and expands to iOS, iPadOS, and macOS in Safari 27, letting developers render 3D models inline like <video> or <img> without JavaScript libraries. It supports attributes like stagemode="orbit" for touch-driven rotation, entityTransform for programmatic orientation, AR Quick Look via <a rel="ar">, playbackRate and play() for animation control, a ready promise for load state, and a W3C polyfill pattern for cross-browser compatibility.

SessionsDiscover USDKit and what's new in OpenUSDGet started with the HTML Model ElementWhat's new in WebKit for Safari 27Explore immersive website environments in visionOS

major

CSS Grid Lanes for Native Masonry-Style Layouts

A new display: grid-lanes layout mode ships in Safari 26.4, enabling masonry/waterfall-style layouts natively in CSS without JavaScript libraries. It supports full CSS Grid track definitions bidirectionally and includes a flow-tolerance property that controls how strictly the browser enforces shortest-column placement, reducing accessibility issues from visual/tab-order mismatches.

SessionsLearn CSS Grid LanesWhat's new in WebKit for Safari 27

major

Customizable Select Element via appearance: base-select

Safari 27 (and Chrome 135) introduce appearance: base-select, which unlocks full CSS styling of the native <select> element while preserving semantic HTML and accessibility. New affordances include ::picker-icon, ::picker(select), ::checkmark pseudo-elements; the :open pseudo-class; rich HTML (images, SVGs) inside <option>; a <selectedcontent> element to mirror selected option content; a custom <button> as first child; and CSS Grid layout inside the dropdown.

SessionsRediscover the HTML select elementWhat's new in WebKit for Safari 27

major

Safari Web Extension Packager in App Store Connect

Developers can now package, sign, and submit Safari Web Extensions to the App Store directly through App Store Connect — no Mac or Xcode required — using any browser on any OS. Extensions also gain visionOS support, new declarativeNetRequest dynamic rule APIs, scripting.registerContentScripts() with persistAcrossSessions, and native messaging to Swift apps via browser.runtime.sendNativeMessage().

SessionsCreate web extensions for SafariWhat's new in WebKit for Safari 27

notable

Spatial Web Enhancements: Wider Windows and Web Environments by Default

In visionOS 27, Safari windows can be adjusted to wider aspect ratios that naturally curve for comfortable viewing, and Web Environments (website-provided immersive backgrounds) are enabled by default, allowing websites to supply immersive backgrounds just as native apps do.

SessionsBuild next-generation experiences with visionOS 27

notable

Web Immersive API for visionOS (immersivechange, :immersive, document.immersiveEnabled)

New JavaScript properties (document.immersiveEnabled, document.immersiveElement) and an immersivechange event let websites detect and react to immersive state on visionOS; the :immersive CSS pseudo-class allows layout adjustments when a model goes immersive. Safari's browser window also casts shadows onto immersive environment geometry when USDZ environments include shadow-receiving Scene Understanding components.

SessionsExplore immersive website environments in visionOS

notable

Navigation API Shipped in Safari 26

The Navigation API is now available in Safari 26, enabling web apps to intercept and manage navigation transitions programmatically for client-side routing without full page reloads.

SessionsWhat's new in WebKit for Safari 27

notable

Largest Contentful Paint (LCP) Support in Safari 26

Safari 26 adds support for the Largest Contentful Paint performance metric, bringing it in line with other browsers and enabling developers to measure and optimize perceived load speed.

SessionsWhat's new in WebKit for Safari 27

notable

SVG 2 Alignment and 75+ SVG Improvements in WebKit

WebKit delivered over 75 SVG improvements aligned with the SVG 2 specification in this release cycle, significantly improving SVG rendering compatibility across real-world websites. The SVG Working Group has also been revived.

SessionsWhat's new in WebKit for Safari 27

notable

Safari Topics Organization and Notify Me Feature

Safari gains a new Topics-based organization system and a Notify Me feature for timely alerts, improving how users browse and track web content.

SessionsAnnouncing Apple's next big step for Siri and iPhone

notable

Block-in-Inline Layout Engine Rewrite in WebKit

WebKit completely rewrote its block-in-inline layout implementation after over 20 years of technical debt, eliminating a broad class of edge-case layout bugs and improving rendering correctness for real-world websites.

SessionsWhat's new in WebKit for Safari 27

minor

CSS math functions in <img> sizes attribute

Safari 26.4 added support for min(), max(), and clamp() CSS math functions inside the sizes attribute of <img>, giving developers more expressive responsive image size hints.

SessionsWhat's new in WebKit for Safari 27

minor

CSS random() Function Global Scoping Update

Safari 26.5 updated the random() CSS function to align with the latest specification for global scoping, enabling consistent random values shared across elements for design effects.

SessionsWhat's new in WebKit for Safari 27

major

Liquid Glass system-wide design language

A new visual design language applied across iOS, iPadOS, macOS 27, and other platforms featuring adjustable transparency, edge darkening with brighter specular highlights, refraction effects, and a personalization slider in Settings (ultra clear to fully tinted). Controls and buttons in macOS 27 gain a subtle glass bounce effect on click, and sidebars and toolbar items receive automatic Liquid Glass updates without requiring app rebuilds; accessibility adaptations for reduced transparency and increased contrast are applied automatically.

SessionsKeynotePlatforms State of the UnionModernize your AppKit app

notable

Icon Composer updates with refraction and multi-layer Liquid Glass

Icon Composer gains new annotation features, refraction support, and multi-layer Liquid Glass design capabilities, enabling richer app icon creation aligned with the updated visual system. macOS 27 also adds a 'show borders' option for icon design.

SessionsKeynotePlatforms State of the Union

notable

Redesigned search UX patterns for iOS, iPad, and Mac

iOS 26 introduces a bottom toolbar placement for search fields that improves one-handed reachability, animating up over the keyboard when focused. A new 'Prominent' tab style immediately engages search and raises the keyboard (distinct from a tab that navigates to a landing page), and search fields placed in toolbars adopt Glass styling as part of Liquid Glass. Updated guidance for iPad and Mac optimizes placement in trailing toolbars, sidebars, and dedicated search tabs for larger displays.

SessionsDesign intuitive search experiences

notable

Accessibility Reader system tool (iOS 26)

Accessibility Reader is a new system-level tool in iOS 26 that displays text content in a more accessible format. Apps that properly implement accessibility APIs automatically benefit without additional developer work.

SessionsEnhance the accessibility of your reading app

notable

Dynamic Type (Large Text) support on tvOS 27

tvOS 27 introduces system-wide text scaling via Dynamic Type for the first time, allowing users to select their preferred text size. Developers must update apps to use scalable fonts and adaptive layouts to support this new platform capability.

SessionsPrepare your tvOS apps for Dynamic Type

notable

Granular accessibility restrictions API for AEAssessmentConfiguration

Nine new Boolean properties on AEAssessmentConfiguration — including allowsAccessibilityVoiceOver, allowsAccessibilitySwitchControl, and allowsAccessibilityZoom — give exam and assessment apps fine-grained control over which accessibility features remain active during a session, making it easier to support user accommodations without compromising test integrity.

SessionsWhat's new in assessment on macOS

notable

accessibilityDirectTouch() modifier for gesture-heavy SwiftUI controls

A new SwiftUI modifier lets VoiceOver pass touch events directly to a control, with options including .requiresActivation (prevents accidental activation) and .silentOnTouch (suppresses VoiceOver audio so the control's own feedback is heard). This enables accessible interaction with controls that rely on repeated or multi-gesture input such as petting, tapping, or pinching.

SessionsRefine accessibility for custom controls

notable

accessibilityActions() modifier for multi-dimensional SwiftUI controls

A new SwiftUI modifier defines named custom actions (e.g., Move Up, Move Down, Move Left, Move Right), enabling VoiceOver users to navigate 2D controls like equalizer pads that cannot be expressed with a single adjustable axis.

SessionsRefine accessibility for custom controls

notable

Accessibility metadata API in USD (AccessibilityAPI schema)

USD gains a native AccessibilityAPI multi-apply schema for attaching assistive labels and descriptions to 3D objects, with authoring support in Blender and Maya. This lets spatial apps surface meaningful VoiceOver descriptions for USD scene content.

SessionsDiscover USDKit and what's new in OpenUSD

notable

VoiceOver accessibility bridge for PencilKit handwritten content

The new PKStrokeRecognizer APIs can be connected to VoiceOver so handwriting is spoken aloud, and a search() method enables assistive features to locate and navigate to specific words within a drawing, bridging the accessibility gap between handwritten and typed text.

SessionsRead between the strokes with PencilKit

notable

Agent-driven accessibility labeling

Xcode agents can automatically add VoiceOver labels and accessibility identifiers to all interactive elements in a project, and can run this concurrently with other agent tasks such as localization.

SessionsXcode, agents, and you

minor

causesPageTurn accessibility trait for continuous read-all

A new accessibility trait for UIKit and SwiftUI signals to VoiceOver and Speak Screen that reaching the end of a text element should trigger an automatic page turn during read-all gestures, enabling continuous cross-page reading experiences.

SessionsEnhance the accessibility of your reading app

minor

UIAccessibilityCustomAction editCategory for VoiceOver edit rotor

Custom actions can now be categorized under editCategory, surfacing reading-app-specific actions (such as saving a highlighted recommendation) directly within the VoiceOver text selection edit rotor.

SessionsEnhance the accessibility of your reading app

minor

accessibilityActivationPoint() for passthrough gesture positioning

A new SwiftUI modifier sets the precise starting point for VoiceOver passthrough gestures using a UnitPoint, giving developers fine-grained control over where touch events originate on custom controls such as sliders.

SessionsRefine accessibility for custom controls

minor

AccessibilityNotification.Announcement API for dynamic value feedback

Developers can post real-time announcements via AccessibilityNotification.Announcement().post() inside an .onChange() modifier, with guidance to throttle posts to a minimum 0.3-second interval to avoid overwhelming users with audio feedback during continuous input.

SessionsRefine accessibility for custom controls

minor

Sparkle symbol indicator for AI-generated or AI-translated subtitles

The system automatically displays a sparkle indicator in subtitle selection UI when subtitles are AI-generated or AI-translated, giving users a clear signal about the subtitle source.

SessionsDiscover generated subtitles and subtitle styles

minor

New Design Principles page in Human Interface Guidelines

Apple added a dedicated design principles reference page to the Human Interface Guidelines in 2026, providing a canonical resource for the eight core design principles underlying the updated platform design system.

SessionsPrinciples of great design

major

Volume Purchasing via Apple Business and Apple School Manager

Organizations can now purchase and manage App Store subscriptions at scale through Apple Business Manager and Apple School Manager, assigning seats to members via existing device management workflows with no additional developer UI required.

SessionsOffer subscriptions to groups and organizationsWhat's new in managing Apple devices

major

Monthly Subscriptions with 12-Month Commitment Billing Plan

A new billing plan lets customers pay month-to-month while committing to a full year, available on iOS/iPadOS/macOS/tvOS/visionOS 26.4+. Developers configure it in App Store Connect and use new StoreKit APIs (SubscriptionInfo.pricingTerms, BillingPlanType enum, Transaction.commitmentInfo, RenewalInfo.commitmentInfo) to merchandise and track commitment progress; the App Store Server API gains corresponding billingPlanType, renewalBillingPlanType, and commitmentInfo fields in JWSTransaction and JWSRenewalInfo.

SessionsWhat's new in Apple In-App PurchaseExplore Retention Messaging in App Store Connect

major

App Store Product Page Header and Search Results Custom Visuals

Developers can now supply custom images or videos in a new Product Page Header placement at the top of their App Store product page, and can display custom images or videos in search results (tailored per keyword via Custom Product Pages) instead of default screenshots, enabling richer brand storytelling and improved discoverability in both the App Store and the new Apple Games app.

SessionsEnhance your presence on the App StoreUnlock in-game content with StoreKit and Background Assets

major

Retention Messaging for Subscriber Cancellation Flows

Developers can now configure retention messages shown to subscribers during cancellation via App Store Connect (three view formats: message-only, message with image, message with offer) or via a new real-time server-to-server API (https://api.storekit.apple.com/inApps/v1/messaging) that returns personalized messages, promotional offers, or alternate plan suggestions per customer. New sandbox performance-testing endpoints validate server latency before going live, a new offerType 5 distinguishes retention-driven redemptions in transaction history, and a billingPlanType field extends compatibility to monthly 12-month commitment plans.

SessionsExplore Retention Messaging in App Store Connect

major

Group Purchases for Auto-Renewable Subscriptions

Subscribers can now buy multiple seats of a subscription directly in-app and share an invitation link; StoreKit 2 handles seat management including invitation generation, member acceptance tracking, and seat lifecycle management. Developers configure group and volume availability in App Store Connect, can set up to five per-seat price bands for bulk discounts, and can restrict availability to Apple School Manager for verified educational pricing.

SessionsOffer subscriptions to groups and organizations

notable

Asset Library in App Store Connect

A new centralized Asset Library in App Store Connect lets developers manage all visual assets — screenshots, preview videos, in-app event media, and new marketing creative assets — across platforms and placements in one place, with a standalone submission flow that allows approved assets to update product pages and search results in real time without repeated reviews. The App Store Connect API supports uploading and submitting assets to the library, with open-source Swift client libraries available.

SessionsEnhance your presence on the App Store

notable

Subscription Bundles and Suites

New grouping concepts let developers offer bundles (subscriptions purchasable individually or together at a discount) and suites (subscriptions only available as a group), available for testing in Xcode 27 with full details coming later in 2026.

SessionsWhat's new in Apple In-App Purchase

notable

StoreKit Unity Plug-in

A new official Apple Unity plug-in (C# API) bridges native StoreKit APIs, enabling Unity game developers to implement native Apple In-App Purchases without writing native code. Available on GitHub at apple/unityplugins, requires Xcode 27 and Unity 2022 LTS or later.

SessionsUnlock in-game content with StoreKit and Background Assets

notable

Background Assets Unity Plug-in with Localized Asset Packs

A new official Apple Unity plug-in bridges the Background Assets framework for C# code, and iOS/iPadOS/macOS/tvOS/visionOS 26 adds support for language-tagged asset packs so each player automatically receives only the language-specific assets they need (with automatic fallback), significantly reducing download sizes for multilingual games.

SessionsUnlock in-game content with StoreKit and Background Assets

notable

Enhanced App Review Submission Experience

App Store Connect now supports grouping multiple In-App Purchase products alongside in-app events, custom product pages, and page optimizations into a single review submission with a centralized status view, accessible via the new reviewSubmissions and reviewSubmissionItems resources in the App Store Connect API. Existing legacy IAP resources in the App Store Connect API are deprecated in favor of these new resources.

SessionsWhat's new in Apple In-App Purchase

notable

Product Page Preview Tool in App Store Connect

A new tool in App Store Connect lets developers preview exactly how their app's product page will appear on the App Store across iPhone, iPad, different orientations, and multiple languages before going live.

SessionsEnhance your presence on the App Store

notable

Enhanced offerCodeRedemption API

The updated .offerCodeRedemption modifier and UIKit presentOfferCodeRedeemSheet now accept RedeemOption values and return a VerificationResult (Transaction on success or error on failure), providing richer handling across all product types, with extended testing support in Xcode 27.

SessionsWhat's new in Apple In-App Purchase

notable

Apple Ads Platform API Support for New Creative Asset Types

The Apple Ads Platform API gains support for automating ad setup flows using the new creative asset types introduced for product page headers and search results.

SessionsEnhance your presence on the App Store

minor

Redesigned StoreKit Payment Sheet with Landscape Support (iOS 26)

The StoreKit system payment sheet has been redesigned in iOS 26 and now works in landscape orientation, which is important for games and apps that run in landscape-only mode.

SessionsUnlock in-game content with StoreKit and Background Assets

minor

Accessibility Nutrition Labels for tvOS — Larger Text Support

Apps can now indicate support for Larger Text in their Accessibility Nutrition Labels specifically for tvOS App Store listings, helping users discover apps that work well at their preferred text size.

SessionsPrepare your tvOS apps for Dynamic Type

major

Storage system for persisting and syncing shortcut data

A new Storage feature in Shortcuts lets shortcuts save and retrieve typed values (including App Entities) between runs using Get, Set, and Add to List actions, with global values shared across multiple shortcuts. All stored values sync across a user's devices via iCloud, so shortcuts maintain state whether run on iPhone, iPad, or Mac.

SessionsWhat's new in Shortcuts

major

Dynamic Island landscape support with isDynamicIslandLimitedInWidth

In iOS 27, Live Activities are now visible in the Dynamic Island when iPhone is in landscape orientation. A new @Environment value isDynamicIslandLimitedInWidth lets Live Activity views detect when the Dynamic Island is width-constrained in landscape and adapt their compact and minimal presentations accordingly.

SessionsLive Activities essentials

major

Small activity family for Apple Watch Smart Stack and CarPlay Dashboard

The .supplementalActivityFamilies([.small]) modifier and activityFamily environment value allow developers to declare and provide customized Live Activity views for the Apple Watch Smart Stack and CarPlay Dashboard, enabling tailored compact layouts for these surfaces.

SessionsLive Activities essentials

major

Accessory Widget support on visionOS

Apps can now extend to Apple Vision Pro with smaller, glanceable accessory widgets that surface the most relevant information in the spatial environment, expanding the Widgets ecosystem to visionOS.

SessionsBuild next-generation experiences with visionOS 27

notable

systemExtraLargePortrait widget family on macOS, iOS, and iPadOS

A new widget family size, .systemExtraLargePortrait, is now supported on macOS, iOS, and iPadOS. Developers can add it to the .supportedFamilies() modifier to offer a larger portrait-oriented widget layout across platforms.

SessionsWidgetKit foundations

notable

Automations surfaced directly in Shortcuts editor

In iOS 26, automations are now surfaced directly in the Shortcuts editor alongside actions via a dedicated Automation section, making them easier to discover and add without switching contexts.

SessionsWhat's new in Shortcuts

notable

Notification automation trigger with keyword filtering

A new automation type triggers a shortcut when a notification is received from a specific app, with optional keyword-based filtering so only notifications containing specific words (e.g., 'arriving') activate the shortcut.

SessionsWhat's new in Shortcuts

notable

StandBy Live Activity presentation optimizations

The showsWidgetContainerBackground environment value and .activityBackgroundTint modifier let developers provide an edge-to-edge background color when a Live Activity appears in StandBy (iPhone charging in landscape), improving the visual fill for this scaled-up presentation.

SessionsLive Activities essentials

minor

Screenshot automation trigger

A new automation type runs a shortcut automatically whenever a screenshot is saved, enabling screenshot-based workflows without user intervention.

SessionsWhat's new in Shortcuts

minor

Keyboard connection automation trigger

A new automation fires when an external keyboard is connected or disconnected, allowing shortcuts to respond to hardware input changes automatically.

SessionsWhat's new in Shortcuts

major

HealthKit Workout Zones APIs for Completed Workouts

New HKWorkoutZoneGroup and HKWorkoutZoneConfiguration types let developers read structured zone data — including zone boundaries and time spent in each zone — from completed HKWorkout and HKWorkoutActivity objects via the new zoneGroupsByType dictionary. Both heart rate zones and cycling power zones are natively supported, integrating with the Health app's preferred zone settings and syncing across devices.

SessionsDeliver workout insights with HealthKit workout zones

notable

Live Workout Zone Updates via HKLiveWorkoutBuilderDelegate

A new didUpdateWorkoutZone(_:) delegate method delivers real-time HKLiveWorkoutZoneUpdate objects during active workouts, providing the current zone, previous zone, cumulative zone durations, and timestamps so apps can show live zone feedback to users.

SessionsDeliver workout insights with HealthKit workout zones

notable

Preferred Zone Configuration Query API on HKWorkoutBuilder

Apps can query the user's system-calculated or manually configured zones via zoneConfiguration(for:) on HKWorkoutBuilder, enabling personalized guidance without requiring apps to define their own thresholds.

SessionsDeliver workout insights with HealthKit workout zones

notable

Custom Workout Zone Configuration API

A new setCustomZoneConfiguration(_:for:) method on HKWorkoutBuilder allows apps to define app-specific zone boundaries (between 3 and 9 zones) scoped to an individual workout session before data collection begins, without persisting them to HealthKit.

SessionsDeliver workout insights with HealthKit workout zones

major

Trust Insights framework (TrustInsights) for scam coaching detection

iOS 27 introduces the TrustInsights framework, which detects when a user may be coached or coerced by a scammer into performing risky actions. The framework exposes an InsightEvaluator API — developers call requestAuthorization(for:) then requestEvaluation(context:) with one of five InsightContext categories (payment, account, resourceUse, communication, other) and receive an IsLikelyBeingCoachedInsight result with unknown, medium, or high risk levels; apps must call reportConsumption() on each result to avoid rate-limiting. Processing combines on-device and privacy-preserving cloud ML.

SessionsMeet Trust Insights

major

App Attest expanded to macOS 27 with new authenticator data extensions

App Attest is now available on macOS 27, allowing developers to attest Secure Enclave-bound keys and validate that Full Security Mode and System Integrity Protection are enforced. Both attestation and assertion objects in iOS 27 and macOS 27 gain a W3C WebAuthn-compatible extensions structure in authenticator data, carrying three new signals: an ACL Blob OID (Secure Enclave access-control conditions), a Launch Validation Category (detecting TestFlight vs. App Store distribution), and a Bundle Version field for confirming the exact app build running on device.

SessionsSecure your apps with App Attest

major

Declarative App Configuration on macOS 27

Declarative app configuration — previously limited to iOS, iPadOS, and visionOS — comes to macOS 27, enabling secure provisioning of managed apps with credentials, hardware-bound keys, and Managed Device Attestation support for authenticating apps and extensions with enterprise services.

SessionsWhat's new in managing Apple devices

major

Binary Execution Control via Endpoint Security framework on macOS 27

A new declarative app.settings configuration uses the Endpoint Security framework to allow or deny binary execution by flexible code-signing matching rules, and can automatically allow managed apps without requiring explicit rules.

SessionsWhat's new in managing Apple devices

notable

.onToolCall lifecycle modifier in Foundation Models framework

A new DynamicProfile modifier that intercepts tool calls before execution, allowing developers to block or confirm high-risk actions (such as financial transactions) by throwing an error or prompting the user. The tool does not execute until the callback returns, making it a deterministic enforcement checkpoint.

SessionsSecure your app: mitigate risks to agentic features

notable

.historyTransform lifecycle modifier in Foundation Models framework

A new DynamicProfile modifier that transforms session transcript entries before each model inference, enabling spotlighting (tagging untrusted content with delimiters) and PII redaction to prevent data exfiltration. Transformations are scoped to the current inference iteration; @SessionProperty is recommended for persistent expensive transforms.

SessionsSecure your app: mitigate risks to agentic features

notable

Consolidated Privacy Consent Prompt for managed apps

iOS, iPadOS, and macOS 27 introduce a single consolidated prompt shown when a managed app or website first launches, displaying the organization name, admin justification, and all privacy component details (camera, microphone, location) with a single Allow action that applies all defaults without further interruption.

SessionsWhat's new in managing Apple devices

notable

Platform SSO Touch ID requirement on macOS 27

IT administrators can require users to authenticate with Touch ID in addition to their password at login, screen unlock, and FileVault unlock, enforcing a built-in second factor on organization-owned Macs.

SessionsWhat's new in managing Apple devices

notable

Web-based authentication with QR code scanning for Platform SSO on macOS 27

A new secure web view in the login window and screen unlock supports modern authentication flows, conditional prompting, and QR code scanning; the camera runs in an isolated system process and the web page receives only decoded QR data, never raw camera imagery.

SessionsWhat's new in managing Apple devices

notable

Authenticated Guest Mode with FileVault on macOS 27

Authenticated Guest Mode now extends to FileVault-protected Macs, allowing temporary session logins on shared devices (such as in healthcare); the guest user can unlock FileVault with full disk encryption maintained, and local data is automatically removed on sign-out.

SessionsWhat's new in managing Apple devices

notable

Managed Migration declarative configuration

A new declarative configuration enables data migration after enrollment while preserving device management settings; IT admins control which accounts, files, and security/privacy settings are migrated, and Migration Assistant reports declarative management status.

SessionsWhat's new in managing Apple devices

notable

Credential management via declarative assets

Certificates, identities, and passwords can now be managed through declarative configurations instead of configuration profiles, supporting many-to-many relationships so multiple configurations can reference a single credential asset for more efficient lifecycle management.

SessionsWhat's new in managing Apple devices

notable

New declarative status items including Device System Health Monitor

New declarative status items include Lockdown Mode state, current push token, enrollment type, and return-to-service state. iOS/iPadOS 27 adds a Device System Health Monitor that reports hardware component health — baseband, camera, Face ID, and Touch ID — giving IT admins a comprehensive fleet health view.

SessionsWhat's new in managing Apple devices

notable

AEAssessmentConfiguration enhancements for secure testing

New properties in AEAssessmentConfiguration let assessment apps enforce specific system states before a test (requiresSIP, requiresManagedDevice, requiresSingleUser, requiresUserAccountType, allowLockdownMode, allowPrivateRelay), restrict file system access to specific directories via allowedDirectoriesAndFiles, and lock down process execution with allowOnlyParticipantsToRun and allowsUserScriptExecution to block Shortcuts and Automator scripts.

SessionsWhat's new in assessment on macOS

notable

EFI Secure Boot for Linux VMs under Virtualization framework

Linux virtual machines can now be hardened with EFI Secure Boot support, bringing modern boot-security features to Linux guests running under Apple's Virtualization framework.

SessionsExpand the capabilities of your Virtualization app

notable

Offline fraud label submission via Apple Business Register

A new server-to-server API in Apple Business Register lets partners submit delayed fraud labels for transactions later confirmed as fraudulent; labels reference the original TrustInsights insight identifier and must exclude PII.

SessionsMeet Trust Insights

notable

Automatic compromised password updates in iOS 27

iOS 27 introduces one-tap automatic updating of compromised passwords, streamlining password security management for users whose credentials have been identified as compromised.

SessionsAnnouncing Apple's next big step for Siri and iPhone

notable

Apple Intelligence privacy protections for Siri expanded in iOS 27

Expanded privacy safeguards ensure that personal data processed by Siri and Apple Intelligence stays protected on-device, reinforcing Apple's privacy-first AI approach in iOS 27.

SessionsAnnouncing Apple's next big step for Siri and iPhone

minor

Optional host permissions model for browser extensions

Extensions can declare optional_host_permissions in their manifest and request host access at runtime via browser.permissions.request(), giving users fine-grained control over which sites an extension can access.

SessionsCreate web extensions for Safari

major

iOS 27, iPadOS 27, macOS 27, watchOS 27, tvOS 27, visionOS 27

Apple announced the next major versions of all operating systems at WWDC 2026, bringing unified design updates and new platform capabilities across all Apple hardware. macOS 27 requires Apple Silicon, ending support for Intel-based Macs and allowing developers to ship Apple silicon-only binaries on the Mac App Store.

SessionsKeynotePlatforms State of the Union

major

LiveCommunicationKit framework for real-time VoIP apps

A new LiveCommunicationKit framework replaces and extends CallKit patterns with a modern Swift concurrency API built around ConversationManager, typed action classes (JoinConversationAction, StartConversationAction, EndConversationAction, MergeConversationAction, UnmergeConversationAction), a Capabilities model, a Handle type for participant identification, and native multi-party call support. Apps automatically surface conversations on the Lock Screen, Dynamic Island, and Phone app Recents list, giving third-party VoIP apps the same system-level presence as the native Phone app.

SessionsCreate live communication experiences

major

DiskImageKit framework for layered, sparse disk image management

A new DiskImageKit framework (macOS 27) provides high-performance disk image management with support for the Apple Sparse Image Format (ASIF), stacked image architectures with base, cache, and overlay layers, copy-on-write semantics for efficient VM cloning, and multi-VM sharing of read-only layers. It integrates with the Virtualization framework via VZDiskImageStorageDeviceAttachment.

SessionsExpand the capabilities of your Virtualization app

major

Rebuilt MetricKit Swift-first API with StateReporting framework

MetricKit has been rebuilt from the ground up in iOS 27 with a modern Swift API exposing metricReports and diagnosticReports as async streams via MetricManager. A companion StateReporting framework lets apps report named states so metrics can be aggregated per state, with new memory exception diagnostics, a terminationCategory field on crash diagnostics, and per-state MetricReport encoding.

SessionsMeet the new MetricKit

major

PKStrokeRecognizer — on-device handwriting recognition for PencilKit

A new Swift actor PKStrokeRecognizer brings on-device handwriting recognition to PencilKit apps on iOS, iPadOS, macOS, and visionOS 27, supporting 29 languages entirely offline. It exposes recognizedText(), indexableContent, and search(_:) async methods, while companion additions include Bézier path conversion, stable Identifiable stroke IDs, substroke extraction, and programmatic erasing.

SessionsRead between the strokes with PencilKit

major

gRPC Swift package with Swift concurrency runtime

A new modern gRPC Swift package (grpc-swift) provides a safe concurrent runtime built on Swift concurrency with GRPCCore, GRPCClient, and GRPCServer types, already used internally by Apple in Private Cloud Compute, iCloud Keychain, Photos, SharePlay, and the Containerization framework. Companion packages include grpc-swift-nio-transport for HTTP/2 networking via SwiftNIO, grpc-swift-extras for production utilities, and SimpleServiceProtocol for idiomatic server implementation.

SessionsBuild real-time apps and services with gRPC and Swift

major

Virtualization framework enhancements: USB passthrough, custom Virtio devices, iCloud support

macOS 27 adds a new AccessoryAccess framework for USB device passthrough to macOS and Linux VMs, new VZCustomVirtioDevice APIs for implementing custom Virtio 1.4-compliant paravirtualized devices, VZMacGuestProvisioningOptions for automated macOS VM setup, iCloud support within VMs, and advanced vmnet network topologies with port forwarding via new vmnet framework APIs.

SessionsExpand the capabilities of your Virtualization app

major

Container machines in Apple's open-source container tool

Container machines are a new first-class feature of Apple's open-source container tool, providing lightweight persistent Linux environments on Mac with sub-second start times, automatic mirroring of the macOS home directory and user identity, per-machine IP addressing with network isolation, and seamless macOS workflow integration.

SessionsDiscover container machines

major

Bluetooth Channel Sounding distance measurement APIs on iOS 27

iOS 27 introduces Bluetooth Channel Sounding using Bluetooth 6.3 chipsets (available on iPhones with the N1 chip), offering more accurate distance measurement than RSSI without requiring Ultra Wideband. New Core Bluetooth APIs (CBCentralManager.supportsFeatures(.channelSounding), CBPeripheral.startChannelSoundingSession) and Nearby Interaction support via NINearbyAccessoryConfiguration provide distance and horizontal-angle direction with optional camera fusion.

SessionsFind your accessory with Bluetooth Channel Sounding

major

Pass Builder Swift server package and new Wallet pass features

iOS 27 adds a Poster Generic pass style, four new barcode formats (EAN-13, Code 39, Codabar, ITF), and a Featured Actions API for surfacing up to two rich actions on passes. A new open-source Pass Builder Swift package (github.com/apple/pass-builder) provides a type-safe server-side API with PassPackage, PassSigner, and a buildpass CLI, plus Protobuf definitions and Swift-Java interoperability.

SessionsWhat's new in Wallet

major

CarPlay video app support and major API additions

iOS 27 adds a new video app category for CarPlay with CPPlaybackConfiguration for metadata and presentation control, card elements with thumbnails and overlays, a Details Header template, a MiniPlayer for CPNowPlayingTemplate, a Voice Control Template expanded to all app categories, Navigation Panels in CPMapTemplate, and a Route Sharing API for direct vehicle routing coordination (requires iOS 26.4 and supported vehicle).

SessionsRev up your CarPlay app

notable

QUIC transport layer open-sourced via SwiftNIO

Apple is open-sourcing a Swift QUIC transport layer through SwiftNIO, available in late June 2026, enabling the community to build on Apple's production QUIC implementation for high-performance networking.

SessionsPlatforms State of the Union

notable

Subprocess 1.0 and ProgressManager Foundation additions

Subprocess reaches 1.0 with simplified execution types, AsyncBufferSequence for standard output/error, and a strings() method respecting grapheme cluster boundaries. ProgressManager is a new Foundation type redesigned for Swift concurrency that separates progress composition from reporting and supports hierarchical Subprogress operations with type-safe metadata.

SessionsWhat's new in Swift

notable

Official Swift SDK for Android

The new Android Workgroup has released the first official Swift SDK for Android, available at swift.org, enabling developers to build Android applications in Swift.

SessionsWhat's new in Swift

notable

PaperKit available on iOS 27, macOS 27, and visionOS 27

PaperKit canvas APIs are now available across iOS, macOS, and visionOS simultaneously, allowing developers to build canvas-based creative apps with a shared code path.

SessionsUnwrap PaperKit

notable

ARKit object tracking expanded to iOS

ARKit object tracking is now available on iOS via ARWorldTrackingConfiguration, supporting stationary objects via detectionObjects and high-frame-rate moving objects via trackingObjects. Reference objects trained once work on both iOS and visionOS without retraining.

SessionsExplore enhancements to visionOS object tracking

notable

Apple Business Platform expanded to 200+ countries with new MDM APIs

Apple Business Platform is now available in over 200 countries and regions with new APIs for blueprints, user/group management, app licensing, audit events, device inventory, and AppleCare warranty details. New MDM additions include a TriggerEnhancedLogCollection command, declarative Content Caching configuration with HTTPS reporting, Package Management cleanup, Authenticated Guest Mode for Shared iPad, and Guided Browsing in the Classroom app.

SessionsWhat's new in managing Apple devices

notable

Thunderbolt RDMA support for distributed MLX inference (macOS 26.2)

Starting with macOS 26.2, MLX gains Thunderbolt RDMA support for low-latency, high-bandwidth distributed inference across multiple Macs, enabling up to 3x speed-up with four nodes.

SessionsRun local agentic AI on the Mac using MLX

notable

Background Assets integration for on-demand AI model downloading

Core AI integrates with the Background Assets framework to enable on-demand downloading of large AI models, avoiding app bundle bloat while still delivering models to users when needed.

SessionsIntegrate on-device AI models into your app using Core AI

notable

First formal OpenUSD core specification released

The Alliance for OpenUSD released the first formal USD core specification, with domain specs for geometry, materials, and physics in progress, providing the ecosystem a stable interoperability baseline.

SessionsDiscover USDKit and what's new in OpenUSD

notable

SpotlightSearchTool ContactResolver and async search result streaming

A new ContactResolver protocol lets apps supply user identity for natural-language people disambiguation. SpotlightSearchTool exposes a searchResults async sequence streaming batched SearchReply values with a queryToken and a content enum covering items, scoredItems, groupedItems, count, table, statistic, and text result types.

SessionsLLM search using Core Spotlight

notable

Thermal state monitoring for dynamic quality adjustment

Developers can observe ProcessInfo.thermalStateDidChange notifications and read ProcessInfo.thermalState (.nominal, .fair, .serious, .critical) to dynamically degrade rendering quality and prevent CPU/GPU throttling.

SessionsExplore advances in RealityKit

notable

Assessment app input restriction and menu bar control APIs

New allowsMenuBar, allowedMenuBarItems, and allowedAppleMenuItems properties let assessment apps restrict the menu bar to approved items. Four additional properties — allowsDictation, allowsAutoFill, allowsStructuralInput, and allowsEmojiKeyboard — block input assistance during exams.

SessionsWhat's new in assessment on macOS

minor

NSStatusItemExpandedInterfaceDelegate and NSWindow.preventsApplicationTerminationWhenModal

A new NSStatusItemExpandedInterfaceDelegate protocol manages expanded interface sessions for status items with begin/end callbacks and programmatic cancellation. NSWindow.preventsApplicationTerminationWhenModal can now be set to false for sheets that don't require user action, enabling graceful app termination during system reboots.

SessionsModernize your AppKit app

minor

NSWindowDidChangeOcclusionStateNotification for background rendering pause

Games can now observe NSWindowDidChangeOcclusionStateNotification and check NSWindow.occlusionState to pause rendering when the window is hidden, saving CPU and GPU resources during app switching.

SessionsBringing Cyberpunk 2077 to Mac

minor

iCloud Drive cross-platform save continuity for games

Games can integrate iCloud Drive alongside in-house cross-progression solutions to let players transfer save files between Apple devices and other platforms, enabling session continuity across Mac, console, and PC.

SessionsBringing Cyberpunk 2077 to Mac

minor

NISession.updateMotionState API and deviceCapabilities.supportsBluetoothChannelSounding

New updateMotionState(_:forObjectWithToken:) method lets apps inform the Nearby Interaction session whether an accessory is stationary or moving to improve direction accuracy. A new supportsBluetoothChannelSounding capability flag allows runtime feature gating on supported hardware.

SessionsFind your accessory with Bluetooth Channel Sounding