WWDC26: Platforms State of the Union – June 8, 2026 (Transcript)

It even translates the Japanese text and uses all of this context to brainstorm a few options. I’ll choose this one. The intelligence keeps going in a fully interactive tutorial. That’s a quick preview.

New Framework Capabilities

MARY BETH: Let’s talk about the framework. This year, we’re taking the Foundation Models framework to the next level. First, you can use new capabilities like multi-modal prompts with text and images. This opens up new categories of experiences you can build with image understanding. It’s as simple as attaching an image to your prompt.

In addition to this, the Vision framework is now integrated, giving you purpose-built tools the model can use, such as OCR for precise text extraction and barcode readers for quick code scanning, all on-device. Next, let’s talk about server models. On-device models are incredibly useful for many tasks. Yet sometimes, you might want a larger model for a more complex workflow. That’s why we’re extending the framework, so you can easily call server models like Claude, Gemini, and more to use features like tool calling and guided generation.

And any model provider can create a Swift package that conforms to the language model protocol so you can pick the one you want for your app. In addition to this, we’re opening up access for those of you getting started with AI to use the Apple Foundation model running on private cloud compute with no cloud API cost, giving you access to frontier-level intelligence while ensuring your user’s data is not stored or accessible to Apple or anyone else. Your users will have access to features leveraging the cloud model every day, and iCloud Plus subscribers will have expanded access. No matter the model you want to use, you can easily swap it in. This makes the Foundation Models framework the best way to run any large language model in your app.

With more modalities and more models at your fingertips, the next thing you’ll need is more ways to put them to work. That’s why we’re introducing a new open source Swift package, loaded with pre-built tools to help you get started with concepts like skills and utilities for context management. For example, a task management app like Timo can use the package to pull in a skill that adapts its tone and recommendations to the user’s data, delivering a personalized brief to help them stay on top of their day. This space evolves so quickly. Tomorrow’s abstractions may be very different from today’s.

Dynamic Profiles

So these utilities from the open source package are created with new fundamental building blocks called Dynamic Profiles. These are new declarative APIs in the Foundation Models framework for building truly adaptive AI experiences with less code, so you can orchestrate skills and subagents, swap tools in and out, and update instructions on the fly. I’ll walk you through how Dynamic Profiles powers intelligence in the Origami app. First, let’s open Xcode. I’ll start with a language model session, which many of you already use.

Now, instead of creating a session with a fixed model, tools, and instructions, with Dynamic Profiles, you have the freedom to continuously update your session. So I’ll choose a profile for the language model session and start with a familiar Swift Result Builder syntax. Here in the body, I’ll define my first profile as a brainstorming helper that’s going to generate project ideas based on the photos I give it. I’ll add modifiers to use Private Cloud Compute language model with temperature cranked up for creativity. Now, the beauty of a dynamic profile is that this body will always resolve to just one profile driving my session at a time, but I can switch between as many profiles as my feature needs in the same session.

So I’ll change profile based on my app’s state. Then I can add in a second profile to handle tutorial generation. Using Private Cloud Compute again with reasoning level set to deep, since this is my most challenging task. Last, I’ll add in a profile that can explain any origami jargon, like Valley Fold, that the user doesn’t understand. This is a nice smaller task, I can send the on-device system language model to save on server calls.

Let’s see it in action. Here in my tutorial, I can now tap this term I don’t understand, and the on-device model generates a nice explanation. In Dynamic Profiles, I’m swapping out models, but everything shares the same continuous transcript. This means more contextual intelligence with less prompting. Now let’s use that in my tutorial profile.

Instructions and tools can be swapped in and out as well. So I’ll use my app’s view model to check if the tutorial’s been generated. And if so, I’ll add in instructions and tools to help the model give high quality feedback tailored to the user. This body recomputes on every model turn, so my session will stay up to date. Finally, do you see how my three origami profiles look a bit like three AI agents? That’s because Dynamic Profiles are designed to be adaptable building blocks.

So if you want to build AI agents or skills or any other high level abstraction, you can. With a focus on flexibility and composability, these new APIs from the Foundation Models framework are here to grow with you.

Developer Tools and Open Source

To help you bring all of this to your apps, you’ll have access to a complete set of tools, from building to testing to shipping with confidence. That includes the new Evaluations Framework, which gives you the ability to test your prompts and validate that your intelligence-powered features work reliably. The upgraded Foundation Models instrument will help you visualize and debug model behavior in your apps.

And the new FM command line tool lets you prompt the model right from the terminal. And there’s so much more, like a Python SDK, tool calling with images, and a new RAG tool powered by Core Spotlight that’s private to your app. That’s the Foundation Models framework, providing you seamless access to multiple models with all new capabilities in a native Swift API. Plus, we’re doing something big. Later this summer, the framework will be open source, so the same Swift APIs you use in your app can now run on your server too, giving you a complete end-to-end AI workflow anywhere you deploy Swift.

Core AI Framework

