Discover what’s next: The biggest updates from WWDC26 | Meet with Apple

Good morning. [applause]

Oh, this is fun. [applause]

All right. Well, welcome everybody here.

Uh whether you're joining us here in Certino, it's so great to have you all here in the room with us. Or to

everybody watching online, we often have folks from over 100 countries joining us for our live events out of uh here in the developer center here in Certino.

Maybe we could give a round of applause for all of our friends joining us from all around the world today as well.

[applause] ALL RIGHT. UH, my name is Josh Tidsbury

ALL RIGHT. UH, my name is Josh Tidsbury and I'm part of our technology evangelism team uh, here at Apple. So,

our team and pretty much everyone you'll hear from today, well, we're all here to support you in bringing your ideas and all of your creativity and create the absolute best apps you can for Apple

platforms. So, today is a recap of the announcements from WC26 and it's a big year with over a 100 sessions. And if

you're anything like me, you've actually not managed to watch all 100 of them yet. Has anybody in the audience

yet. Has anybody in the audience actually watched all 100 video? Okay, we

need to have a conversation. [laughter]

And maybe I can find some swag for you, too. All right, maybe you watched a

too. All right, maybe you watched a handful of them or maybe you're new to our platforms and you're vibe coding your first app and just trying to decide where to get started. No matter where

you are in your journey, this day is for you and we hope you get a lot out of it.

One of the most important things in this age of AI is really understand the opportunities and capabilities that you can bring to your projects and so you can approach those with a really clear vision. We're going to touch on things

vision. We're going to touch on things at a high level so that you know where everything is, how it fits together, and that you leave here feeling like you know that you have everything you need to figure out what you're going to do

next.

This is all of the sessions from this year and it's a lot. But the story that's really underlying all of this is how all of these pieces come together in

a truly seamless way.

As we take a look across the industry, the AI story is often really complicated with various components coming from different companies and providers and you are all left to figure out how to

put those pieces together. It's a lot of complexity before you get to the good part. building something that people

part. building something that people love. And this just isn't the story that

love. And this just isn't the story that we want for you. At Apple, AI is just not a layer that you bolt on. It's fully

integrated into our platforms. From the silicon runs it, the OS that integrates it, the frameworks and models that enable it, and the tools that help you

create with it. These were all designed to work seamlessly together. And when

one of these gets more capable, the pieces next to it are already built to take advantage of these capabilities. So

here's some of the big focus areas from this year. And we'll start with where a

this year. And we'll start with where a lot of the energy was intelligence.

So the headline isn't just that there's a model now. It's that you can access all of these models now from a single front door from ondevice intelligence.

It's private, works offline, there's no inference bill, and it's fast because it's running on Apple silicon that's built just for this purpose. Private

cloud compute when you need to reach for something heavier without giving up that privacy or any other model you like, including cloud-based frontier models or

your own models running on device.

It's one common API, the foundation models framework, and it allows you to point basically the same code at whichever model you want, and you get to

decide what fits. And this year, this framework will also be open- source. So

the same Swift APIs that you're using in your app can now also be running on your server. You can have an endto-end AI

server. You can have an endto-end AI workflow anywhere that you deploy Swift.

And for folks who are digging into custom models, MLX is right there for you, ready and waiting when you need it.

And then there's how your app integrates with the system.

Intelligence sitting inside of your app is its potential. But what turns it into something that people reach for more easily is that the system can now know

what your app can do. This is what app intents are for. So you describe your app's capabilities using app intents and then the system does the surfacing.

Siri, spotlight, the places where people already are before they actually think to open up your app. So the ondevice models that we were talking about a moment ago, they're not trapped behind

your launch screen. They become

something that a user now discovers at exactly the right moment.

And then there's adaptable. how your

appears and behaves on different devices and platforms and matches the people that are using your app.

So this year or sorry last year we introduced liquid glass a new material and design language across our platforms and this year it evolves. The

foundations are refined for more for better readability and more depth and more consistent across devices. And now

it's something that users can personalize from completely clear to fully tinted. And here's the part that

fully tinted. And here's the part that probably matters for many of you. If

you've already done the work to adopt liquid glass, your app will pick up these refinements automatically on this year's releases.

But this year, we've also now introduced iPhone app resizability. And this

matters a lot. Your app shows up in a lot of different ways, different sizes, side by side, on external displays. But

now, iPhone apps are completely resizable on iPad OS and running through iPhone mirroring on the Mac. So, your

app can no longer just assume a single fixed size. Universal resizability is

fixed size. Universal resizability is what makes this graceful. One app that adapts to whatever canvas it's given.

And the frameworks do so much of this work for you.

Ondevice intelligence surfaced by the system and arriving in an interface that adapts itself. This is a lot of

adapts itself. This is a lot of capability for you all to take advantage of, which is why the tools story matters so much this year and how it becomes so

much easier to build and maintain going forward. Xcode27's agentic coding is all

forward. Xcode27's agentic coding is all about the tools becoming your collaborator using your model of choice.

a collaborator that can see across your whole project, access the suite of tools, understand the latest updates to frameworks and APIs, and offer a truly integrated experience when you're

developing for Apple platforms. So, the idea here is that you spend less time telling the agents what you're looking at, and way more time just feeling like you're working alongside the agents as

your partner and your teammate.

So you've made something that's intelligent integrated adaptive and the last step is the one that the whole journey is building towards getting your

app into people's hands.

So that's the app store getting discovered, reaching the right customers. It's where the lines of code

customers. It's where the lines of code that you started with become an app that the world uses and loves. And there's a lot of great improvements this year to help you get there.

That's already a lot of great stuff and it's just a quick throughine. Here are

some others that we want to make sure you're aware of these areas so you can dig into them. We'll we'll we'll be going into specifics later. So there's a whole lot of sessions on spatial

computing and what's new in real or vision OS 27 including this is a really big year for reality composer pro. It's

a visual editor that allows you to build 3D scenes, materials, and interactivity.

And it goes further this year with nodebased tools for authoring animations, particle effects, and behaviors right in the editor.

If you happen to be building games, there's this really great story about how the team from CD Project Red brought their game Cyberpunk 2077 to the Mac.

And there's Game Porting Toolkit 4, where Agentic Coding reduces what used to be months of manual porting to just a fraction of that time.

WebKit got a lot of updates this year from grid lanes to customizable select HTML model, immersive environments, and the latest for web extensions.

