– English Lyrics

Lyrics & Translation

[English]

Welcome to the 2026 Platforms State of the Union.

This is one of our favorite moments of the year where we get to share what's new

with the technologies, the frameworks, and the tools that you use every day

to build incredible apps and games.

Apps that inspire us, that raise the bar of what's possible

and that push us to build even better technologies.

We love connecting with so many of you.

Hearing about your passions, your challenges,

and how we can better support your work.

Your feedback shapes some of the most important technologies that we build.

And this past year, nowhere was that more true than with the new design

with Liquid Glass and with Apple Intelligence.

These were both huge themes in the 26 releases, and they're key again this year,

with many of our efforts influenced by your feedback.

Design and intelligence are both so important because they enhance

what's special about your apps.

The care and the craft that you put into them.

With unique interfaces and rich experiences

shaped by your deep domain expertise.

Combined with enhanced intelligence capabilities, you can now build features

that weren't previously possible.

To highlight what's new, we'll dive into three key areas.

First, Apple Intelligence, with new ways to bring generative intelligence

directly into your apps, and new integrations

with system intelligence to bring users back to your apps.

Second, platform improvements, with design refinements and more flexible UI layout,

updates to Swift and SwiftUI, and enhancements that make your apps faster,

more adaptive, and easier to build.

And finally, developer productivity, taking agentic coding even further,

alongside improvements that make Xcode faster and more personal.

We have a lot to cover, so let's get started with Apple Intelligence.

At the heart of Apple Intelligence are Apple Foundation models.

Working together with Google and leveraging the technologies

behind their Gemini family of models,

we created the latest Apple Foundation models

to power our Apple Intelligence experiences and toprovide even better support

for the ways you're using intelligence in your apps.

We adapted these models to run on device and on Private Cloud Compute.

Apple Foundation Models power Apple intelligence, and your apps can use them

too, through the Foundation Models framework.

This year, the framework's capabilities are expanding to include image input and

support for server models.

So if you have a more complex task

requiring the most advanced frontier models

the API can now integrate with the cloud model provider of your choice.

To ensure getting started with a large cloud model is as accessible as possible,

even if you're writing your first app,

developers with fewer than 2 million first-time App Store downloads

will be able to use Apple Foundation Models

running in Private Cloud Compute with no cloud API cost.

It's access to frontier level intelligence with unparalleled privacy protections.

Because getting started exploring ideas

shouldn't be held back by infrastructure costs.

With these enhancements, the Foundation Models framework now offers a single API

that supports any model you need.

In addition to features you build within your apps, Apple Intelligence can also

surface your app in more places across the system,

giving users more ways to discover and return to it.

The App Intents framework connects your app to Apple Intelligence,

drawing on core operating system technologies,

like the Spotlight semantic index.

It organizes and surfaces personal context from any supported app.

The app toolbox, which identifies features

available across apps to serve a user request.

And the system orchestrator, which coordinates it all

while protecting user privacy.

Together, in-app and system-wide intelligence unlock experiences that

neither could deliver alone.

Your apps made more powerful by intelligence.

And intelligence made more meaningful by your apps.

Let's dive into these frameworks and see how they'll transform

what your apps can do.

Here's Richard and Mary Beth.

The Foundation Models framework is a native Swift API

that gives you direct access

to the same on-device model that powers Apple intelligence.

And many of you have already adopted it, creating experiences for shopping apps

like Wayfair, educational apps like CellWalk,

local sports apps like CricHeroes and more,

all running on device with no infrastructure costs

or privacy trade-offs.

It's amazing to see how you've pushed the limits of what an on-device model can do.

We've got exciting updates for you.

Let's start with a preview of the intelligence-powered features

you will be able to build today.

Mary Beth, over to you.

This year, we're building a sample app all about the Japanese paper craft of origami.

It's a place to unwind and get creative with paper.

I'll give you a quick tour.

Our app starts with a beautiful gallery of my origami projects.

And what's special about these is that I've used foundation models

to tailor origami projects to match a person's interests and materials

with step-by-step feedback.

Of course, it's more fun to craft with friends.

So our app has a built-in chat.

It's a fun focused place to plan meetups and talk about crafting.