RICHARD: You’ve seen how the Foundation Models framework connects the third-party models, private cloud compute, and the on-device model. You have the flexibility you need to get the right model for the job. And when you want to bring a specific model into your app and run it on-device, there’s Core AI. Core AI is a brand new framework built right into the platform, along with supporting tools and technologies. It’s designed to be the best way to bring and run models on-device in your apps.

It delivers uncompromising performance through a modern, memory-safe Swift API, with extensive tuning capabilities, from fine-grained inference management and model specialization to custom GPU kernels. And there are Python-based tools alongside the framework, so you can convert and optimize your PyTorch models for the Core AI runtime. The framework is backed by deep integration into a new developer tool chain, with ahead of time compilation, dedicated Core AI instruments, and a powerful visual debugger to trace tensor values directly back to your original Python source code, and is engineered to scale with your available compute.

So you can run a compact vision model in your iPhone app for real-time camera queries, or deploy a multi-billion parameter LLM in a Mac app right at your desk to power an agentic assistant for complex multi-step workflows. Whatever the device, whatever the model, it all runs on-device with zero server dependencies and zero token costs.

Core AI is optimized for performance on Apple Silicon and powers Apple Intelligence experiences across the system, including Siri.

App Intents Framework

RICHARD: And this year, Apple Intelligence offers even more opportunities for developers. Over to Laurie.

LAURIE: Apple Intelligence draws on personal context from across apps, understands what’s on screen, and can take actions to get things done. Now you can integrate with its capabilities through the App Intents framework. It’s how our platforms understand what your apps can do. With it, you can make your app’s content easier to find and its capabilities easier to use through the action button, shortcuts, widgets, and in Siri AI.

App Intents Schemas make integration with Siri’s capabilities easy. Schemas are recognizable structures that Siri understands deeply, built on years of language model training. We provide entity schemas for describing the content and concepts your app works with, and intent schemas for describing the actions it can perform.

Entity schemas enable personal context understanding. By contributing your app’s content to the Spotlight semantic index, you can help your users find information from your app quickly and easily, with attribution back to your app. The indexing keys for important content properties are built right in, which means more understanding from less code. Siri’s understanding of intent schemas means people can make requests naturally. They don’t need to learn specific phrases, and you don’t have to define them in your code.

App Intents and Siri Integration

Schemas cover common app categories like task management, photo editing, and communication, and include a whole set of system-supported actions. Just adopt the relevant intent schemas for the actions your app can perform to make them available to your users. And because these schemas are system-defined, they’ll benefit from future updates. That means as Siri’s language understanding evolves or as we add new support for languages or regional dialects, your intents will work there too, without any changes to your code. Combining these capabilities with the new View Annotations API will let your users reference and take action on the content in your app when it’s on screen, so your users can interact with your app conversationally, saying what feels natural to them, not commands they have to memorize.

Now, I’m going to show you how we’ve made our Origami app work with Siri. I already have some entities and intents that describe my app’s content and actions and the entities can form to the index entity protocol so they can be indexed into Spotlight. By also conforming to an entity schema, Siri will be able to discover and reason over my app’s content. I’ll make sure my message, contact, and conversation entities all conform to the relevant entity schemas by using the app entity macro. I’m indexing these entities into Spotlight when my app finishes launching to make sure everything’s in sync.

I’ve rebuilt to get the latest changes and now let’s see what I can do, even when I’m not in the app. Hey Siri, who’s coming to Origami Night? Based on your messages in Origami, it looks like Kevin, Marybeth, Rachel, and Richard are discussing Origami Night. What’s Richard bringing? Richard mentioned he is thinking of bringing pizza.

Awesome. But now I want to follow up, which means I need to act on this information. I can make the content Siri found actionable by conforming an intent to the send message schema. This time I’m using the App Intent macro, since this is an action rather than content. I’ll build and run again.

And now I can say, Siri, text Richard, “Can you make one of the pizzas vegetarian?” From Origami. Ready to send it? Yes. It’s sent.

Great, message sent. I’d also like to let people reference what’s on screen in my app just by saying “the second message” or “this photo.” The new View Annotations API lets me associate my views with entities, which can then be passed to my app’s intents, making them actionable. My message list view contains all the individual messages in a conversation. I can use a new view modifier to map each message row to its respective message entity.

Let’s try it out. Hey, Siri, send this photo to Kevin and say, “Rachel got us some paper to practice our folds.” What color would you like? And Siri sends the photo with my message. By combining personal context, common app actions, and on-screen awareness, your app can become part of the intelligent fabric of the system.

Through Siri, users can access it through natural language, discover it through semantic search, and integrate it into their daily workflows.

A Vision for an Intelligent Platform

Now back to Josh. This is our vision for an intelligent platform. Rich, native experiences and intelligent natural language interfaces working together. As app developers, this represents an incredible opportunity.