And then there's more great stuff.

Cameras and photos on audio and accessibility. So the videos and docs

accessibility. So the videos and docs for all of these areas are ready and waiting for you. Even though we're not going to have time to dig into everything today, we only have a short time with you all.

So with that overview, here are the five threads that now we're going to dig deep into. Intelligent, integrated,

into. Intelligent, integrated, adaptable, agentic, and discoverable.

Each of these is now going to get its own deep dive. Now, with a year that's this big, not all of this might be equally important to you, and what matters most really depends on what you're building and what your individual

goals are. So as we go along today, our

goals are. So as we go along today, our hope is that you get a feel for which of these threads matters most for the apps that you're working on and where to take

things next. So let's get started with

things next. So let's get started with intelligent. Shashank, over to you.

intelligent. Shashank, over to you.

Thank you Josh. [applause]

Hey everyone, I'm Shashank. I'm part of the technologies evangelism team here at Apple. And in this intelligence section,

Apple. And in this intelligence section, I'll focus on opportunities created by foundation models framework, core AI, and MLX. I'll cover four areas. First,

and MLX. I'll cover four areas. First,

I'll start with Apple Foundation models powering Apple intelligence and how you can tap into them through the foundation models framework. Next, I'll cover

models framework. Next, I'll cover custom machine learning models and the frameworks for bringing specialized domain specific intelligence into your app. Then I show you how to deliver

app. Then I show you how to deliver aantic experiences with multiple models.

And finally, I'll cover evaluations and how they measure quality and keep those experiences reliable over time. Let's

begin with Apple intelligence. Now

across Apple devices, Apple intelligence powers features including smart reply, live translation, priority notifications, and more. The foundation

MS framework gives your apps direct access to the ondevice model behind Apple intelligence through a native swift API. At its heart, the framework

swift API. At its heart, the framework is very straightforward. The app sends a prompt to the language model. The model

reasons over the prompt and generates a response. For example, ask the model to

response. For example, ask the model to create a 3-day itinerary for Paris. It

returns a detailed plan in natural language.

The framework goes beyond basic text generation. Guided generation gives your

generation. Guided generation gives your apps precise control over the output structure and guarantees that the results matches swift types

and that is only the start.

Tool calling connects the model to live data and personal context like weather and calendar events. It also lets the model perform actions in your app on the

system or out there in the real world.

And custom instructions define the model's role, style, and behavior. And

streaming delivers models output as it is generated, enabling realtime UI updates.

Developers already using these capabilities across shopping apps like Wayfair, educational apps like Cellwalk, and local sports apps like Cricket

Heroes for the Cricket fans in the room, and many more. All on device without infrastructure cost or privacy trade-offs. It's really amazing to see

trade-offs. It's really amazing to see how developers have pushed the limit of what this ondevice model can do. This

year, working together with Google and using technologies behind the Gemini family of models, Apple created its latest foundation models to better

support intelligence inside your apps.

Prompts now accept both text and images.

With this, you can generate captions, identify landmarks, understand visual content, and more.

For example, you can ask it to describe an image, and the built-in model gives you a description of the image.

And yes, if you're wondering, he is indeed a very good boy.

The ondevice model now handles a broad range of tasks, especially with an image input. However, some requests demand a

input. However, some requests demand a larger model for deeper reasoning and more complex tasks. For those requests, the foundation malls framework now

includes access to a server model running on private cloud compute. It

delivers frontier level intelligence with strong privacy protections.

There is no account setup account setup authentication flows or API keys to manage. PCC is available for developers

manage. PCC is available for developers in the App Store small business program with less than 2 million downloads.

And of course, private cloud compute is private. It's architected in a way that

private. It's architected in a way that guarantees that user data is never stored. Your data is used only for your

stored. Your data is used only for your requests and comes with a verifiable privacy promise.

The foundation models framework spans both Apple's ondevice and private cloud compute models through the same set of APIs.

But there are a lot of LLMs out there and a lot of LLM providers. Maybe some

new ones by the time we're done with this presentation.

And now any LLM provider can make their LLM accessible via the foundation models framework by creating a Swift package that conforms to the new language model

protocol. The result is one swift API

protocol. The result is one swift API for the model that best fits your task, whether it runs on device or on a server.

Google and Anthropic have already created Swift packages to extend the foundation models framework, making state-of-the-art Gemini and Cloud models

available to all Swift developers.

The foundation models framework is the best way to run any large language model in your app. It provides you seamless access to multiple models including thirdparty models and custom ondevice

models which we'll discuss in the next section.

That covers updates to Apple intelligence and Apple foundation models. Next, let's bring the model of

models. Next, let's bring the model of your choice directly into your apps. So

far, I've covered how to tap into Apple Foundation models using the foundation models framework. This year, Apple's

models framework. This year, Apple's ondevice inference is getting a big upgrade with the new core AI framework and upgraded MLX.

The new Core AI framework, it's easier than ever to use a custom model to power features within your app, taking full advantage of Apple Silicon. And MLX

supports model research, training, fine-tuning, running local inference servers, including distributed workloads across multiple Macs. Let's take a

closer look at each. Starting with Core AI.

AI capabilities advance quickly and specialized models now power a wide range of experiences. They generate

image captions, recognize gestures, remove backgrounds, isolate voices, and you may even have your own proprietary models for specialized tasks. Bringing

these specialized models to your app should remain as smooth as possible. And

built from the ground up for modern AI workloads, Core AI brings cutting edge generative models into apps and turns them into responsive integrated experiences.

Local execution brings three immediate benefits. First, user data stays

benefits. First, user data stays private. Second, intelligent features

private. Second, intelligent features remain available offline. And third,

there's no per inference cost to the developer or the person using the app.

CoreI delivers high performance inference to build advanced AI features taking advantage of all of Apple silicon across CPU, GPU, and the neural engine.

But Core AI is more than just the inference runtime built into the operating system. It's a complete set of

operating system. It's a complete set of technologies and tools spanning the model deployment life cycle from optimization, conversion, and inference

fine-tuning all the way up to debugging and app integration designed to support the fast iterative cycle that is needed to build great AI features.

The framework also powers Apple intelligence experiences that you're familiar with like writing tools, smart reply, live translation, image playground, Genmoji, and others. Now,

every developer has access to the same inference foundation behind Apple's advanced system experiences deeply optimized for Apple silicon.

