WWDC26 Platforms State of the Union: What Apple's New Frameworks Mean for App Developers

Apple has published a 5-minute recap of its WWDC26 Platforms State of the Union, the hour-long technical session that follows the keynote each year and explains what the new features actually mean for people who ship apps. The recap, hosted summary aside, points at a set of changes that genuinely reshape how you build for iOS, iPadOS, macOS, watchOS, and visionOS this cycle.

The State of the Union, presented by Josh Shaffer, Apple's Senior Director of Platform Technologies, with a rotating cast of engineers, is the developer-facing counterpart to the morning keynote. If the keynote is the marketing pitch, this is where Apple shows the APIs, the framework diagrams, and the migration paths. Here is what matters if you maintain apps on Apple's platforms, and how it lines up against what Android developers are seeing.

The Apple Intelligence rebuild, now with Google

The headline for developers is that Apple Intelligence has been rearchitected, and Apple is openly crediting a partnership with Google for part of that work. Practically, this filters down into the Foundation Models framework, which Apple introduced last year as the supported way to call the on-device language model from your own code.

Two additions stand out. First, Foundation Models now accepts image input, so the same framework you used for text generation and structured output can reason over images a user provides. Second, there is now a cloud model option. Last year's framework was strictly on-device, which capped what you could do but kept everything private and free of inference cost. The cloud tier lets you hand off heavier requests when the on-device model is not enough, using Apple's Private Cloud Compute path rather than a third-party endpoint.

For a developer maintaining the same feature on both platforms, this brings Apple's offering closer to the tiered approach Android already uses, where Gemini Nano runs on-device through ML Kit's GenAI APIs and larger requests go to cloud Gemini models. The shapes are converging. You write against a small local model for latency-sensitive and offline work, and you escalate to the cloud for the hard cases.

Core AI: running your own models on-device

The new Core AI framework is the more interesting piece for teams that do not just want Apple's model. Core AI is positioned as the way to run on-device models inside your app, which signals a more general runtime than the fixed Foundation Models endpoint. If you have been shipping models through Core ML and stitching together your own tokenization and sampling, Core AI is meant to collapse that into a supported, higher-level path.

This is the area to watch in the session videos, because the trade-offs are real. On-device inference means no per-request cost and no network dependency, but it also means you are spending the user's battery and competing for the Neural Engine with the system itself. Apple's framing of Core AI alongside Foundation Models suggests they want you to reach for the built-in model first and bring your own only when you have a specific reason.

App Intents keeps expanding

Expanded App Intents support is the quiet workhorse of this release. App Intents is how your app exposes actions to Siri, Shortcuts, Spotlight, and increasingly the system's AI features. Every year Apple widens where those intents surface, and this year is no different. If you have not invested in modeling your app's core actions as intents, the gap between apps that have and apps that have not is widening, because the assistant layer can only act on what you expose.

The Android parallel here is App Actions and the broader intent system, though Apple's App Intents is more tightly coupled to its assistant story. If you are building cross-platform, the practical advice is the same on both sides: define your domain actions in a structured, machine-readable way and you get assistant integration close to free.

Liquid Glass and SwiftUI

On the UI side, Apple covered the revamped Liquid Glass design language and a batch of SwiftUI improvements. Liquid Glass is the visual refresh threading through this year's releases, and the State of the Union is where Apple explains how to adopt it without rebuilding your interface from scratch. Expect the usual pattern: standard SwiftUI and UIKit controls pick up the new look automatically when you build against the new SDK, while custom-drawn UI needs manual attention to match.

The migration cost is worth budgeting for. Apps that lean on system controls will mostly come along for free. Apps with heavily custom interfaces, the kind that ignored Dynamic Type or hardcoded materials, are the ones that will look out of place and need real work.

Xcode 27 and agentic coding, including Google's agents

Xcode 27 leans further into agentic coding, and the notable detail is that it now supports coding agents from Google, not just Apple's own. This continues the direction Xcode 26 started, where the editor gained model-backed assistance. Opening it up to third-party agents, with Google named explicitly, is a meaningful shift for a tool that has historically been a closed garden.

For a working developer, this means your in-editor assistant is becoming a choice rather than a fixed feature. The trade-offs mirror the broader agentic coding debate: these agents are good at boilerplate, refactors, and test scaffolding, and they still need careful review on anything touching architecture or security. The integration matters more than the model, because an agent that can see your build errors, run your tests, and edit across files is far more useful than a chat window bolted on the side.

Where to go deeper

Apple has added more than 100 session videos to the Apple Developer YouTube channel and the Developer app, covering Apple Intelligence, Core AI, the Foundation Models framework, SwiftUI, visionOS, App Intents, Xcode 27, and the new Device Hub. The 5-minute recap is a fine orientation, but the framework-specific sessions are where the migration details live, and those details are what determine how much of your summer is spent on this transition.

The through-line this year is consolidation around on-device and cloud AI as a first-class part of the SDK, paired with an unusually open posture toward Google across both the intelligence stack and the development tools. For anyone maintaining the same app on iOS and Android, the two platforms are starting to ask you to think about AI features in remarkably similar terms, which is a welcome change from building everything twice.