You can enhance your app’s experiences through natural language with Siri, build powerful AI features with the Foundation Models framework, and even run your own models on device with Core AI. If you’re using a custom model to power a feature within your app, Core AI is the right technology to use. Your models will perform efficiently across all devices, and it’s built into the platform, so your apps always benefit from the latest fixes and enhancements. And if you’re an enthusiast who is experimenting with training, researching, or fine-tuning generative models, or if you’re running a local inference server, our array framework MLX makes it easy to explore cutting edge innovations and technologies. It now supports Metal 4, GPU neural accelerators, and it can even scale training across multiple Macs with RDMA over Thunderbolt.

It’s all open source, and it’s faster than ever. The breadth of capabilities offered by Apple Intelligence and powered by Apple Silicon makes Apple’s platforms the best place to build and deliver the next generation of intelligence-enhanced apps and games.

Platform Foundations and Performance

Now, let’s take a look a level deeper at what makes all of this possible. The systems your apps depend on, from the frameworks you call to the processes that schedule your work, manage your memory, and render your UI. We took an especially close look at the performance and quality of these foundations, and you’ll see a multitude of platform improvements in this year’s releases.

When you rebuild with the new SDK, your apps will launch faster and feel more responsive. You’ll see refinements and platform improvements across frameworks, media, search, and accessibility, enhancements to Swift and SwiftUI, and a lot more, especially around design. Last year, the new design with Liquid Glass brought a unified design language built for a world where your experience moves across devices. The new design is making apps more expressive and delightful while staying instantly familiar to users. It looks great in apps like TideGuide, where subtle interactive highlights respond as users scroll through tide data and charts, and Sketch Pro, where translucent brush panels and controls let artwork show through, even while you switch between tools.

Throughout the last year, we’ve been refining the design, and that journey continues with a new set of design updates in the 27 releases. Apps that have already adopted Liquid Glass benefit from many of these improvements automatically. To tell you more, here’s Cindy.

Liquid Glass Design Updates

In this year’s releases, you’ll see updates to the foundations of how Liquid Glass is built, refinements to the new design that improved consistency, and new ways for iOS apps to adapt across devices and screen sizes. Let’s review the changes you’ll see in your apps.

To maintain exceptional readability, we tuned Liquid Glass so it more effectively diffuses complex content behind it. And to establish more depth and separation, we also introduced a darkened edge along with brighter specular highlights. We also made it more personalizable with a new slider and settings to adjust Liquid Glass anywhere from ultra clear to fully tinted, allowing users to choose the look that works best for them. Apps already using Liquid Glass get these improvements automatically when they run on this year’s releases without even needing to recompile.

Liquid Glass seamlessly adapts to a variety of accessibility settings users may choose, such as reducing transparency or increasing contrast. And now, macOS 27 also supports the Show Borders environment value, just like iOS. So you can adapt your macOS app’s custom controls for this setting as well.

Sidebars expand to the edges on Mac and iPad, providing clearer structure while still refracting content from your app and the wallpaper. And icons in the sidebar regain their color using your app’s accent color, giving your app more personality and making it more clear which window is key. List and label APIs provide these updates automatically and support customizing the tint per item. And every window on macOS now also has the same tighter corner radius, ensuring greater consistency across all apps.

When content scrolls under floating bars, a uniform toolbar appears across the top and keeps the text legible while improving contrast. This effect is applied automatically for standard toolbars and can be customized using the existing Scroll Edge Effect APIs.

We also thought about how icons and menus can be used intentionally to call attention to the most important actions, both on macOS and iPadOS. While icons are hidden by default, there’s an API to show icons for key app actions. We’re also updating how Liquid Glass shows up in icons, making them sharper and more defined. This updated rendering applies to all app icons, and we’ve introduced new features, such as refraction, that can be selectively used for added character. And with Icon Composer, you can now design your icons out of multiple layers of Liquid Glass. It’s been updated with new annotation features to add refraction or dial in Liquid Glass content effects. And it provides an interactive preview of how your icon will look on earlier releases.

Together, these updates culminate in a more focused and approachable experience across your apps and across platforms.

App Adaptability and iOS Resizability

Next, let’s talk about app adaptability. iOS apps show up in more places than ever. On iPad as an iPhone app or on Mac through iPhone Mirroring. When your iOS app shows up in these other contexts with larger displays, users want to be able to take advantage of the extra space to see more information.

So this year we’re introducing support to resize iOS apps in iPhone Mirroring and on iPad. Let’s see how this works with the Origami app. Once you rebuild with the latest SDK, your app is automatically opted into resizability. Since Origami is a SwiftUI app, it’s already taking advantage of scene lifecycle and standard framework support for basic resizability. If you’re already using SwiftUI, auto layout, or responding to size class changes, you are well on your way to supporting full resizability.

If you have custom views, you’ll want to update them to using auto layout and trait collections for layout decisions. Using the new Resizable iOS Simulator and Previews, you can test across a variety of screen sizes right in Xcode, so you’ll see exactly how your layout performs. And we’re providing a skill for coding agents that will help you find and fix common resizability issues.

Now instead of designing for specific devices and orientations, you’re designing for a dynamic range of sizes and aspect ratios. To provide the best experience when using iPhone Mirroring, update your app to be able to adapt and support any size. Resizable Simulator, Previews, and iPhone Mirroring all make it easy to ensure your app is as dynamic and flexible as possible.