That is Core AI, the complete toolkit for optimizing and deploying models directly in apps.

While Core AI focuses on efficient model deployment inside apps, MLX focuses on efficiency and flexibility. Building

models from scratch, fine-tuning openweight models, and scaling frontier workloads across multiple Macs. MLX is

purpose-built for Apple Silicon and takes advantage of unified memory. It

accelerates computation directly on the GPU through metal and it supports advances in Apple silicon including GPU neural accelerator in M5.

The entire MLX SL stack is open source from the low-level kernel libraries all the way up to high level uh APIs. It's

available on GitHub with a thriving community of contributors.

MLX also has a strong presence on hugging face where you can find the latest and greatest models from the ML community. If you head over there right

community. If you head over there right now, you'll find that there are over 10,000 models supported out of the box.

MX also supports distributed computing which spreads large workloads across multiple Macs. For example, frontier

multiple Macs. For example, frontier openweight models like the latest Kimmy with trillions of parameters can be split and run across multiple Macs. This

gives you and your team access to fully private locally hosted Frontier Intelligence.

Some of the most popular tools uh for running large language models on your Mac are already powered by MLX. This

includes Olama, LM Studio, and VLM. If

you're using one of these uh tools on your Mac, you've already been using MLX.

Both CoreI and MLX provide open-source packages that conform to the foundation models framework language model protocol. That means the same foundation

protocol. That means the same foundation models framework Swift API now works across both Cori and MLX models.

So far, I've shared what's new in Apple Foundation models and bringing in custom [snorts] ML models with code and MLX.

With all these models with just a few lines of code away, AI experiences in your app can be more capable than ever.

In this section, I'll show how models work together to achieve multi-step goals. An agantic experience goes beyond

goals. An agantic experience goes beyond just prompting a model and getting back a response. An agent acts on your app's

a response. An agent acts on your app's behalf with particular goal and set of capabilities.

Consider a travel app. This app has two specialized agents. An offline planner

specialized agents. An offline planner that uses an ondevice model and has access to my calendar. A booking

assistant that uses a server model has access to a booking service. Each agent

has its own goal, model, instruction, tools, and configuration.

I ask what time is my flight? The

planner calls the calendar tool, finds the flight and returns the details. Its

role is focused planning and personal travel information.

From the response, I realize my flight is delayed. Now I need to rebook my

is delayed. Now I need to rebook my hotel. This is a different task. It's

hotel. This is a different task. It's

more complex and requires a booking agent. The agent has access to a server

agent. The agent has access to a server model and a booking tool.

The booking agent has the right set of capabilities, but it does not yet have the flight details from my planner.

Without this shared context, this experience breaks into two separate interactions.

Instead, the app needs to move from planning mode to booking mode while keeping one continuous interaction. And

this year, we adding a new capability called dynamic profiles to handle all of this for you. Agents now have shared context and all of this happens within

one session preserving continuity across handoffs. The session maintains a

handoffs. The session maintains a transcript containing the instructions, my prompts, model responses, tool calls, and tool outputs.

When booking mode becomes active, the booking agent can use the existing history while applying its own model instructions, tools, and configuration.

The context continues while the agent's capabilities change.

This new agantic experience is powered by dynamic profiles. A profile is a complete configuration of a particular task including the model, instructions,

tools, and the generation behavior.

Different tasks can use different models allowing each stage to balance capability privacy performance and cost.

As the active profile changes, relevant prompts, responses, and tool calls and tool outputs can remain in that shared context, preserving continuity across the handoff.

All of this enables you to build specialized agents, each with its own distinct goal and set of capabilities, working together within one coherent experience.

That's agantic experience. specialized

agents working together to complete one or more complex goals. Next, let's look at evaluations. How to measure the

at evaluations. How to measure the quality of these experiences.

As you chain multiple of these models, tools, and custom instructions together, your app's logic becomes incredibly complex. If you spent any time building

complex. If you spent any time building features with language models, you already know the biggest challenge. The

output can be unpredictable.

Traditional features always produce the same output for a set of inputs and you can easily verify this behavior with a unit test. With intelligent features,

unit test. With intelligent features, you cannot rely on functional consistency to verify behavior because the model output can be unpredictable.

This means a simple unit test is insufficient.

Let's take a look at an example.

Consider book tracker app that uses a model. I prompt the model to act as a

model. I prompt the model to act as a librarian and generate descriptive tax uh from user reviews.

When I tested myself, it looks great.

Based on my description, it added tax to the book. Romance, science fiction,

the book. Romance, science fiction, good. And I tried it with a few other

good. And I tried it with a few other books. No issues. Classic adventure

books. No issues. Classic adventure

looks great to me. But then I share the app with a friend and they wrote a review for Dracula and since their writing style may be different than

mine, the model tripped up and tagged it as cuddly. I guess a type of cuddly uh

as cuddly. I guess a type of cuddly uh familyfriendly kittens, vampire kittens. Well, this is clearly a problem and that is why you

need evaluations. The evaluations

need evaluations. The evaluations framework provides a flexible system to measure the quality of the model output.

You start by defining metrics that represent success for your feature. Then

grade outputs automatically, including language model based evaluators.

Finally, analyze statistical trends across large data sets and tailor evaluations to the behavior the app must deliver. The result is a repeatable

deliver. The result is a repeatable quality process instead of one-off manual testing. The framework scales

manual testing. The framework scales evaluations across larger and more diverse sample sets over time. Can also

synthetically generate additional samples, expanding coverage without relying entirely on handwritten cases.

The foundation models framework now connects an app to a broad range of models and the evaluations framework lets you measure your features. no

matter which model you're using.

Together, they provide both model flexibility and consistent standard for quality.

And there's a lot more we didn't have time to cover.

Vision tools to extract text and read barcodes from user provided images.

There's core spotlight rack tools to securely search and retrieve personal or app specific data. This lets you lets the model ground responses in information that is relevant, private

and upto-date and dynamic instructions to adapt models behavior to changing users context. And

there's so much more.

Put together these technologies provide the building blocks for great AI features. We've covered three major

features. We've covered three major frameworks. So let's close with which to

frameworks. So let's close with which to use when. First foundation models

use when. First foundation models framework for experiences built around large language models. It provides one swift API for Apple foundation models

both ondevice and on private cloud compute as well as third party models.

Second, use Core AI when your app needs a specific model to run locally with high performance and efficiency. And