Now I'm working on a cool feature to combine people's interests

into an origami project.

Here, I'll take this paper Rachel's bringing and mix in a photo of my dog

to generate a fun project for us all to fold together.

With Foundation Models framework, my app analyzes the inspiration pictures

to get a sense of the materials I have and this dog theme I have in mind.

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.

Let's talk about the framework.

This year, we're taking the Foundation Models framework

to the next level.

First, you get new capabilities like multimodal 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+ 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 Tiimo 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.

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 sub-agents,

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 LanguageModelSession, 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 LanguageModelSession

and start with the 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 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 explains any origami jargon, like "valley fold",

that the user doesn't understand.

This is a nice smaller task.

I can send the on-device SystemLanguageModel

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 the focus of flexibility and composability, these new APIs

from the Foundation Models framework are here to grow with you.

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 the 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.

You've seen how the Foundation Models framework connects to 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 interest 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 toolchain,

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 it's 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 it empowers Apple Intelligence experiences

across the system, including Siri.

And this year, Apple Intelligence offers even more opportunities for developers.

Over to Lori.

Apple Intelligence draws on personal context from across apps,

understands what's on screen, and can take actions to get things done.

And 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.

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 conform to the IndexedEntity 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 @AppEntity 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?

Siri: Based on your messages in Origami, it looks like Kevin, Mary Beth, Rachel,

and Richard are discussing origami night.

What's Richard bringing?

Siri: 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 sendMessage schema.

This time I'm using the @AppIntent 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?"

Siri: From Origami: Ready to send it?

Yes.

Siri: 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 MessageEntity.

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?"

Siri: From Origami: Ready to send it?

Yes.

Siri: It's sent.

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.

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.

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 Tide Guide, where subtle, interactive highlights

respond as users scroll through tide data and charts.

And SketchPro, 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.

In this year's releases, you'll see updates to the foundations

of how Liquid Glass is built, refinements to the new design

that improve 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 in 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.

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 in to 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.

Next, let's talk about SwiftUI.

Here's Franck.

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 The Goat are built with SwiftUI

because they want to feel truly at home on Apple platforms.

The Goat 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 agentic 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 a new Siri app by enabling us

to share code across all our platforms and Creator 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.

Let's start with 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 grid 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 parent.

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 .swipeActions() modifier to my row

and .swipeActionsContainer() 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 TextField and TextEditor.

And on macOS, it now supports custom text renderers, text vibrancy,

and vertical text.

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 on-the-line improvements.

For example, menu pickers on macOS

are now better equipped to smoothly handle large lists of items.

And in nested stack layouts,

whereas 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, AsyncImage avoids redundancies as well.

It now caches its content automatically using standard HTTP caching,

so images are downloaded once and only re-fetched when needed.

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 finer control over how toolbar items adapt to space.

Use the new visibilityPriority 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 toolbars overflow menu container, which groups them in an overflow menu.

And finally, the new topBarPinnedTrailing 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.

Deprioritized 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 role

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 is 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 checking performance with content builders,

a new alert binding API, and to support adjusting cross-fade transitions.

Together, these platform improvements bring more speed, richer interactions, and

powerful new capabilities to SwiftUI that you can take advantage of.

Now, let's take a look at Swift itself.

Here's 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, reusing over 100,000 lines of code.

Or Frameo, which uses Swift-Java interoperability to share Swift libraries

between the iOS app and the PhotoFrame 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.

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++ code base.

Using Swift's safe C++ interoperability, WebKit is replacing core components

with Swift versions incrementally.

In the networking stack, the QUIC transport layer was rewritten in Swift.

Later this month, the project will be open sourced and available

for cross-platform use hrough SwiftNIO 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, coprocessors, 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.

Swift 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 'anyAppleOS'.

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's 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.

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.

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.

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.

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 Git config 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 on 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.

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.

You can almost smell it.

How about something with a little bit more energy?

Neon Noir. Electric. Love it.

Light or dark? Every theme supports both.

Here's Coral Reef. I feel relaxed already.

And 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.

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 note.

It renders differently based on the CraftState 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.

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.

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, in Apple frameworks.