SwiftUI: Interactions, Speed, and New Capabilities

Next, let’s talk about SwiftUI. Here’s Frank. SwiftUI is the best way to build apps for any Apple device. We designed SwiftUI to capture everything we know about building great apps on our platforms. It gracefully handles the complexities of layout, animation, and platform integration so you can focus on what makes your app yours. And as new capabilities like Liquid Glass are added, apps get these features easily because they’re designed with SwiftUI in mind.

New apps like Zagot are built with SwiftUI because they want to feel truly at home on Apple platforms. Zagot is a game development environment that brings the open source Godot engine to Apple devices. It started on iPad, expanded to iPhone, and when the time came to bring it to Mac, it felt completely natural. And apps that previously used cross-platform or web technologies like Notion are migrating their user interface to SwiftUI because they want a level of performance and UI consistency that other technologies can’t deliver. With powerful agented coding tools, porting code to Swift has never been easier.

Of course, we reach for SwiftUI ourselves whenever we build apps. For example, SwiftUI made it easy to build the new Siri app by enabling us to share code across all our platforms, and creative studio apps like Logic Pro build new features with SwiftUI for high performance and cross-platform support. Since we rely on SwiftUI ourselves, every improvement we make for our own apps becomes an improvement for your apps too.

And this is a big year for SwiftUI. With richer interactions that help you write less custom code, with speed, making your apps much faster. And finally, with new capabilities for your apps.

# Interactions

This year, SwiftUI brings more dynamic interactions to your app, like reorderable containers, which makes it super easy to add drag to reorder to any container. Building a great reordering experience outside of lists, like with this grid in the Origami app, used to require a lot of code. Now, it is just as simple as adding Reorderable to your ForEach and ReorderContainer to the parents. And just like that, I can customize the order of my origami models. SwiftUI handles the lift and the drop animations, and it works with any container like grids and stacks.

Now, for origami models I feel a little less proud of, SwiftUI now supports Swipe Actions inside any container as well. I can delete a custom row with a swipe by adding the existing Swipe Actions modifier to my row and Swipe Actions container to the scrollable container. This provides great flexibility for quick actions on my custom row. Finally, text selection got more flexible too. On iOS, it gains the same full fidelity selection already found in text field and text editor. And on macOS, it now supports custom text renderers, text vibrancy, and vertical text.

# Speed

Next, let’s take a look at speed. This is always a priority for us, but even more so this year. And you will see many improvements without any changes on your end. To start, we’ve been gradually unifying the architectures of SwiftUI, AppKit, and UIKit. And this year, they share a common foundation across many controls. So wherever your app is running, they can benefit from the same underlying improvements.

For example, menu pickers on macOS are now better equipped to smoothly handle large lists of items. And in nested stack layouts, where SwiftUI used to measure each child multiple times to resolve their flexibility, it now short-circuits computations where they’re not needed. Meaning, layouts now resize up to twice as fast.

And nothing saves performance like avoiding unnecessary work. SwiftUI now only initializes state objects when they’re first loaded. Previously, a new temporary instance of the state object would get created every time the view is reinitialized. You get this improvement for free because state is now lazy under the hood and was converted from a dynamic property to a macro. And when it comes to loading images, Async Image avoids redundancies as well. It now caches its content automatically using standard HTTP caching. So images are downloaded once and only refreshed when needed.

# New Capabilities

Finally, let’s talk about new capabilities, starting with toolbars. With the new resizability features, optimizing your app for a dynamic range of sizes and aspect ratios is more important than ever. And toolbars are central to that experience. This year, SwiftUI gives you final control over how toolbar items adapt to space.

SwiftUI Enhancements and New APIs

Use the new visibility priority modifier to mark your most important items high, and SwiftUI keeps them visible longer as space shrinks. Less prominent actions, like Archive or Delete, can be added to the new Toolbar Overflow Menu container which groups them in an overflow menu. And finally, the new top bar pinned trailing placement anchors items to the trailing edge, no matter how the toolbar reflows. Now, when I resize the window, the toolbar stays organized exactly how I want. Important buttons stay visible, the prioritized ones are in the overflow menu, and share is always pinned to the trailing edge.

Tabs can also be distinguished with the new prominent tab row pinning the tab to the trailing edge of the screen. SwiftUI also opens up new ground for document-based apps with a new document infrastructure that provides a ton of functionality out of the box, like first-class URL access for fully customizable reading and writing to disk. The kind that powers apps like Xcode or Pages. For example, with direct access to the file URL, you now have the flexibility to read just the parts of a file you need and write only the pieces that changed, not the entire file. You can also observe and update document attributes using the provided observable configuration.