third, MLX for model research, development, fine-tuning, running local inference servers and distributed computing across Apple silicon. And

finally, no matter which framework or model you choose, you need to ensure that it works flawlessly. And that's

where evaluations framework comes in. It

provides automated tools to measure quality, uncover failures, reduce unpredictability, and help your ship with confidence. And with that, I'll

with confidence. And with that, I'll hand it over to Alan. Thank you.

[applause] Thank you.

All right. Thank you, Shashank. Hello,

everyone. Good morning.

Good to see you all. It's actually it's always awesome to see folks here and get the energy in the room. Uh, and looking forward to connect with you all in the

mixer uh afterwards as well. Uh, but so delighted. My name is Alan Schaefer. I'm

delighted. My name is Alan Schaefer. I'm

also part of the techn technology evangelism team here at Apple. Uh and so Shashank just talked to you about how to make your apps uh more intelligent. Uh

and now let's talk about making them more integrated and enabling them to take advantage of some of our Apple provided system experiences. There's a

lot of these like in widgets for instance. So, widgets present

instance. So, widgets present information at a glance uh using your app's content. And so, it's really just

app's content. And so, it's really just a way of keeping people engaged right from the home screen. And so, here we have a widget for a book club app that

shows how many pages the next chapter has and encourages a daily read. There's

also integrations with live activities.

And so, uh, this is about providing real time step-by-step updates from your app.

Like in this coffee shop app, it lets people track their order status without pulling them away from whatever they're doing. And then there's just so many

doing. And then there's just so many other ways that your apps can integrate with the system, whether it's in control center or the action button or spotlight

search. All of these different

search. All of these different integrations can help your app stay present and useful really appearing right at the right moment uh without any friction.

And then for today, let's talk about this how it can go even further with voice. And so sometimes just the most

voice. And so sometimes just the most natural interaction is by simply asking.

Uh and that's where the allnew Siri comes in.

So this year Siri has been completely rebuilt. uh with Apple intelligence at

rebuilt. uh with Apple intelligence at its core. And when your app works with

its core. And when your app works with Siri, it's meeting people where they are comes naturally to them through natural conversations and experiences that fit

their context. And so, let me show you

their context. And so, let me show you what I really mean by this. So, we built this sample app. It's called Comet Cow, and it's a calendar app, but it's filled

with like astronomical events, eclipses, and meteor showers and all that kind of thing. So, let's imagine that I'm using

thing. So, let's imagine that I'm using it now to organize a a picnic for my friend's birthday. And then we're going

friend's birthday. And then we're going to go on a trip for some stargazing.

I can start a conversation with Siri and just ask, "Who's coming to my picnic?"

And Siri searches for the event, finds the attendees, and immediately brings up the guest list. I can also reschedule the picnic by saying move it to noon,

actually 11:30 a.m. And so now Siri locates that specific event coming from Comet Cow and reschedules it. Siri then

asks to confirm the details and I say, "Sounds good. Thanks." But so Siri is

"Sounds good. Thanks." But so Siri is handling all of the heavy lifting here.

It's interpreting my phrasing, making the change, and then rendering this custom view. And this allows me to

custom view. And this allows me to interact with Comet Cow's core features without having to navigate into its UI.

So, let's keep going. So, here I've opened up the Comet Cal app. I'm looking

at my calendar events and they all have a date and a time, a title, location, invite list, etc. They're calendar events. And Siri understands what's

events. And Siri understands what's currently on screen. So, I can ask it to open one of these events in a very natural way. So I can say, "Hey Siri,

natural way. So I can say, "Hey Siri, open that third event." And Siri identifies the third event that's on screen and opens it up.

So now I'm on the event detail view.

I'll try referring to this event rather than saying the title of the event.

Okay. So, hey Siri, email the people in this event and ask them to bring chocolate and marshmallows. And Siri can identify the event that's currently on

screen right now. find the attendees and pass them over into mail. So there that is.

All right. So this is the new Siri taking a big leap forward. It can now understand personal context like knowing about the calendar events that are in

comic cow and who was invited to them.

It has on-screen awareness so people can refer naturally to what's right in front of them. And it can perform actions

of them. And it can perform actions across multiple apps like pulling attendees from an event in CometCal and dropping them into mail.

And this isn't just an upgrade to a voice assistant. It's really a new

voice assistant. It's really a new interaction model that's available to your apps. And although it might feel a

your apps. And although it might feel a little bit novel right now, this kind of interaction is probably what people will come to expect from these apps that they

use every day.

So how do you build this? Well, let's

start to break it down. So to make your app a part of this new experience, we have to start by giving Siri visibility into its content. And you do that by

adopting the app intense framework. So

app intents is the foundation that connects your app to Siri and to Apple intelligence and it provides a structured way to describe the content

the content inside your app and the things that your app can do. So starting

with the content we call these entities.

So app entities describe the concrete information that's inside of your app.

You can think of them like the nouns that are in your app. And they describe really three things. What that thing is, how it's uniquely identified, and its

key properties like a title or a date or text or whatever it contains. Now,

they're not a new data model. They're

really a way of just describing your content so that the system can understand it.

And to make this concrete, think about the data that you probably already work with every day. If you have a calendar app, each calendar event is an entity.

If you have a mail app, each message is an entity. And if you have a photos app,

an entity. And if you have a photos app, each photo or each photo album is an entity.

But the key to all of this and telling you this is that this isn't just for these built-in apps. It's for your apps,

too. And so if your app tracks

too. And so if your app tracks astronomical events or sends messages or works with photos, whatever the case, each of its content elements can be an

entity. And then when you model your

entity. And then when you model your content this way, it means that Siri can search it, can reason about it, and interact with it just like it does for

the built-in apps.

But okay, so that's entities, but they're on their own, they're really just information. Where this begins to

just information. Where this begins to get interesting is when you combine information with taking action. And

those actions are what we call intents.

So in this example here, I'm sending a a report to Mary and the report is the entity and sending it is the intent. So

I want to get a closer look now into intents.

And if entities were the nouns, then you can think of intents as being the verbs for your app. The things that your app actually does. So in a mail app, that

actually does. So in a mail app, that means, for instance, creating a new draft or forwarding a message, sending a reply, all that kind of thing. Each of

those verbs is an intent. And when you define these intents, then the system knows exactly what actions are available and it can trigger them. And of course,

