Good morning. Oh, this is fun. All right. Well, welcome everybody here whether you’re joining us here in Cupertino. 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 here in the developer center here in Cupertino. Maybe we could give a round of applause for all of our friends joining us from all around the world today as well.

All right. My name is Josh Tidsbury, and I’m part of our technology evangelism team 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 WWDC26. And it’s a big year with over 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 actually watched all 100 videos? Okay, we need to have a conversation.

And maybe I can find some swag for you, too. All right. Maybe you’ve watched a handful of them. Or maybe you’re new to our platforms and your 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 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 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 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 on device 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 end to end AI workflow anywhere that you deploy. Swift. And for folks who are digging into custom models, ML 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 on device 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 app 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 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 resize ability. 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 iPadOS and running through iPhone mirroring on the Mac so your app can no longer just assume a single fixed size universal resize ability 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 on device intelligence surface by the system and arriving in an interface that 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.

Xcode 27 is a genetic. 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 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 through line. 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 reality or visionOS 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 node based 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 Projekt Red brought their game, cyberpunk 2077 to the Mac, and there’s game porting toolkit for 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 and audio and 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, 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 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 Intelligent Shashank. Over to you. Thank you. Josh.

Hey everyone. I’m Shashank, I’m part of the technologies evangelism team here at Apple. And in this intelligent section I’ll focus on opportunities created by Foundation models, framework core AI and ML. 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 custom machine learning models and the frameworks for bringing specialized domain specific intelligence into your app. Then I’ll show you how to deliver a generic 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 Models framework gives your apps direct access to the on device model behind Apple Intelligence through a native Swift API. At its heart, the framework is very straightforward.

The absence of prompt to the language model. The model reasons over the prompt and generates a response. For example, ask the model to create a three day itinerary for Paris. It returns a detailed plan in natural language, the framework goes beyond basic text 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 real time UI updates.

Developers already using these capabilities across shopping apps like Wayfair, educational apps like sell, walk, 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 tradeoffs. It’s really amazing to see how developers have pushed the limit of what this on device 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 on device model now handles a broad range of tasks, especially with an image input. However, some requests demand a larger model for deeper reasoning and more complex tasks for those requests. The Foundation Models 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. Peek 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 guarantees that user data is never stored. Your data is used only for your requests and comes with a verifiable privacy promise.

The Foundation models framework spans both Apple’s on device and private cloud compute models to the same set of APIs, but there are a lot of LLMs out there, and there are 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 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 third party models and custom on device 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 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 on device inference is getting a big upgrade with the new core AI framework and upgraded ML.

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 ML 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 advanced 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 build 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 private. Second. Intelligent features remain available offline, and third, there’s no per inference cost to the developer or the person using the app code. AI 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 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 the complete toolkit for optimizing and deploying models directly in apps.

While core AI focuses on efficient model deployment inside apps, ML focuses on efficiency and flexibility, building models from scratch, fine tuning open rate models, and scaling frontier workloads across multiple Max ML 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 ML stack is open source from the low level kernel libraries all the way up to high level APIs.

It’s available on GitHub with a thriving community of contributors. ML 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 now, you’ll find that there are over 10,000 models supported out of the box.

ML also supports distributed computing, which spreads large workloads across multiple Macs. For example, frontier open weight models like the latest Kimi 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 for running large language models on your Mac are already powered by ML. This includes llama, LM studio, and VLM. If you’re using one of these tools on your Mac, you’ve already been using ML for.

Both core AI and ML provide open source packages that conform to the Foundation models. Framework. Language model. Protocol. That means the same Foundation Models framework. Swift API now works across both core AI and ML models. So far, I’ve shared what’s new in Apple Foundation models and bringing in custom ML models with core AI and ML.

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 authentic experience goes beyond just prompting a model and getting back a response. An agent acts on your app’s behalf with a particular goal and set of capabilities.