The new document API integrates deeply with modern Swift, with support for observation, Swift concurrency, and so much more. Lastly, here’s something pretty awesome. The Spatial Preview Framework gives Mac apps new ways to extend in space around users wearing Apple Vision Pro. When you adopt this new API in your app, a 3D model can become spatial when you stream to Apple Vision Pro, allowing your users to preview, edit, and share objects and models in real time. Beyond those we’ve mentioned already, there are many other new improvements, including better type check and performance with content builders, a new alert binding API, and supports for cross-fade transitions.

Together, these platform improvements bring more speed, richer interactions, and powerful new capabilities to SwiftUI that you can take advantage of.

Swift: Built for Every Layer of the Stack

Now, let’s take a look at Swift itself. Here’s Holly.

HOLLY: Swift is designed to be the language you reach for at every layer of the stack. Whether you’re building full featured mobile apps, internet scale services, or embedded firmware, Swift helps you write code that’s fast, expressive, and safe.

Swift’s performance, depth, and unmatched interoperability make it the natural successor to C and C++ for low-level systems and server programming. And its approachability and expressiveness make it ideal for higher-level development, like apps and frameworks. We think Swift is the only language with this breadth. That’s what makes Swift a language you can keep reaching for as your stack grows, including outside Apple platforms, where the tools for development on Linux, Windows, Android, and the web are available on Swift.org. Many of you are extending your use of Swift to additional platforms and the server, so you can reuse code and benefit from Swift’s high performance across your entire stack.

Like Flighty, which uses Swift in their services to share the code that tracks airport visits between the app and backend. Or GoodNotes, which uses Swift for WebAssembly to bring the app to the web, Chrome OS, Android, and Windows, using over 100,000 lines of code. Or Framio, which uses Swift Java interoperability to share Swift libraries between the iOS app and the photo frame software written in Java. Interoperability means you can bring Swift into C, C++, and Java systems you already have so you can get Swift’s benefits at every layer without a rewrite.

Swift at Every Layer of Apple’s Stack

At Apple, we’ve been building with Swift at every layer of our own stack.

Foundation paved the way for Objective-C frameworks to move to native Swift under the hood. AppKit and UIKit have followed suit by using Swift and SwiftUI extensively in their implementation. WebKit, the open-source web engine that powers Safari, is a large and security-critical C++ codebase. Using Swift’s safe C++ interoperability, WebKit is replacing core components with Swift versions incrementally. In the networking stack, the quick transport layer was rewritten in Swift.

Later this month, the project will be open-sourced and available for cross-platform use through Swift Neo integration. You can follow along or get involved through the vibrant open-source community on Swift.org. Further down the stack, more security and performance critical systems moved to Swift this year. The TrueType font rendering engine replaced decades of hand-optimized C with Swift code that’s not only memory safe, but also faster. At the lowest level, we’ve written hundreds of thousands of lines of Swift code across bare metal firmware, co-processors, and drivers.

For the 27 releases, we’ve started writing parts of the core operating system kernel in Swift. As Swift becomes more capable in these domains, we’re staying true to one of Swift’s most important design goals. It’s fun. It’s natural to write and iterate on your ideas in Swift, and the compiler is there to catch mistakes along the way. The latest updates are focused on improving your workflow, so you can focus on the fun part, writing great code with confidence.

What’s New in Swift 6.4

So 6.4 is here, built to make everyday tasks feel effortless. I’ll show you just a few examples. When your code base is undergoing a migration or incremental adoption of new features, sometimes it’s not realistic to address all compiler warnings across your project at once. You can now suppress warnings in specific parts of your code, and you can promote warnings to errors in places where you want strict enforcement. Availability attributes can get long and repetitive when you’re writing code for multiple Apple platforms.

Now, instead of listing out every Apple platform with the same version number, you can simply write any Apple OS. The limitation on async calls in a defer block is gone, and awaiting inside a defer just works. No matter what you’re building, Swift compiler diagnostics are a daily companion, helping you catch mistakes early and guiding you toward correct code. If you’ve spent time writing Swift code, you’ve probably encountered this error message: “The compiler is unable to type check this expression in reasonable time.”

This can happen in complex operator expressions, closures, or in deeply nested SwiftUI view bodies. This is frustrating, and we’ve made it a lot better. In many common cases, code that hit this fallback error will now either compile successfully or give you a more actionable error to work with. We know this area is important for a smooth workflow, and we’re continuing to invest in it. Swift 6.4 makes you more productive in day-to-day code, and it brings that same care to the more specialized corners of your project.

There’s never been a better time to go full stack with Swift. Now back to Josh.

Platform Improvements and Looking Ahead

JOSH: So those are the platform improvements in this year’s releases. Now, to move ahead, sometimes we have to leave something behind. As we said last year, macOS Tahoe was the final release to support Intel Macs.

The transition of macOS to Apple Silicon is now complete, enabling us to focus on a single architecture across the entire ecosystem. This can benefit your apps as well. You can now ship Apple Silicon-only binaries on the Mac App Store, reducing your app’s download size and letting you focus your testing on a single architecture. And with all the refinements to the new design with Liquid Glass, it’s time to complete your migration there too. We’ll be removing support for opting to use the old design, so once your app is recompiled with Xcode 27, it will automatically begin to use the new design with Liquid Glass.