that was looking at mail. But the same goes for your apps. You define the entities and intents using the app uh app intense framework and then Siri can

act on them.

But okay, so let's talk now about really getting started with this. Um, you don't have to start from scratch thinking through this through. Really, the best way to get started is with what we call

an app schema domain. These are kind of like blueprints for common application experiences. And whether that's working

experiences. And whether that's working with photos or managing calendars, navigating maps, playing media, whatever is the case.

And inside each domain then app schemas define the entities the intents and different semantics for that uh specific kind of experience.

And Siri and Apple intelligence have been trained on these schemas to reason about your app in a consistent way. So

here now are the Apple provided schema domain. So it's system, phone, mail,

domain. So it's system, phone, mail, clock calendar camera photos etc. Right? And then here is just one example

Right? And then here is just one example for each of an example action. Uh so you can create an event in the calendar, send a message, uh start a camera

capture, and there's dozens more of these.

So if one of these domains is a good fit for what your app does, this is where you should start. And then by adopting these predefined schemas and mapping

them to your app's features, it means that Siri can immediately know how to work with your app.

Okay, so that's just the beginning. Uh

earlier I was showing you how Siri can understand uh what was on screen in comet cow. Uh and the app intense

comet cow. Uh and the app intense framework is what provides the APIs uh to give Siri that awareness. So think

back to this example now. Uh I was looking at my list of events and I said uh open that third event. Now for Siri to understand this phrase or to handle

this, it has to understand exactly what's on your screen right now and then be able to map those visual elements to actual data.

And to make this work, Siri uses uh lets you define what it calls view annotations.

So it lets you tag your app's UI views with the specific entities that correspond to them. So when someone says the third one, Siri's not just looking

at the pixels, it actually knows exactly which entity is backing that view right at the point where that request was made. And this goes beyond views. It

made. And this goes beyond views. It

work also works with user activities, notifications, now playing sessions, uh, etc. Okay, continuing on. So with Apple

intelligence, as I said, Siri can work across multiple apps in a single request. This means it can pull

request. This means it can pull information from one app and take action in another. And all of this really

in another. And all of this really breaks down the walls between apps to create a more fluid user experience.

For example, imagine an app that keeps you up to date with uh kids soccer tournaments, right? So, it'll have all

tournaments, right? So, it'll have all the games in a calendar and then you can just ask Siri, ah, message Emma the game details for this weekend, right? And

Siri will find the event entity for the game, finds Emma from your contacts, and then executes the app intent uh to send the message. And the reason this works

the message. And the reason this works is because there's APIs to translate your app's entities into formats that other apps can understand.

And it works the other way, too. If we

had the team roster in notes, we could say, "Link this note to my next game," and Siri would take the note on screen, connect it to the next game that's

showing up in your soccer app. And then

so in doing so, that app becomes a first class citizen in the fabric of the system.

And then finally, what really makes Siri feel truly personal is that it can learn from how people use your apps. And so

people very often use language that doesn't specify a certain app. They'll

ask Siri, "Send a message to Emma," but might not say which app they want to use to actually send it. They just it's implied.

And if there's multiple messages um messaging apps installed on their device, Siri kind of has to stop and disambiguate and ask which app did you

meet? Now if I use Siri in the end to

meet? Now if I use Siri in the end to send that message, the system will learn my preference. But uh we also want it to

my preference. But uh we also want it to learn from the actions that people take inside of your app's UI and that's where interaction donations

come in.

So think of these as building muscle memory for the system. Each time someone performs an action in your app's UI, if that's something that maps into an app

intent, you should donate that interaction. And what it does is it

interaction. And what it does is it builds a history that teaches Siri how people are actually using your app, giving it the context it needs to

anticipate what they might want to do next time.

So then in the future if they ask Siri to take that action, it can use that history to infer the right app to use and then go directly to executing that

request.

But okay, so that's a quick uh exploration of the new Siri and just how it's becoming more powerful, more contextual, and more capable. And app

intents are that connection that makes it all possible uh with your app.

Now, before I go, there's three steps that I would uh that you can take to really get started right now. First is

to download the samples. There's a bunch of them. Uh I mentioned Comet Cal. Uh

of them. Uh I mentioned Comet Cal. Uh

there's also Cosmo Tunes, which works with music. Unicorn Chat is a messaging

with music. Unicorn Chat is a messaging app. Uh and there's others. There's a

app. Uh and there's others. There's a

photo uh uh interactions app, and so on.

And all of these are great for exploring the feature set on your own and then seeing how app intents work under the hood.

Next uh next step after that sit down with your team and begin to map out what are the nouns and what are the verbs uh from your app and you can begin to map

those into entities and intents.

And then finally review the app schema domains. So identifying which schemas

domains. So identifying which schemas might align with your app's features is really just the fastest way to get Siri working with your app.

And that's what this integration really means. When your app is deeply

means. When your app is deeply integrated, it just shows up when people need it. And that builds habit and trust

need it. And that builds habit and trust and keeps people coming back. All right,

so that's all for me. Thank you very much. Uh, and now I'll hand it off to

much. Uh, and now I'll hand it off to Mar. [applause]

Mar. [applause] Hi, I'm Aaho. I'm a design evangelist and after all that deep technical ground, I get to bring things over to

design. I will share the latest updates

design. I will share the latest updates and all the possibilities they open up for your apps.

People move naturally between apps and devices throughout their day. studying,

working, shopping, catching up with the family, with the news. And each of those moments is a chance for your app to be part of their day.

But what happens when your app isn't on the device they are already using? That

extra step to find it makes uh takes effort from them and it's an engagement opportunity difficult to miss, easier to miss.

New this year, that experience gets so much better. iPhone apps are now

much better. iPhone apps are now resizable and show up in more places than ever.

Your iPhone app runs on iPad and on Mac through iPhone mirroring. When your iOS app shows up and resizes on larger displays, it can step in the moment

someone needs it without having to build a dedicated version.

When someone's ready to use your app, all it takes is a spotlight search. The

fitness app doesn't have a Mac version, but it opens instantly through iPhone mirroring. No unlocking, distractions,

mirroring. No unlocking, distractions, or extra steps.

So, today I'll show you what it takes to make your iOS app resizable and the most important updates made to Apple's design system and liquid glass.

To begin modernizing your app and make it resizable and available on more devices, you need to recompile with Xcode 27. It automatically supports