Consider a travel app. This app has two specialized agents an offline planner that uses an on device 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 hotel. This is a different task. It is more complex and requires a booking 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 are 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 Hand-offs. 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 agent 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 a genetic experience. Specialized agents working together to complete one or more complex goals. Next, let’s look at evaluations and how to measure the quality of these experiences.

As you chain multiple of these models, tools, and custom instructions together, your apps logic becomes incredibly 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, 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 librarian and generate descriptive tags from user reviews. When I tested myself, it looks great. Based on my description, it added tags to the book romance, science fiction. Good. And I tried it with a few other 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, family friendly kittens. Vampire kittens. Well, this is clearly a problem and that is why you 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 quality process instead of one off 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 rag 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 up to date, and dynamic instructions to adapt models behavior to changing user’s context. And there’s so much more.

Put together, these technologies provide the building blocks for great AI features. We’ve covered three major frameworks, so let’s close with which to use when. First Foundation Models framework for experiences built around large language models. It provides one Swift API for Apple Foundation models, both on device and on private cloud compute, as well as third party models. Second, use code I when your app needs a specific model to run locally with high performance and efficiency and third ML 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 you ship with confidence. And with that, I’ll hand it over to Allan. Thank you. 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 and looking forward to connect with you all in the mixer afterwards as well.

But so delighted. My name is Allan Schaffer. I’m also part of the technology technology evangelism team here at Apple. And so Shashank just talked to you about how to make your apps more intelligent. 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 information at a glance using your 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 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 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 integrations can help your app stay present and useful, really appearing right at the right moment 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 natural interaction is by simply asking. And that’s where the all new Siri comes in. So this year, Siri has been completely rebuilt with Apple Intelligence at its core. And when your app works with Siri, it’s meeting people where they are. It comes naturally to them through natural conversations and experiences that fit their context. And so let me show you what I really mean by this.

So we built this sample app. It’s called CometCal. 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 it now to organize a picnic for my 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 comical and reschedules it Siri then asked to confirm the details and I say, 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 interact with comet calls core features without having to navigate into its UI.

So let’s keep going. So here I’ve opened up the comical app. I’m looking at my calendar events and they all have a date and a time, a title, location, invite list, etc. there are calendar 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, open that third event in 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 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 comical 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 across multiple apps, like pulling attendees from an event in comical and dropping them into Mail.

And this isn’t just an upgrade to a voice assistant. It’s really a new interaction model that’s available to 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, it starts 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 Intents 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, each photo or each photo album is an entity.

But the key to all of this in 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 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 content this way, it means that Siri can search it. It can reason about it and interact with it just like it does for the built in apps.

Okay, so that’s entities, but on their own, they’re really 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 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 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. App intents framework. And then Siri can act on them.

But okay, so let’s talk now about really getting started with this. 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 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 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 domains. So it’s system, phone, mail clock, calendar, camera, photos, etc.. Right. And then here is just one example for each of an example action.

So you can create an event in the calendar or send a message, 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. Earlier, I was showing you how Siri can understand what was on screen in CometCal, and the App Intents framework is what provides the APIs to give Siri that awareness. So think back to this example. Now I was looking at my list of events and I said, 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 lets you define what it calls view annotations. So it lets you tag your app’s UI views with a specific entities that correspond to them. So when someone says the third one Siri is 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 also works with user activities, notifications. Now playing sessions, 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 information from one app and take action 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 kids soccer tournaments, right? So it’ll have all the games in a calendar. And then you can just ask Siri. Oh, iMessage 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 to send 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 have the team roster in notes, we could say link this note to my next game, and Siri would take the note on screen and 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, messaging apps installed on their device here, he kind of has to stop and disambiguate and ask, which app did you mean? Now, if I use Siri in the end to send that message, the system will learn my preference. But 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 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 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 with your app. Now, before I go, there’s three steps that I would that you can take to really get started right now.

First is to download the samples. There’s a bunch of them. I mentioned CometCal. There’s also CosmoTunes, which works with music. UnicornChat is a messaging app, and there’s others. There’s a photo 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. Next step. After that, sit down with your team and begin to map out what are the nouns and what are the verbs 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 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 integrated, it just shows up when people 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. And now I’ll hand it off to Majo.