With so many improvements across the system, your apps and games will look and feel better than ever on this year’s releases.

Intelligence and the Future of Xcode

Now let’s turn to your productivity and the tools you use to build with and for our platforms. Intelligence is deeply transforming how you write code, add new features, and build apps. Last year, we brought AI coding assistance to Xcode, and so many of you embraced it immediately. It’s helping you write code faster and adopt new APIs more easily.

This space moves really fast, so we’ve picked up the pace of our releases, delivering new Xcode capabilities to you faster than ever before. Earlier this year, we brought coding agents to Xcode, along with tools allowing agents to grab a preview, search documentation, and more, powered by the Model Context Protocol. With MCP, Xcode also connects to the tools you already use, from design apps like Figma to services like GitHub. And Xcode includes a built-in integration for agents from Anthropic, OpenAI, and now Google. Today, Xcode adds support for agent-client protocol, so you can bring any compatible agent into Xcode.

ACP support and Gemini integration are shipping in an update to Xcode 26 available today. And there’s more coming in Xcode 27. Here’s Ken.

Xcode 27: A New Daily Experience

KEN: From the first line of code to the App Store, Xcode is where you build the best apps for Apple platforms. Millions of you live in it for writing and debugging your code with coding agents right alongside.

Designing interfaces in SwiftUI and previewing them in real time, testing across devices and simulators to catch issues before your users do, and profiling performance with instruments, keeping your apps fast, responsive, and efficient. This year, Xcode has two big stories. The first is intelligence, and we have a lot to talk about in a minute. The second is the daily experience, how Xcode feels to use.

Now, just like you, we spend hours in Xcode every day. We build all our operating systems and apps with it. In fact, we build Xcode with Xcode. So it needs to feel like home while being fast, fun, and personal. And we’ve heard your feedback and improved Xcode across the board. It’s faster at loading projects.

We fixed top crashes and spins. Debug sessions are more reliable, with faster expression evaluation, and a console that can handle more intensive logging without hitching. Xcode 27 is 30% smaller. Now Apple Silicon only. With agents, documentation, and other components downloading in the background, so you’re always up to date.

Xcode 27: Personalization and Setup

Now, let’s take a look at the experience. First, your Xcode settings are now automatically saved to iCloud. When I’m setting up a new Mac like this, Xcode offers to import them. I’ll pull in the settings from my iMac. I can sign in with my Apple ID, Xcode fills in my GitConfig too. And just like that, I’m ready to code with my new Mac.

Now, let’s create a new project. Watch this, I’ll select new project, then app, and boom! I’m in the editor. No file name, no bundle ID, no setup.

Of course, I can specify all those things later when I’m ready. This is great for exploring an idea, a new API, or prototyping a view. Alright, now I’ll open the Origami project. Xcode 27 looks beautiful with the design refinements of macOS 27, crisp and clean. Let’s customize it.

In Xcode 27, you can make the toolbar your own. It’s easy to rearrange things, so I can add what I need and remove what I don’t. The activity view is now tucked neatly into the document title over here, so there’s even more room for the things I want. The navigation buttons, canvas toggle, editor splits, they’re all right up here in the toolbar. Now I’ll add a shortcut to quickly create a new coding assistant conversation, and that’ll be useful a little bit later.

Themes, Xcode Cloud, and Previews

Next, and super fun, themes. Color now flows throughout the entire app, not just the editor. You can personalize everything from the background to syntax colors and dial in that perfect shade of purple for your keywords. And Xcode 27 comes with gorgeous new choices. Let me show you a few of my favorites.

Emerald, that feels fresh. Can almost smell it. How about something with a little bit more energy? Neon Noir. Electric, love it.

Lighter dark, every theme supports both. Here’s Coral Reef. I feel relaxed already. When I’m working on multiple projects at the same time, I can set a different theme for each. Makes it super easy to tell them apart at a glance.

All right, let’s get back to work. Next, Xcode Cloud, which gives you continuous integration and delivery, built right into Xcode. Now I’ll set up my Origami project to use it. I’ll click Get Started, grant access to my repository, and that’s it. I can kick off my first cloud build.

No App Store Connect setup needed. And Xcode Cloud builds are up to twice as fast, now supporting Apple Vision Pro and apps using Metal on Apple Silicon. Next, previews. They are the best way to iterate on UI and the easiest way to see how your views look across variants, like accessibility sizes, orientations and localizations. And now you can see variations for any property.

I’ll open this view here that shows a craft node. It renders differently based on the craft state enum, which has four different values. Now I can pass that enum to the preview. And just like that, I get a grid showing all the states of my UI, all four in one glance.

Device Hub: Simulator and Hardware, Together

Next, another one I’m excited about. When testing your app, you use real hardware to evaluate performance, use sensors and test real world conditions, and you use simulators to cover older OSes and devices that you don’t have. Xcode 27 brings both together in the new Device Hub. It replaces Simulator, and it does a whole lot more too. Let me show you.