Xcode 27. It automatically supports resizability and begins using the new design with liquid glass.

There's no new API to adopt. Swift UI

handles this for you. This is your moment to evaluate how well your app ex your app experience carries across devices and to support liquid glass as

the option for opting out is no longer supported.

To offer a great experience when people move between devices or resize a window, your layout and content have to gracefully adapt. Here's how it looks in

gracefully adapt. Here's how it looks in the music app. As more space opens up, the top bar and list widen. The cover

art resizes, making room for a second column with content and controls, and color fills the entire background.

And the same logic runs in reverse. As a

space gets tighter, everything settles back down. To achieve that, you don't

back down. To achieve that, you don't have to design for every platform or window size individually.

You define the logic once how the content behaves when there's more room and when there's less. The system takes that logic and applies it across every

aspect ratio.

And the way it does it is through size classes. They define how your layout

classes. They define how your layout behaves and adapts according to the available horizontal and vertical space.

instead of restricting your designs to a specific screen size.

For example, when horizontal space is limited, the size class is compact and the layout logic is stacking elements vertically. It's more efficient. It's

vertically. It's more efficient. It's

easier to read and to tap.

And when space opens up, the size class becomes regular. And the logic is

becomes regular. And the logic is repositioning elements to take advantage of all that extra space.

Take the notes apps as an example. When

the window expands, the canvas automatically adjusts to the wider layout and it even allows a split view.

It shows more notes and access to search without needing to navigate back and forth.

Many apps can achieve this without without introducing your designs, especially if they use Swift UI or auto layout. To make your interface stay

layout. To make your interface stay familiar and accessible for everyone to use, use system components. Let them

handle the heavy lifting across every stage of resizability. They know what to do to keep your controls reachable and predictable.

designers can bring their system components into their sorry our our system components into their design system with a new UI kit for iOS, iPad

OS, and Mac OS 27. It's available in Figma and in the design resources section of the developer website.

System components like dub bars and toolbars are designed to smoothly adapt between different aspect ratios without with minimal work from your end.

Top bars, for example, get wider as the window enlarges, and icons move in line with their labels, so the top bar stays compact.

Toolbars, when a window narrows, automatically move items into an overflow menu. Here in the news app,

overflow menu. Here in the news app, it's the last control on the right.

Again, the system manages this transition for you, and you can customize it.

For example, share is persistent across all window sizes because it's an important feature in an article.

Items with lower priority like save story go into the overflow menu when the screen narrows and is accessible just a single tap or

click away in the ellipses button.

This is possible with the visibility priority property. Use it to define what

priority property. Use it to define what items have lower priority so they move into the overflow first and which items are high priority so they stay visible longer.

System components are constantly evolving and are your best allies to modernize your app across all Apple platforms and to help you maximize engagement.

This year, system components using liquid glass got an upgrade for better consistency and usability, so your apps look and work better than ever.

[clears throat] To maintain exceptional readability, liquid glass now diffuses content behind it much more effectively.

It also creates a more distinct separation by using a darken edge with brighter specular highlights.

People can now easily fine-tune liquid glass to their own taste. A new slider in the settings app lets them adjust it anywhere from ultra clear to fully

tinted.

And the best part is apps already using liquid glass get these improvements without recompiling when they run on iOS 27.

In addition to the improvements on liquid glass, Mac OS also receive its own set of updates like a more uniform toolbar that provides better structure and legibility.

And sidebars now extend to the very edges of the window, rendering beautiful refractions as content scrolls underneath.

and sidebar icons regain their color, making it easier for people to distinguish between active windows at a glance.

All of these updates to liquid glass extend to app icons, making them sharper and more defined.

In icon composer, you can now design your app icons out of multiple layers of liquid glass and dial properties such as refraction, shadows, translucency, and specular

highlights to give them some real character to design for fluid resizability and engage with your audience. Hello,

this is an iPhone. Um, to design for resizability and engage with your audience in more platforms, start here.

Recompile your app with Xcode 27. Use

system components and liquid glass. And

ensure your app layout resizes well across different aspect ratios and that controls remain easily accessible.

Whether you're designing individual features or shaping entire ecosystems, we invite you to design experiences that are more seamless, scalable, and

powerful for all your customers.

And now, here's Angelica to show you what's new in Xcode.

[applause] Thank you, Maho.

Hello. As Mah mentioned, my name is Angelica. I'm part of the technology

Angelica. I'm part of the technology evangelism team covering developer tools. My colleagues have covered a lot

tools. My colleagues have covered a lot of the exciting updates this year to create fantastic experiences inside and outside of your apps, and I'm excited to walk through the significant advances

across Apple's developer tools that can help get you there.

Xcode already gives you everything you need to build, debug, test, and distribute your apps. And over the past year, coding agents were added to Xcode

to work across all of these stages.

So when an idea strikes, you can describe the feature you want or the problem you're trying to solve. Xcode

and the agent helped you build it with full awareness of your project.

Xcode works with the most popular and well-known models and agents. We worked

with Anthropic, OpenAI, and Google to bring Claude, Codeex, and Gemini directly into Xcode, so you can code with the agent you prefer.

And with the agent client protocol, you can bring in any agent and any model, including models that run locally right on your Mac.

With the model context protocol, Xcode also connects to the tools you already use, design tools like Figma and developer services like GitHub.

Whichever agent you choose, Xcode will provide the deep context it needs to not only understand your requests with less explanation. It will be able to build,

explanation. It will be able to build, validate, and test its work to ensure the most effective solutions are made.

Agents in Xcode have access to your source code, your build settings, and even your live editor state, like what files you have open or what your active selections are. So, you spend less time

selections are. So, you spend less time explaining your setup and more time building.

And working with agents can also be more exploratory. That's where plan mode

exploratory. That's where plan mode comes in. Support for plan mode is now

comes in. Support for plan mode is now part of Xcode 27.

You give a highle overview of what you want. The agent drafts a step-by-step

want. The agent drafts a step-by-step plan before a single line of code is written. And you could adjust, correct,

written. And you could adjust, correct, and expand it turning planning into a discussion and aligning on the approach before implementation. And when you

before implementation. And when you approve, Xcode works with the agent to build it.

And when you want to have fine grain control or provide feedback for any artifacts that are created, you can add in inline annotations to prov uh to provide the right context for the agent

to start working.