Hi, I’m Majo. 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 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 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 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 is 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 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 making it resizable and available on more devices, you need to recompile with Xcode 27. It automatically supports resize ability and begins using the new design with Liquid Glass. There’s no new API to adopt. SwiftUI handles this for you. This is your moment to evaluate how well your app, 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 the music app. As more space opens up, the tab, 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 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 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 taking elements 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 repositioning elements to take advantage of all that extra space. Take the notes app 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 new designs, especially if they use SwiftUI or Auto 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 resize ability. 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 UIKit for iOS, iPadOS, and macOS. 27. It’s available in Figma and in the Design Resources section of the developer website. System components like tab bars and toolbars are designed to smoothly adapt between different aspect ratios without. With minimal work from your end. Tab 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, 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 it’s accessible just a single tap or click away in the ellipsis button.

This is possible with the Visibility 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 to maintain exceptional readability.

Liquid Glass now diffuses content behind it much more effectively. It also creates a more distinct separation by using a darkened 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 already using Liquid Glass. Get these improvements without recompiling when they run on iOS 27. In addition to the improvements on Liquid Glass, macOS also received 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. Find an icon composer. You can now design your app icons out of multiple layers of Liquid Glass and dial in properties such as refraction, shadows, translucency, and specular highlights to give them some real character to design for fluid, resize ability and engage with your audience. Hello.

This is an iPhone to design, resize, ability, 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. Thank you. Majo. Hello.

As Majo mentioned, my name is Angelica. I’m part of the technology evangelism team covering developer 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 helps 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 Codex 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, 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 explaining your setup, and more time building and working with agents can also be more exploratory. That’s where plan mode comes in. Support for Plan Mode is now part of Xcode 27.

You give a high level overview of what you want. The agent drafts a step by step plan before a single line of code is written, and you could adjust, correct, and expand it. Turning planning into a discussion and aligning on the approach before implementation. And when you approve, Xcode works with the agent to build it. And when you want to have fine grained control or provide feedback for any artifacts that are created, you could add inline annotations 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 Apple documentation with fast on device 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 incrementally to visually verify 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 multiweek 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 UIKit app and want to tackle what Majo 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 macOS. 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 Latika to talk about what’s new on the App Store.

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 In-app Purchase and StoreKit. And finally, some updates to the App Store Connect API to help you automate your 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.5 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, 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 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 up level, 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 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 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 approved and where you can use them. So for example, you can explore which assets might work with in-app 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 in-app purchase and StoreKit. Apple’s in-app 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 handles 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 and app purchases, you’ll first need to use the StoreKit framework to configure your products and your entitlements, and then you can use App Store Connect to set up your in-app 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 subscriptions value, like an upcoming launch, new content, or maybe key 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 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 configured in many ways.

You can make a bundle from a subscription in your app across many of 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 One, 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 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 kid’s 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 auto renewable 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 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 in-app purchase options, it’s really important that you streamline your app review submissions, and this year, you’ll be able to submit in-app purchases and other items that require review, like an app update or an in-app 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 in-app purchase submission enhancements, and the asset library. There’s also some improvements to how you manage your. background assets. So we’re making changes to how you can manage the way users download your assets to reduce your apps installation time.

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

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 create a great experience and reinforce 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 going to be a quiz, though, so we’ll see how that goes. We’ve got all of the videos online for from WWDC for you all to dive into. You can find them on the Apple Developer app, website, YouTube, and actually now also on our new Bilibili 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 events will connect you with us 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 to events to learn more about events near you.

And for those of us who have joined us online. Thank you for your time today. Excited for you joining us from wherever you are. I always have to put hats off to our friends in India. It just doesn’t matter. It’s like 10:00 approaching midnight there. 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.

For those of us here in the room, we’ve got, we’re going to have a mixer just out here in the lobby. We’ve got some snacks and some beverages. Really excited to meet with you. Answer any questions you might have and understand 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.