When I first run my app, the window looks like the simulator I know. I can easily rotate, grab a screenshot, and jump back to the home screen, just like I’m used to. When I extend the view, I can now change device properties and test how my app responds to different system settings, like switching to dark mode, increasing the font size, and more. We rebuilt the experience from the ground up for the highest fidelity possible. So I can pinch to zoom, use two finger scrolling, and like in previews, I can dynamically resize the simulator to see how my iOS app handles different sizes.

I can also manage and interact with physical devices from the same place, like this iPhone here on my desk. I’ll launch the Origami app right here from my Mac, and I can interact with it. All the convenience of the simulator with the fidelity of real hardware in a single place. That is a quick look at the experience in Xcode 27. And beyond the experience, the biggest changes this year, the ones that will truly accelerate you, are in intelligence. Kevin, over to you.

Agentic Coding in Xcode 27

What a great time to be a developer. Intelligence is transforming how you build apps. Agentic coding, together with Apple platforms, frameworks, and tools, helps you bring ideas to life. Xcode 27 takes the next big step in agentic coding, leveraging the full power of the best models and agents directly into Xcode. Agents are woven into every layer of the Xcode experience, from the way you interact with them, to a set of tools that help you get the best results.

Tools like understanding your project, searching documentation, building, and testing. And Xcode 27 helps you even more with new tools like rendering previews with variants, interacting with the simulator, localizing your app, debugging, and more. And this goes beyond tools. When using agents in Xcode, every answer is grounded in Swift, SwiftUI, and Apple frameworks. That’s why when building for Apple platforms, Xcode is the best place to code with agents.

Building a Feature: From Idea to Implementation

Let me show you what this looks like across every stage of app development. From starting with an idea, to implementing and validating it, to improving it, like adding new languages or fixing issues. First, I’m going to add something fun to the Origami app. My daughter, she loves making Origami with me. I want to surprise her with a feature that makes up a little choose-your-own-adventure story about the characters that we make together.

I’ll start with a new conversation with the agent. I’ll create one here from the toolbar. It opens right in the editor, just like any other file. Here’s what I want to build. In my Origami project, I want a button that generates a choose your own adventure story for my daughter.

That alone would get me good results, but I had something a little more specific in mind, so I’ll add some more details. She’ll start by picking some options, like the setting and an item to use in the story. The app will generate the first page, and then let her pick what comes next. I want to use the latest Foundation Model APIs and present it with beautiful typography. When using a coding agent, the best results come from collaborating on the implementation and design first, before any code is written.

So I’ll add slash plan to the prompt. And I’m going to ask for a diagram while I’m at it. I find it easier to review the plan that way. Let’s get this started. The agent is exploring my project using Xcode tools to help it efficiently understand my code base, its architecture and patterns, to find the best way to build the feature.

And it’s asking some clarifying questions. Do I want to persist it? Yes. And how many options for the next part of the story? Two to three is good.

And the agent continues to create the plan. Let’s skip forward in time. My plan is now ready and it shows right next to the conversation in beautifully rendered markdown. It’s very easy to review. And I can also refine it.

Here, the current implementation has a fixed set of settings and items to choose. I’d love if she could add her own. I’ll add that as a comment. And now the plan looks good. Let’s kick it off.

Now Xcode and the agent work together to implement the plan. Xcode shows everything that’s changing, like code and previews. As it runs, I can refine the implementation. Like here, I’m going to add a fun image filter to the story’s hero image. It looks like Xcode is done building my feature.

There’s a lot of code and the previews look great. Let’s just run it. I’ll open an Origami project, tap the new toolbar icon, and just like we asked, page one offers an item in a setting. I’ll pick a forest and a wand and, oh, look, there’s the button if I wanted to add my own. And here’s the first page of the story with that gorgeous hero image.

My daughter’s going to love this. What was just an idea a couple minutes ago is now something I can run in my app. This is amazing.

Validating and Testing with Agents

Now, building a feature is more than writing code. It’s also making sure it does what it’s supposed to do. Xcode 27 can help you with that too, with new tools for agents to check their work. For example, agents can validate the logic of your app by running tests, try ideas in isolation using Playgrounds like experimenting with APIs, and check visual changes with previews in light and dark mode, different orientations, text sizes, or localizations. And now agents can interact with your app in the simulator. Let me show you.

I want to test different combinations of settings, items, even customized ones. Xcode launches Origami and Device Hub and starts testing those for me. The agent can tap, swipe, and type. When it’s done, I get a summary of the tests, and I can see all the screenshots it created along the way. And just like that, the Origami app has a new story feature, designed, built, and tested end to end.

Improving Your App with Agentic Coding

Next, let’s see how we can use agentic coding to improve our app. Agents in Xcode can help with all kinds of engineering tasks, like adopting new APIs, making your app more accessible, and more. Let’s localize our Origami app. I’ll start with French. Xcode automatically adds a new language to the strings catalog, then works with the agents to translate strings across the entire project. This is more than a word-for-word translation.