Whether you're building or planning, Xcode provides skills and tools for agents to use, and it will pick the right one automatically for the task at

hand. A few that stand out. Up-to-date

hand. A few that stand out. Up-to-date

Apple documentation with fast ondevice access.

Xcode downloads a local archive of the developer documentation that is optimized for model use and ensures that it's always up to date.

No matter which agent you choose or how up-to-date the model is regarding the latest frameworks, agents will automatically invoke invoke Apple document search to pull current

framework docs, making sure that you're building with the latest and greatest.

Another great tool is previews. With it,

the agent can visually verify its work and generate multiple UI directions for you to choose from, which makes prototyping fast. Previews render

prototyping fast. Previews render incrementally to visually verify results. If something doesn't look right

results. If something doesn't look right to the agent, adjustments are made before you even need to step in.

Agents can also use previews to provide snapshots as an artifact once it completes its work for you to validate.

All right. Agents in Xcode can also take on the large task of localization for you.

The agent prepares and then translates your whole app while preserving the context of each string. This isn't just a word for word swap. It considers the relevant code surrounding UI differences

that might be relevant to certain devices or whether or not it's singular or plural.

So what would have been a multi-week cycle happens in far less time and your app feels at home in every market.

Another great tool is tests. There are

so many amazing things agents can do with tests in Xcode. Existing suites are picked up automatically and all your work, all the work that the agent does will be tested against it. Xcode can

also help build a whole suite of tests to validate any new changes. You can

even ask it to modernize your tests. Now

you can be confident that the work is reliable.

And we're just scratching the surface.

There are so many more things agents can do in Xcode, including if you have a UI kit app and want to tackle what Maho just talked about today. You can ask

Xcode to modernize your app. You can

also ask Xcode to fix the top crashes or assess the performance of your app in the field and generate recommendations to improve it.

Agents can run LLDB commands to debug its work and read its output from the console along with any logging.

It can even build, run, and interact with your app on devices and simulators and much, much more. Whatever the task, the right tool gets discovered and used

automatically.

And of course, you can control what agents have access to.

Whichever agent you use, file access is protected by system level security built into Mac OS. You decide exactly which files the agent can touch. Everything

else requires your explicit approval.

So, I really recommend trying it out because coding with agents in Xcode means better understanding of your project and the tasks at hand. It means

being more aligned with features like inline annotations, plan mode, or using tests to validate its work. It's

designed to be integrated into your project and your workflow.

This is why Xcode is truly the best place to develop apps made even better with support for agents. Thank you so much. I'll hand it off to Latica to talk

much. I'll hand it off to Latica to talk about what's new on the app store.

[applause] Good morning. My name is Latika and I

Good morning. My name is Latika and I lead product marketing for marketplace technologies, including a number of developer tools for the app store. And

today we're going to cover a few of the key App Store announcements from WWDC26 and what you can do to get ready for these features when they launch later this year.

So today we'll start off by discussing some of our new discovery and marketing enhancements to help people discover your app and some exciting updates to Apple inapp purchase and store kit and

finally some updates to the App Store Connect API to help you automate your workflows. All right, let's get started.

workflows. All right, let's get started.

The App Store is a safe and trusted place for people around the world to discover your app or game. Reaching

customers in 175 storefronts on more than 2 and a half billion devices and in 50 languages.

Today, the App Store welcomes over 850 million weekly visitors from around the globe to help them discover your app or game and get excited about what you've

made. And with an audience this large,

made. And with an audience this large, there's appetite for a range of experiences across genres, business models, and play styles.

Now, when someone views your app on the app store, what they see in those first few moments really determines whether they tap in to view or download. And

today, the product page includes images of your app in use, and those same images appear in search results.

With new creative assets, you can present a large image or video in your product page and in your search results, giving you a powerful way to showcase

your apps and games to potential customers. As shown on the screen, the

customers. As shown on the screen, the exercise app has chosen to incorporate some lifestyle images like dumbbells and a yoga mat. and on the right a hiker.

These assets can help you tell a richer story about your app or game and uplevel your value proposition, maybe your brand or a seasonal offering. And they can be

approved without having to submit a new binary, which gives you more flexibility in how and when you update your product page.

These assets also work with custom product pages and product page optimization. So you can use these two

optimization. So you can use these two features to test and learn what resonates with your customers.

To help you visualize how these new images appear on the app store, you can preview your product page in App Store Connect. And before that goes live on

Connect. And before that goes live on the App Store.

You can check out how your header, image, your icon, screenshots, and descriptions appear both on your product page and across the app store. You can

see it on iPhone and iPad. You can

preview different languages, and you can check out what your product page looks like in dark mode or light mode.

And to manage all these new assets in one central place, you can use the new asset library in App Store Connect. This

is where you can review all your images and videos. You can see what's been

and videos. You can see what's been approved and where you can use them. So,

for example, you can explore which assets might work with inapp events or what's better suited for your product page.

The app store helps people discover new apps and games, and our new personalized collections show apps that are tailored to their interests. Collections can

appear across the store, and they cover a variety of topics like fitness, travel, or even a subgenre like mellow atmospheric games.

Collections adapt to a customer's changing interests and needs, and they're based on app store information like app usage and downloads, and they'll be a fun new way for customers

to discover your apps.

Now, let's talk about Apple inapp purchase and store kit.

Apple's inapp purchase system makes it simple for customers to purchase your digital goods and services on the app store and in your apps across all platforms, whether that's a one-time

purchase or a recurring subscription.

Customers around the world can pay with their preferred payment methods with over 200 options. And you can price your products, choosing from over 900 price

points that get automatically updated as taxes or currencies change.

Apple hands the complexity of tax collection and remittance so you can focus on building great apps. And with

extensive marketing tools like paywall templates and offer codes and robust analytics and sales reporting, it's never been easier to build a business on the app store.

To set up Apple inapp purchases, you'll first need to use the storekit framework to configure your products and your entitlements. And then you can use App

entitlements. And then you can use App Store Connect to set up your inapp purchase metadata and submit for review.

If you offer subscriptions, keeping subscribers engaged and retained is critical, and retention messaging can help you do just that by reaching subscribers at the moment that they

might choose to cancel. You can share a custom message that highlights your subscription's value, like an upcoming launch, new content, or maybe key benefits. And you can even sweeten the

benefits. And you can even sweeten the deal with a special offer. Like in this example, the customer is reminded that they would miss out on the guided yoga feature coming next month with an offer