That's why, when building for Apple platforms,

Xcode is the best place to code with agents.

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 gonna 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 Models 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 /plan to the prompt.

And I'm gonna 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 gonna add a fun image filter to the story's hero image.

It looks like Xcode is done building my feature.

There's still 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 and 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 gonna love this.

What was just an idea a couple minutes ago is now something I can run in my app.

This is amazing!

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.

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.

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!

Back to you, 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.

There are over 100 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 Bilibili.

And there's so much more happening online throughout the week.

Sign up for Group Labs, online panels, and Q 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 do next.

Enjoy WWDC.

Key Vocabulary

Vocabulary	Meanings
incredible /ɪnˈkrɛdəbl/ B2	adjective - impossible or very difficult to believe; extraordinary
inspire /ɪnˈspaɪər/ B2	verb - to fill someone with the urge or ability to do or feel something
feedback /ˈfiːdbæk/ B1	noun - information about reactions to a product or a person's performance
intelligence /ɪnˈtɛlɪdʒəns/ B2	noun - the ability to acquire and apply knowledge and skills
enhance /ɪnˈhæns/ B2	verb - to intensify, increase, or further improve the quality of something
expertise /ˌɛkspɜːrˈtiːz/ C1	noun - expert skill or knowledge in a particular field
generative /ˈdʒɛnərətɪv/ C2	adjective - relating to or capable of production or creation
flexible /ˈflɛksəbl/ B1	adjective - capable of bending easily; ready to change
productivity /ˌprɒdʌkˈtɪvəti/ B2	noun - the state or quality of being productive
leveraging /ˈliːvərɪdʒɪŋ/ C1	verb - to use something to maximum advantage
infrastructure /ˈɪnfrəˌstrʌktʃər/ B2	noun - the basic physical and organizational structures
unparalleled /ʌnˈpærəlɛld/ C2	adjective - having no equal; exceptional
privacy /ˈpraɪvəsi/ B1	noun - the state of being free from public attention
orchestrate /ˈɔːrkɪstreɪt/ C2	verb - to arrange or direct elements to achieve a desired effect
transform /trænsˈfɔːrm/ B2	verb - to make a thorough or dramatic change

Key Grammar Structures

• These were both huge themes in the 26 releases, and they're key again this year, with many of our efforts influenced by your feedback.

  ➔ Past Participle Phrase (Reduced Relative Clause)

  ➔ The phrase "influenced by your feedback" modifies "efforts," acting as a passive construction.

• If you have a more complex task requiring the most advanced frontier models, the API can now integrate with the cloud model provider of your choice.

  ➔ First Conditional with Participial Phrase

  ➔ The "requiring..." phrase functions as an adjective modifying "task," explaining its nature within the conditional "if" clause.

• Developers with fewer than 2 million first-time App Store downloads will be able to use Apple Foundation Models running in Private Cloud Compute with no cloud API cost.

  ➔ Future Simple (Prediction/Ability) + Prepositional Phrase

  ➔ The phrase "with no cloud API cost" is a prepositional phrase providing additional detail about the conditions of the ability.

• It organizes and surfaces personal context from any supported app.

  ➔ Subject-Verb-Object (SVO) Structure with Transitive Verbs

  ➔ "Organizes" and "surfaces" are transitive verbs requiring the object "personal context" to complete their meaning.

• Because getting started exploring ideas shouldn't be held back by infrastructure costs.

  ➔ Passive Voice with Gerund Subject

  ➔ The gerund phrase "getting started exploring ideas" acts as the subject, modified by the passive construction "shouldn't be held back."

• You can pick the one you want for your app.

  ➔ Relative Clause (Reduced)

  ➔ The clause "(that/which) you want" functions as a relative clause identifying "the one."

• This makes the Foundation Models framework the best way to run any large language model in your app.

  ➔ Complex Object Structure

  ➔ The structure uses "makes" + [object] + [object complement], where the framework is being defined as the best way.

• Because getting started exploring ideas shouldn't be held back by infrastructure costs.

  ➔ Modal Verb in Passive Voice

  ➔ The modal "shouldn't" expresses a recommendation or expectation about the state of affairs, combined with "be held back" for passive.