Xcode looks at each string in its context, the surrounding code, UI, the action, to find the best translation. And when it’s done, I can see all the translations here in the string catalog. Let’s build and run. My app is now localized. Fantastique.

Building a great app also means responding to the feedback and data from your users. The organizer already gives you insights into how your app is doing in the real world. Crashes, hangs, performance metrics, anonymized and aggregated. Now you can use agents to help you find issues that matter most and fix them. I’ll ask Xcode to pull up the top crashes from the latest release.

I get a list of crashes ranked by how often they happen. Oh, that first one is from an update I pushed last week. Let’s fix it. Xcode looks at the symbolicated crash log, figures out where in my project this happens, identifies the issue, reproduces the crash, makes the fix, and then validates it. And just like that, our issue is fixed.

That’s agents at work with Xcode across every stage of your development, planning, building, and improving. You’ll be amazed when you see Xcode and agents bring your ideas to life.

Xcode 27: Skills, Specialists, and Plugins

Finally, let’s talk about what makes all of this possible. Xcode 27 ships with the expertise of Apple’s engineers and designers built right in as a corpus of skills, documentation, and MCP tools. Think of them as specialists. A SwiftUI specialist that knows how to structure your view and data flow. An accessibility specialist that knows what makes an interface work for everyone. Specialists for universal sizing, testing, and performance. In fact, so much of what we’ve seen to this point is powered by one of these specialists. And you can bring your own. Xcode integrates all of them in the same way.

Plugins. It’s a format used by many agents and widely adopted by the community. It’s amazing to see how many of these you have already been building and sharing. A plugin can contain skills, just markdown files that teach the agent new tasks. It can contain tools using the model context protocol.

And we’ve added one new capability to plugins. With the agent client protocol, a plugin can bring an agent of your choice. Installing one is easy. You can use the command line or paste a Git URL right into Xcode. And partners like Figma and GitHub make it even easier to set up with just one click.

And then I can put it all together. I can tell Xcode to implement a Figma design in SwiftUI, refine it for different variants, make it resizable using a skill, and post a PR to GitHub. How cool is that? That’s agentic coding in Xcode 27, from an idea to an app at every step, built for how you create, refine, and ship, and reach your users wherever they are. We can’t wait to see what great things you make next.

Developer Tools: Reality Composer Pro, Game Porting Toolkit, and More

Back to you, Josh.

JOSH:

It’s a huge year for Xcode, and for many of our other developer tools as well, like the all-new Reality Composer Pro 3, which has been completely rebuilt for crafting production-ready 3D experiences using RealityKit. It brings support for character animations, more realistic lighting, and live previews that let you see the results of your edits as you make them using Mac Virtual Display. And there’s even more for game developers in this year’s releases, including a major update to Game Porting Toolkit, which dramatically cuts the time it takes to bring games to Apple platforms by adding AI skills for coding agents. And new Metal command line tools give agents direct control during development and debugging, bringing best practices for game development on Apple platforms to every step of your porting journey.

So that’s developer productivity. Across the 2027 releases, there are so many new capabilities to build on, like the App Intents framework, which lets you connect your app to Apple Intelligence, and the Foundation Models framework, and Core AI, which enable you to bring powerful generative intelligence features directly into your apps. There are platform improvements across design, Swift, and SwiftUI that make your apps faster, more flexible, and easier to build. And Xcode has even more expansive support for agentic coding. And we’ve only just scratched the surface.

Sessions, Labs, and Community

There are over a hundred sessions to dive deep into everything we’ve covered today, including Apple Intelligence, Xcode 27, Design, and more. All these sessions are available on the Apple Developer app, the website, YouTube, and new this year on Beely Beely. And there’s so much more happening online throughout the week. Sign up for group labs, online panels, and Q&A sessions with Apple engineers and designers, and connect with us on the Apple Developer Forums to ask questions and follow the conversation about the latest tools and technologies.

And the opportunities to connect extend well beyond this week. You can meet with Apple around the world and online in hands-on workshops, labs, and events to learn and connect as a community throughout the year. We love when we can meet you in person, and there are many opportunities to do that in our Developer Centers, located in Cupertino, Shanghai, Singapore, and Bengaluru. And we’re excited to announce the opening of our fifth this fall in Berlin. Home to one of Europe’s most vibrant developer and designer communities, we can’t wait to see you there or in one of our events online.

Whether this is your first WWDC or your 25th, thank you. Your work inspires and drives us. We use the apps and play the games that you all build. So our greatest hope is that everything we talked about today will enable your next great idea to come to life. We can’t wait to see what you

Related Posts

• Only In America: w/ Jensen Huang on Vision, Risk, and the GPU (Transcript)
• Interview: Elon Musk on SpaceX Plans -June 8, ’26 (Transcript)
• Transcript: Apple WWDC 2026 June 8 Keynote: Siri AI and More
• Elon Musk’s Interview in 2007 with PBS Wired Science (Transcript)
• TRIGGERnometry: w/ Dwarkesh Patel – People Have No Idea What Is About To Happen (Transcript)