for three months free.

There's also a few new ways to help customers get more value from your subscriptions. With subscription

subscriptions. With subscription bundles, you can offer access to one or more apps with a single subscription.

That's one subscription offered at a lower price than each one individually.

And bundles can be create configured in many ways. You can make a bundle from a

many ways. You can make a bundle from a subscription in your app across many of your apps. Or you can even partner with

your apps. Or you can even partner with another developer to create a bundle for both of your apps. And a good example of this is Apple 1 where users can get access to multiple services like Apple

Music, Apple TV, Apple Arcade, and iCloud.

You can also offer a subscription suite.

Let's say your products work better together, like a set of apps for photo and video editing. You can use a suite to provide access to all of them with a single subscription, provided the apps

are on the same developer account. And

an example of a suite is Apple's Creator Studio, which offers access to nine apps from Apple, including Final Cut Pro and Vision Pro, Logic Pro.

When offering your subscriptions on the app store, you can share it with groups or organizations in two new ways.

There's group purchases and volume purchasing.

Group purchases is built for people who use the app store. If you think about a small team of designers or maybe your kids baseball team, being able to give every person on the roster access to an

app with a single tap. One person buys a subscription and invites others seamlessly without shared passwords or multiple purchases.

With volume purchasing, your subscription can be made available to enterprise organizations and education buyers through the Apple School Manager and Apple Business. And this allows you

to reach organizations that procure apps at scale using your organization's existing device and identity management solutions.

There's also a new payment option for autorenewable subscriptions where you can offer customers a lower monthly rate in exchange for a 12-month commitment.

And this can make annual subscriptions more affordable while securing a long-term customer relationship.

On the left is how the payment option is provided to the customer before they purchase. And on the right, customers

purchase. And on the right, customers can stop the subscription from renewing at any point once the 12-month commitment is complete. And they can also easily view their payment schedule

in their Apple account and receive reminder emails and notifications of upcoming payments.

With so many new inapp purchase options, it's really important that you streamline your app review submissions.

And this year, you'll be able to submit inapp purchases and other items that require review, like an app update or an inapp event, all together in a single submission.

In addition to batching multiple products and combining these items into a single subscription, you can also check out the status of your submission in App Store Connect and view any messages that you've received from the

App Review team.

Finally, let's review some updates to the App Store Connect API. Many of you might be using the App Store Connect API to help automate your build distribution and manage your metadata. And the

features that we covered today are also available through the API, including support for monthly subscriptions with a 12-month commitment, support for inapp purchase submission enhancements, and

the asset library. There's also some improvements to how you manage your uh your background assets. So, we're

making changes to how you can uh manage the way users download your assets to reduce your app's installation time.

All right. Right. So, with all of these new features, here are some things to consider as you prepare for your next app update. First, think about the

app update. First, think about the creative assets that you'll use in your marketing and how you might use images and videos across the app store to showcase your brand, your seasonal

content, or new offerings. And this

fall, you'll be able to submit these assets for approval and then use the asset library to update your presence on the store to align with your marketing campaigns.

For those of you offering subscriptions, take advantage of retention messaging to help combat churn with custom messaging and special offers.

Explore new business models like group purchases, subscription bundles, and suites to see if they might help you acquire more customers and drive better retention. And finally, you can use the

retention. And finally, you can use the App Store Connect API to automate your common workflows like app submissions or managing your images and videos in a single place.

For more details and links to related documentation, you can check out our App Store what's new page on the Apple developer website. And this is where you

developer website. And this is where you can find feature overviews and more video resources to help you make the most of your business on the App Store.

So, to wrap things up, here's a snapshot of some of the biggest app store announcements from WWDC, including new ways to market your apps and games with creative assets and product page previews, new features to grow your

subscription business like retention messaging, bundles and suites, and group purchases, and tools to simplify your workflow using the App Store Connect API for a seamless submission experience.

Thank you so much for joining us today, and now I'll hand it back to Josh.

[applause] All right. So, we covered a lot today

All right. So, we covered a lot today and hopefully it inspired some ideas for your apps and hopefully by the end of this what you feel is that you know what

makes the platforms here distinctive is it's not any single piece. It's all of these layers that come together to uh create a great experience and reinforce each other. Not just a collection of

each other. Not just a collection of features, a really coherent system. And

the idea is it's designed from the ground up so that whether you're working with something that makes your app more intelligent, integrated, and adaptable, you end up with an incredible app that

you can release on the app store and ensure that people discover your app and love it all around the world.

When you're ready to go deeper still, and I did find a pin for our friend who raised their hand saying they've watched all over 100 videos where it's gonna be a quiz, though, so we'll see how that

goes.

Uh we've got all of the videos online uh for from WC for you all to dive into.

You can find them on the Apple developer app website, YouTube, and actually now also on our new BillyBilly channel.

Also, Apple experts are on the Apple developer forums if you need deeper technical support at any time.

and you and your teams can use the new AI powered search on the developer website which actually brings together documentation, sample code, sessions,

group labs, and more. And finally, this event that you've joined us for today is just one of many that Apple hosts throughout our meet with Apple program, including at our developer centers

around the world. This is just one of four, and we just recently announced that we're going to be opening one in Berlin, and we're really excited about that. So throughout the year, these

that. So throughout the year, these events will connect you with us uh so that you can get the support and insights that you need to get to build truly great apps and games across the

full range of topics and Apple platforms. So check out developer.apple.com/events

developer.apple.com/events

to learn more about events near you.

And uh for those of us who have joined us online, uh thank you for your time today. Uh excited for you have joined us

today. Uh excited for you have joined us from wherever you are. I always have to put hats off to our friends in India. Uh

there it just doesn't matter. It's like

10 o'clock approaching midnight there.

Uh uh it's delightful to see folks from all around the world joining us. We're

excited to see how you bring these experiences and features to life in your app. Uh for those of us here in the

app. Uh for those of us here in the room, uh we've got a we're going to have a mixer just out here in the lobby. Uh

we've got some snacks and some beverages. uh really excited to meet

beverages. uh really excited to meet with you, answer any questions you might have uh and understand uh what you're doing and what you're working on and see how we can work closer together. So,

thank you to everyone. Have a wonderful day. We'll see you soon. [applause]

day. We'll see you soon. [applause]

day. We'll see you soon. [applause]