Welcome to the 2026
Platforms State of the Union.
00:22
This is one of our favorite
moments of the year where we get
to share what's new
00:26
with the technologies, the
frameworks, and the tools that
you use every day
00:32
to build incredible apps and
games.
00:34
Apps that inspire us,
that raise the bar of what's
possible
00:38
and that push us
to build even better
technologies.
00:43
We love connecting with so many
of you.
00:46
Hearing about your passions,
your challenges,
00:49
and how we can better support
your work.
00:51
Your feedback shapes some of the
most important technologies that
we build.
00:56
And this past year, nowhere was
that more true than with the new
design
01:01
with Liquid Glass
and with Apple Intelligence.
01:02
These were both huge themes in
the 26 releases, and they're key
again this year,
01:10
with many of our efforts
influenced by your feedback.
01:13
Design and intelligence are both
so important because they
enhance
01:19
what's special about your apps.
01:21
The care and the craft that you
put into them.
01:25
With unique interfaces
and rich experiences
01:28
shaped by your deep domain
expertise.
01:31
Combined with enhanced
intelligence capabilities, you
can now build features
01:36
that weren't previously
possible.
01:38
To highlight what's new, we'll
dive into three key areas.
01:42
First, Apple Intelligence, with
new ways to bring generative
intelligence
01:47
directly into your apps,
and new integrations
01:50
with system intelligence
to bring users back to your
apps.
01:53
Second, platform improvements,
with design refinements and more
flexible UI layout,
01:59
updates to Swift and SwiftUI,
and enhancements that make your
apps faster,
02:03
more adaptive, and easier to
build.
02:07
And finally, developer
productivity, taking agentic
coding even further,
02:13
alongside improvements that make
Xcode faster and more personal.
02:17
We have a lot to cover, so let's
get started with Apple
Intelligence.
02:22
At the heart of Apple
Intelligence are Apple
Foundation models.
02:26
Working together with Google
and leveraging the technologies
02:30
behind their Gemini family of
models,
02:32
we created the latest
Apple Foundation models
02:33
to power our Apple Intelligence
experiences and toprovide even
better support
02:40
for the ways you're using
intelligence in your apps.
02:43
We adapted these models to run
on device and on Private Cloud
Compute.
02:47
Apple Foundation Models power
Apple intelligence, and your
apps can use them
02:52
too, through the Foundation
Models framework.
02:54
This year, the framework's
capabilities are expanding to
include image input and
03:00
support for server models.
03:02
So if you have
a more complex task
03:04
requiring the most advanced
frontier models
03:07
the API can now integrate with
the cloud model provider of your
choice.
03:11
To ensure getting started with a
large cloud model is as
accessible as possible,
03:17
even if you're writing your
first app,
03:19
developers with fewer than
2 million first-time App Store
downloads
03:23
will be able to use
Apple Foundation Models
03:25
running in Private Cloud Compute
with no cloud API cost.
03:29
It's access to frontier level
intelligence with unparalleled
privacy protections.
03:34
Because getting started
exploring ideas
03:38
shouldn't be held back
by infrastructure costs.
03:42
With these enhancements, the
Foundation Models framework now
offers a single API
03:48
that supports any model you
need.
03:49
In addition to features you
build within your apps, Apple
Intelligence can also
03:53
surface your app
in more places across the
system,
03:57
giving users more ways to
discover and return to it.
04:00
The App Intents framework
connects your app to Apple
Intelligence,
04:04
drawing on core
operating system technologies,
04:08
like the Spotlight semantic
index.
04:09
It organizes and surfaces
personal context from any
supported app.
04:14
The app toolbox,
which identifies features
04:17
available across apps
to serve a user request.
04:20
And the system orchestrator,
which coordinates it all
04:23
while protecting user privacy.
04:25
Together, in-app and system-wide
intelligence unlock experiences
that
04:30
neither could deliver alone.
04:32
Your apps made more powerful by
intelligence.
04:34
And intelligence made more
meaningful by your apps.
04:40
Let's dive into these frameworks
and see how they'll transform
04:44
what your apps can do.
04:46
Here's Richard and Mary Beth.
04:50
The Foundation Models framework
is a native Swift API
04:54
that gives you direct access
04:55
to the same on-device model that
powers Apple intelligence.
04:58
And many of you have already
adopted it, creating experiences
for shopping apps
05:03
like Wayfair,
educational apps like CellWalk,
05:05
local sports apps like
CricHeroes and more,
05:09
all running on device
with no infrastructure costs
05:12
or privacy trade-offs.
05:13
It's amazing to see how you've
pushed the limits of what an
on-device model can do.
05:19
We've got exciting updates for
you.
05:21
Let's start with a preview of
the intelligence-powered
features
05:24
you will be able to build today.
05:26
Mary Beth, over to you.
05:27
This year, we're building a
sample app all about the
Japanese paper craft of origami.
05:33
It's a place to unwind and get
creative with paper.
05:35
I'll give you a quick tour.
05:37
Our app starts with a beautiful
gallery of my origami projects.
05:41
And what's special about these
is that I've used foundation
models
05:44
to tailor origami projects
to match a person's interests
and materials
05:49
with step-by-step feedback.
05:51
Of course, it's more fun to
craft with friends.
05:54
So our app has a built-in chat.
05:56
It's a fun focused place to plan
meetups and talk about crafting.
05:59
Now I'm working on a cool
feature to combine people's
interests
06:03
into an origami project.
06:05
Here, I'll take this paper
Rachel's bringing and mix in a
photo of my dog
06:11
to generate a fun project
for us all to fold together.
06:14
With Foundation Models
framework, my app analyzes the
inspiration pictures
06:18
to get a sense of the materials
I have and this dog theme I have
in mind.
06:22
It even translates the Japanese
text and uses all of this
context
06:27
to brainstorm a few options.
06:29
I'll choose this one.
06:31
The intelligence keeps going in
a fully interactive tutorial.
06:35
That's a quick preview.
06:37
Let's talk about the framework.
06:39
This year, we're taking
the Foundation Models framework
06:42
to the next level.
06:43
First, you get new capabilities
like multimodal prompts with
text and images.
06:49
This opens up new categories of
experiences you can build
06:53
with image understanding.
06:55
It's as simple as attaching an
image to your prompt.
06:58
In addition to this, the Vision
framework is now integrated,
07:02
giving you purpose-built tools
the model can use,
07:05
such as OCR for precise text
extraction,
07:08
and barcode readers for quick
code scanning all on-device.
07:13
Next, let's talk about server
models.
07:16
On-device models are incredibly
useful for many tasks.
07:19
Yet sometimes you might want a
larger model for a more complex
workflow.
07:23
That's why we're extending the
framework so you can easily call
server models
07:28
like Claude, Gemini, and more
07:30
to use features like tool
calling and guided generation.
07:34
And any model provider can
create a Swift package that
conforms
07:36
to the Language Model protocol.
07:40
So you can pick the one you want
for your app.
07:42
In addition to this, we're
opening up access for those of
you
07:46
getting started with AI
to use the Apple Foundation
Model
07:49
running on Private Cloud Compute
with no cloud API cost,
07:54
giving you access to
frontier-level intelligence
07:57
while ensuring your user's data
is not stored or accessible
08:01
to Apple or anyone else.
08:02
Your users will have access to
features leveraging the cloud
model every day,
08:07
and iCloud+ subscribers
will have expanded access.
08:11
No matter the model you want to
use, you can easily swap it in.
08:15
This makes
the Foundation Models framework
08:18
the best way to run
any large language model in your
app.
08:22
With more modalities
and more models at your
fingertips,
08:25
the next thing you'll need
is more ways to put them to
work.
08:28
That's why we're introducing a
new open source Swift package,
08:32
loaded with pre-built tools
to help you get started
08:35
with concepts like skills and
utilities for context
management.
08:37
For example, a task management
app like Tiimo can use the
package
08:43
to pull in a skill that adapts
its tone and recommendations to
the user's data,
08:49
delivering a personalized brief
to help them stay on top of
their day.
08:53
This space evolves so quickly.
08:55
Tomorrow's abstractions may be
very different from today's.
08:59
So these utilities from
the open source package are
created
09:02
with new fundamental building
blocks called Dynamic Profiles.
09:07
These are new declarative APIs
in the Foundation Models
framework
09:11
for building truly adaptive AI
experiences with less code,
09:16
so you can orchestrate skills
and sub-agents,
09:18
swap tools in and out,
and update instructions on the
fly.
09:23
I'll walk you through how
Dynamic Profiles powers
intelligence in the Origami app.
09:29
First, let's open Xcode.
09:30
I'll start with a
LanguageModelSession, which many
of you already use.
09:34
Now, instead of creating a
session with a fixed model,
tools, and instructions,
09:37
with Dynamic Profiles,
09:40
you have the freedom
to continuously update your
session.
09:44
So I'll choose a profile for the
LanguageModelSession
09:47
and start with the familiar
Swift result builder syntax.
09:51
Here in the body, I'll define my
first Profile as a brainstorming
helper
09:55
that's going to generate project
ideas based on the photos I give
it.
09:59
I'll add modifiers to use
Private Cloud Compute language
model
10:03
with temperature cranked up
for creativity.
10:05
Now the beauty of a Dynamic
Profile is that this body will
always resolve
10:08
to just one Profile
driving my session at a time,
10:12
but I can switch between as many
Profiles
10:16
as my feature needs in the same
session.
10:19
So I'll change Profile
based on my app state.
10:21
Then I can add in a second
Profile to handle tutorial
generation.
10:26
Using Private Cloud Compute
again with reasoning level set
to deep,
10:31
since this is my most
challenging task.
10:33
Last, I'll add in a Profile that
explains any origami jargon,
like "valley fold",
10:38
that the user doesn't
understand.
10:42
This is a nice smaller task.
10:43
I can send the on-device
SystemLanguageModel
10:46
to save on server calls.
10:47
Let's see it in action.
10:48
Here in my tutorial, I can now
tap this term I don't
understand,
10:52
and the on-device model
generates a nice explanation.
10:56
In Dynamic Profiles,
I'm swapping out models,
10:58
but everything shares
the same continuous transcript.
11:01
This means more contextual
intelligence with less
prompting.
11:05
Now let's use that in my
Tutorial Profile.
11:07
Instructions and tools can be
swapped in and out as well.
11:10
So I'll use my app's view model
to check if the tutorial's been
generated,
11:15
and if so, I'll add in
instructions and tools to help
the model
11:19
give high-quality feedback
tailored to the user.
11:22
This body recomputes on every
model turn, so my session will
stay up to date.
11:26
Finally, do you see how my three
Origami Profiles look a bit like
three AI agents?
11:33
That's because Dynamic Profiles
are designed to be adaptable
building blocks.
11:38
So if you want to build AI
agents or skills
11:39
or any other high-level
abstraction, you can.
11:43
With the focus of flexibility
and composability, these new
APIs
11:48
from the Foundation Models
framework are here to grow with
you.
11:51
To help you bring all of this to
your apps,
11:54
you'll have access
to a complete set of tools,
11:56
from building to testing,
to shipping with confidence.
11:59
That includes the new
Evaluations framework,
12:02
which gives you the ability
to test your prompts and
validate
12:05
that your intelligence-powered
features work reliably.
12:09
The upgraded Foundation Models
instrument will help you
visualize and debug
12:14
model behavior in your apps.
12:15
And the new FM command line tool
lets you prompt the model right
from the terminal.
12:22
And there's so much more,
like a Python SDK,
12:25
tool calling with images,
and a new RAG tool
12:28
powered by Core Spotlight that's
private to your app.
12:31
That's the Foundation Models
framework, providing you
seamless access to
12:36
multiple models with all new
capabilities in the native Swift
API.
12:39
Plus, we're doing something big.
12:43
Later this summer, the framework
will be open source.
12:47
So the same Swift APIs you use
in your app can now run on your
server too,
12:52
giving you a complete end-to-end
AI workflow anywhere you deploy
Swift.
12:57
You've seen how the Foundation
Models framework connects to
third-party models,
13:01
Private Cloud Compute, and the
on-device model.
13:04
You have the flexibility you
need to get the right model for
the job.
13:07
And when you want to bring a
specific model into your app and
run it on device,
13:10
there's Core AI.
13:14
Core AI is a brand new framework
built right into the platform,
13:18
along with supporting tools
and technologies.
13:21
It's designed to be the best way
to bring and run models on
device in your apps.
13:26
It delivers uncompromising
performance through a modern
memory-safe Swift API,
13:31
with extensive tuning
capabilities from fine-grained
interest management
13:36
and model specialization
to custom GPU kernels.
13:39
And there are Python-based tools
alongside the framework, so you
can convert
13:43
and optimize your PyTorch models
for the Core AI runtime.
13:47
The framework is backed
by deep integration
13:50
into a new developer toolchain,
13:51
with ahead-of-time compilation,
dedicated Core AI instruments,
13:55
and a powerful visual debugger
to trace tensor values
13:58
directly back to your original
Python source code.
14:02
And it's engineered to scale
with your available compute.
14:06
So you can run a compact vision
model in your iPhone app
14:09
for real-time camera queries.
14:10
Or deploy a multi-billion
parameter LLM in a Mac app right
at your desk
14:15
to power an agentic assistant
for complex, multi-step
workflows.
14:21
Whatever the device, whatever
the model, it all runs on-device
14:25
with zero server dependencies
and zero token costs.
14:29
Core AI is optimized for
performance on Apple silicon,
14:32
and it empowers
Apple Intelligence experiences
14:35
across the system, including
Siri.
14:37
And this year, Apple
Intelligence offers even more
opportunities for developers.
14:40
Over to Lori.
14:44
Apple Intelligence draws on
personal context from across
apps,
14:47
understands what's on screen,
and can take actions to get
things done.
14:52
And now you can integrate
with its capabilities
14:54
through the App Intents
framework.
14:56
It's how our platforms
understand what your apps can
do.
14:59
With it, you can make
your app's content easier to
find
15:02
and its capabilities easier to
use
15:04
through the Action button,
Shortcuts, widgets, and in Siri
AI.
15:09
App Intents schemas make
integration with Siri's
capabilities easy.
15:11
Schemas are recognizable
structures that Siri understands
deeply,
15:18
built on years of language model
training.
15:20
We provide entity schemas
15:21
for describing the content and
concepts your app works with,
15:25
and intent schemas for
describing the actions it can
perform.
15:29
Entity schemas enable personal
context understanding.
15:32
By contributing your app's
content to the Spotlight
semantic index,
15:35
you can help your users find
information from your app
quickly and easily
15:40
with attribution back to your
app.
15:42
The indexing keys for important
content properties are built
right in,
15:46
which means more understanding
from less code.
15:48
Siri's understanding of intent
schemas means people can make
requests naturally.
15:53
They don't need to learn
specific phrases
15:55
and you don't have to define
them in your code.
15:57
Schemas cover common app
categories
15:59
like task management,
photo editing, and
communication,
16:02
and include a whole set
of system-supported actions.
16:05
Just adopt the relevant intent
schemas for the actions your app
can perform
16:09
to make them available to your
users.
16:11
And because these schemas
are system-defined,
16:14
they'll benefit from future
updates.
16:16
That means as Siri's language
understanding evolves
16:18
or as we add new support for
languages or regional dialects,
16:21
your intents will work there
too, without any changes to your
code.
16:25
Combining these capabilities
with the new View Annotations
API will let your users
16:30
reference and take action on the
content in your app when it's on
screen.
16:34
So your users can interact with
your app conversationally,
16:37
saying what feels natural to
them, not commands they have to
memorize.
16:41
Now, I'm going to show you how
we've made our Origami app work
with Siri.
16:45
I already have some entities and
intents that describe my app's
content
16:48
and actions, and the entities
conform to the IndexedEntity
protocol,
16:53
so they can be indexed into
Spotlight.
16:54
By also conforming to an entity
schema, Siri will be able to
discover and reason
17:00
over my app's content.
17:01
I'll make sure my Message,
Contact, and Conversation
entities all conform
17:05
to the relevant entity schemas
by using the @AppEntity macro.
17:09
I'm indexing these entities into
Spotlight when my app finishes
launching
17:12
to make sure everything's in
sync.
17:14
I've rebuilt to get the latest
changes, and now let's see what
I can do,
17:18
even when I'm not in the app.
17:20
Hey Siri, who's coming to
origami night?
17:24
Siri: Based on your messages in
Origami, it looks like Kevin,
Mary Beth, Rachel,
17:34
and Richard are discussing
origami night.
17:38
What's Richard bringing?
17:40
Siri: Richard mentioned he is
thinking of bringing pizza.
17:42
Awesome.
17:44
But now I want to follow up,
which means I need to act on
this information.
17:47
I can make the content Siri
found actionable by conforming
an intent
17:52
to the sendMessage schema.
17:54
This time I'm using the
@AppIntent macro,
17:56
since this is an action
rather than content.
17:58
I'll build and run again, and
now I can say, Siri, text
Richard,
18:04
"Can you make one of the pizzas
vegetarian?"
18:07
Siri: From Origami: Ready to
send it?
18:12
Yes.
18:14
Siri: It's sent.
18:16
Great. Message sent.
18:17
I'd also like to let people
reference what's on screen in my
app
18:20
just by saying "the second
message" or "this photo".
18:23
The new View Annotations API
lets me associate my views with
entities,
18:27
which can then be passed
to my app's intents, making them
actionable.
18:31
My Message List view contains
all the individual messages in a
conversation.
18:35
I can use a new view modifier
to map each message row
18:39
to its respective MessageEntity.
18:42
Let's try it out.
18:43
Hey Siri, send this photo to
Kevin and say,
18:46
"Rachel got us some paper
to practice our folds.
18:49
What color would you like?"
18:51
Siri: From Origami:
Ready to send it?
19:00
Yes.
19:01
Siri: It's sent.
19:03
And Siri sends the photo with my
message.
19:05
By combining personal context,
common app actions,
19:09
and on-screen awareness,
19:09
your app can become part of
the intelligent fabric of the
system.
19:13
Through Siri, users can access
it through natural language,
19:16
discover it through semantic
search,
19:18
and integrate it
into their daily workflows.
19:21
Now, back to Josh.
19:23
This is our vision for an
intelligent platform.
19:27
Rich, native experiences and
intelligent natural language
interfaces
19:33
working together.
19:34
As app developers, this
represents an incredible
opportunity.
19:37
You can enhance your app's
experiences through natural
language with Siri,
19:42
build powerful AI features
with the Foundation Models
framework,
19:43
and even run your own models
on-device with Core AI.
19:50
If you're using a custom model
to power a feature within your
app,
19:55
Core AI is the right technology
to use.
19:58
Your models will perform
efficiently across all devices,
20:02
and it's built into the
platform, so your apps always
benefit
20:06
from the latest fixes and
enhancements.
20:08
And if you're an enthusiast who
is experimenting with, training,
researching,
20:13
or fine-tuning generative
models, or if you're running a
local inference server,
20:18
our array framework, MLX,
makes it easy to explore
20:22
cutting-edge innovations
and technologies.
20:25
It now supports Metal 4, GPU
Neural Accelerators, and it can
even scale
20:30
training across multiple Macs
with RDMA over Thunderbolt.
20:35
It's all open source and it's
faster than ever.
20:38
The breadth of capabilities
offered by Apple Intelligence
and powered by
20:42
Apple silicon makes Apple's
platforms the best place to
build and deliver
20:44
the next generation of
intelligence-enhanced apps and
games.
20:52
Now let's take a look a level
deeper at what makes all of this
possible -
20:56
the systems your apps depend on,
from the frameworks you call
21:00
to the processes that schedule
your work, manage your memory,
and render your UI.
21:05
We took an especially close look
at the performance and quality
21:09
of these foundations, and you'll
see a multitude of platform
improvements
21:14
in this year's releases.
21:14
When you rebuild with the new
SDK, your apps will launch
faster
21:20
and feel more responsive.
21:21
You'll see refinements and
platform improvements across
frameworks media,
21:25
search, and accessibility,
enhancements to Swift and
SwiftUI, and a lot more,
21:32
especially around design.
21:35
Last year, the new design
with Liquid Glass
21:37
brought a unified design
language
21:39
built for a world where your
experience moves across devices.
21:43
The new design is making apps
more expressive and delightful
21:45
while staying instantly familiar
to users.
21:50
It looks great in apps like Tide
Guide, where subtle, interactive
highlights
21:55
respond as users scroll through
tide data and charts.
21:59
And SketchPro, where translucent
brush panels and controls
22:02
let artwork show through, even
while you switch between tools.
22:07
Throughout the last year,
we've been refining the design,
22:10
and that journey continues
22:11
with a new set of design updates
in the 27 releases.
22:15
Apps that have already adopted
Liquid Glass benefit
22:18
from many of these improvements
automatically.
22:21
To tell you more, here's Cindy.
22:25
In this year's releases, you'll
see updates to the foundations
22:28
of how Liquid Glass is built,
refinements to the new design
22:32
that improve consistency,
and new ways for iOS apps
22:36
to adapt across devices
and screen sizes.
22:40
Let's review the changes you'll
see in your apps.
22:42
To maintain exceptional
readability, we tuned Liquid
Glass
22:45
so it more effectively diffuses
complex content behind it.
22:49
And to establish more depth and
separation, we also introduced
22:52
a darkened edge
along with brighter specular
highlights.
22:56
We also made it more
personalizable with a new slider
in settings
23:00
to adjust Liquid Glass
anywhere from ultra clear to
fully tinted,
23:04
allowing users to choose the
look that works best for them.
23:08
Apps already using Liquid Glass
get these improvements
automatically
23:11
when they run on this year's
releases without even needing to
recompile.
23:15
Liquid Glass seamlessly adapts
to a variety of accessibility
settings
23:19
users may choose, such as
reducing transparency or
increasing contrast.
23:24
And now macOS 27 also supports
the "show borders" environment
value,
23:30
just like iOS.
23:30
So you can adapt your macOS
app's custom controls for this
setting as well.
23:35
Sidebars expand to the edges on
Mac and iPad, providing clearer
structure
23:40
while still refracting content
from your app and the wallpaper.
23:44
And icons in the sidebar regain
their color using your app's
accent color,
23:46
giving your app more personality
and making it more clear which
window is key.
23:53
List and Label APIs provide
these updates automatically
23:57
and support customizing
the tint per item.
24:00
And every window on macOS now
also has the same tighter corner
radius,
24:05
ensuring greater consistency
across all apps.
24:08
When content scrolls under
floating bars, a uniform toolbar
appears across the top
24:14
and keeps the text legible
while improving contrast.
24:16
This effect is applied
automatically for standard
toolbars
24:21
and can be customized using
the existing scroll edge effect
APIs.
24:25
We also thought about how icons
and menus can be used
intentionally
24:30
to call attention to
the most important actions,
24:33
both on macOS and iPadOS.
24:35
While icons are hidden by
default, there's an API to show
icons
24:40
for key app actions.
24:41
We're also updating how Liquid
Glass shows up in icons,
24:45
making them sharper and more
defined.
24:47
This updated rendering applies
to all app icons,
24:51
and we've introduced new
features such as refraction
24:54
that can be selectively
used for added character.
24:58
And with Icon Composer,
you can now design your icons
25:01
out of multiple layers
of Liquid Glass.
25:03
It's been updated with new
annotation features to add
refraction
25:08
or dial in Liquid Glass content
effects.
25:10
And it provides an interactive
preview of how your icon will
look
25:14
on earlier releases.
25:15
Together, these updates
culminate in a more focused and
approachable experience
25:17
across your apps and across
platforms.
25:24
Next, let's talk about app
adaptability.
25:27
iOS apps show up in more places
than ever,
25:30
on iPad as an iPhone app, or on
Mac through iPhone Mirroring.
25:34
When your iOS app shows up in
these other contexts with larger
displays,
25:39
users want to be able to take
advantage of the extra space
25:43
to see more information.
25:44
So this year we're introducing
support to resize iOS apps
25:47
in iPhone Mirroring and on iPad.
25:52
Let's see how this works
with the Origami app.
25:54
Once you rebuild with the latest
SDK,
25:56
your app is automatically
opted in to resizability.
25:59
Since Origami is a SwiftUI app,
it's already taking advantage
26:02
of scene lifecycle and standard
framework support for basic
resizability.
26:07
If you're already using SwiftUI,
Auto Layout, or responding to
26:11
size class changes, you are
well on your way
26:13
to supporting full resizability.
26:15
If you have custom views, you'll
want to update them to using
auto layout
26:17
and trait collections
for layout decisions.
26:22
Using the new resizable iOS
simulator and Previews,
26:26
you can test across a variety of
screen sizes right in Xcode,
26:30
so you'll see exactly
how your layout performs.
26:32
And we're providing a skill for
coding agents that will help you
find and fix
26:37
common resizability issues.
26:39
Now, instead of designing for
specific devices and
orientations,
26:43
you're designing for a dynamic
range of sizes and aspect
ratios.
26:48
To provide the best experience
when using iPhone Mirroring,
26:51
update your app to be able to
adapt and support any size.
26:55
Resizable simulator, Previews,
and iPhone Mirroring all make it
easy
27:00
to ensure your app is as dynamic
and flexible as possible.
27:04
Next, let's talk about SwiftUI.
27:07
Here's Franck.
27:08
SwiftUI is the best way to build
apps for any Apple device.
27:13
We designed SwiftUI to capture
everything we know
27:17
about building great apps
on our platforms.
27:18
It gracefully handles the
complexities
27:22
of layout, animation,
and platform integration
27:26
so you can focus on what makes
your app yours.
27:30
And as new capabilities like
Liquid Glass are added, apps get
these features easily
27:37
because they're designed
with SwiftUI in mind.
27:40
New apps like The Goat
are built with SwiftUI
27:43
because they want to feel
truly at home on Apple
platforms.
27:46
The Goat is a game development
environment that brings the open
source Godot engine
27:48
to Apple devices.
27:52
It started on iPad, expanded to
iPhone, and when the time came
to bring it to Mac,
27:58
it felt completely natural.
28:00
And apps that previously used
cross-platform or web
technologies
28:04
like Notion are migrating
their user interface to SwiftUI
28:09
because they want a level of
performance and UI consistency
28:13
that other technologies can't
deliver.
28:16
With powerful agentic coding
tools, porting code to Swift
28:19
has never been easier.
28:22
Of course, we reach for SwiftUI
ourselves whenever we build
apps.
28:27
For example, SwiftUI made it
easy to build a new Siri app by
enabling us
28:32
to share code across all our
platforms and Creator Studio
apps like Logic Pro,
28:39
build new features with SwiftUI
for high performance
28:43
and cross-platform support.
28:44
Since we rely on SwiftUI
ourselves, every improvement we
make for our own apps
28:49
becomes an improvement
for your apps too.
28:55
And this is a big year for
SwiftUI.
28:57
With richer interactions that
help you write less custom code,
29:01
with speed making your apps
much faster,
29:05
and finally, with new
capabilities for your apps.
29:09
Let's start with interactions.
29:11
This year, SwiftUI brings more
dynamic interactions to your app
29:15
like reorderable containers,
which makes it super easy
29:19
to add drag
to reorder to any container.
29:22
Building a grid reordering
experience outside of lists,
like with this grid
29:27
in the Origami app,
used to require a lot of code.
29:31
Now, it is just as simple as
adding .reorderable() to your
ForEach
29:37
and .reorderContainer()
to the parent.
29:40
And just like that, I can
customize the order of my
Origami models.
29:45
SwiftUI handles the lift and the
drop animations and it works
with any container
29:50
like grids and stacks.
29:53
Now, for Origami models I feel a
little less proud of,
29:57
SwiftUI now supports swipe
actions inside any container as
well.
30:03
I can delete a custom row with a
swipe
30:05
by adding the existing
.swipeActions() modifier to my
row
30:09
and .swipeActionsContainer()
to the scrollable container.
30:12
This provides great flexibility
for quick actions on my custom
row.
30:17
Finally, text selection
got more flexible too.
30:20
On iOS, it gains the same.
full-fidelity selection
30:26
already found
in TextField and TextEditor.
30:29
And on macOS, it now supports
custom text renderers, text
vibrancy,
30:36
and vertical text.
30:37
Next, let's take a look at
speed.
30:40
This is always a priority for
us, but even more so this year,
30:44
and you will see many
improvements without any changes
on your end.
30:49
To start, we've been gradually
unifying the architectures of
SwiftUI, AppKit,
30:55
and UIKit, and this year, they
share a common foundation across
many controls.
31:01
So wherever your app is running,
31:03
they can benefit from
the same on-the-line
improvements.
31:07
For example, menu pickers on
macOS
31:10
are now better equipped
to smoothly handle large lists
of items.
31:15
And in nested stack layouts,
31:17
whereas SwiftUI used to
measure each child multiple
times
31:20
to resolve their flexibility,
it now short-circuits
computations
31:25
where they're not needed,
31:27
meaning layouts now resize
up to twice as fast.
31:30
And nothing saves performance
like avoiding unnecessary work.
31:34
SwiftUI now only initializes
state objects when they're first
loaded.
31:40
Previously, a new temporary
instance of the state object
would get created
31:46
every time the view is
reinitialized.
31:48
You get this improvement for
free because state is now lazy
under the hood
31:51
and was converted
from a dynamic property to a
macro.
31:57
And when it comes to loading
images, AsyncImage avoids
redundancies as well.
32:03
It now caches its content
automatically using standard
HTTP caching,
32:09
so images are downloaded once
and only re-fetched when needed.
32:13
Finally, let's talk about new
capabilities starting with
toolbars.
32:18
With the new resizability
features, optimizing your app
for a dynamic range
32:21
of sizes and aspect ratios
is more important than ever.
32:29
And toolbars are central
to that experience.
32:32
This year, SwiftUI gives you
finer control over how toolbar
items adapt to space.
32:39
Use the new visibilityPriority
modifier to mark your most
important items high.
32:45
And SwiftUI keeps them visible
longer as space shrinks.
32:49
Less prominent actions, like
archive or delete, can be added
to
32:52
the new toolbars overflow menu
container, which groups them in
an overflow menu.
32:59
And finally, the new
topBarPinnedTrailing placement
anchors items
33:04
to the trailing edge,
no matter how the toolbar
reflows.
33:07
Now, when I resize the window,
the toolbar stays organized
exactly how I want.
33:14
Important buttons stay visible.
33:16
Deprioritized ones are in
the overflow menu and share is
always pinned
33:22
to the trailing edge.
33:23
Tabs can also be distinguished
with the new prominent tab role
33:28
pinning the tab
to the trailing edge of the
screen.
33:31
SwiftUI also opens up new ground
for document-based apps
33:35
with a new document
infrastructure that provides a
ton of functionality
33:41
out of the box,
like first-class URL access
33:44
for fully customizable
reading and writing to disk,
33:48
the kind that powers apps
like Xcode or Pages.
33:51
For example, with direct access
to the file URL, you now have
the flexibility
33:57
to read just the parts of a file
you need and write only the
pieces that changed,
34:03
not the entire file.
34:05
You can also observe and update
document attributes
34:08
using the provided
observable configuration.
34:11
The new document API integrates
deeply with modern Swift,
34:15
with support for observation,
Swift concurrency, and so much
more.
34:21
Lastly, here is something pretty
awesome.
34:22
The Spatial Preview framework
gives Mac apps new ways
34:28
to extend in space around users
wearing Apple Vision Pro.
34:32
When you adopt this new API in
your app, a 3D model can become
spatial
34:37
when you stream to Apple Vision
Pro, allowing your users to
preview, edit,
34:43
and share objects and models
in real time.
34:46
Beyond those we've mentioned
already, there are many other
new improvements,
34:51
including better type checking
performance with content
builders,
34:53
a new alert binding API, and to
support adjusting cross-fade
transitions.
35:01
Together, these platform
improvements bring more speed,
richer interactions, and
35:07
powerful new capabilities to
SwiftUI that you can take
advantage of.
35:12
Now, let's take a look at Swift
itself.
35:16
Here's Holly.
35:16
Swift is designed to be the
language you reach for at every
layer of the stack.
35:21
Whether you're building
full-featured mobile apps,
internet-scale services, or
35:23
embedded firmware, Swift helps
you write code that's fast,
expressive, and safe.
35:31
Swift's performance, depth, and
unmatched interoperability make
it the natural
35:36
successor to C and C++ for
low-level systems and server
programming.
35:42
And its approachability and
expressiveness make it ideal for
higher-level development
35:48
like apps and frameworks.
35:49
We think Swift is the only
language with this breadth.
35:52
That's what makes Swift a
language you can keep reaching
for as your stack grows.
35:57
Including outside Apple
platforms, where the tools for
development on Linux,
36:02
Windows, Android, and the web
are available on Swift.org.
36:07
Many of you are extending your
use of Swift to additional
platforms
36:11
and the server so you can reuse
code and benefit from Swift's
high performance
36:16
across your entire stack, like
Flighty, which uses Swift in
their services
36:21
to share the code that tracks
airport visits
36:23
between the app and backend.
36:25
Or GoodNotes, which uses Swift
for WebAssembly to bring the app
to the web,
36:30
Chrome OS, Android, and Windows,
reusing over 100,000 lines of
code.
36:35
Or Frameo, which uses Swift-Java
interoperability to share Swift
libraries
36:40
between the iOS app and the
PhotoFrame software written in
Java.
36:44
Interoperability means you can
bring Swift into C, C++, and
Java systems
36:51
you already have.
36:51
So you can get Swift's benefits
at every layer without a
rewrite.
36:54
At Apple, we've been building
with Swift at every layer of our
own stack.
37:01
Foundation paved the way
for Objective-C frameworks
37:04
to move to native Swift
under the hood.
37:06
AppKit and UIKit have followed
suit by using Swift and SwiftUI
extensively
37:12
in their implementation.
37:13
WebKit, the open source web
engine that powers Safari,
37:16
is a large and security-critical
C++ code base.
37:20
Using Swift's safe C++
interoperability, WebKit is
replacing core components
37:25
with Swift versions
incrementally.
37:28
In the networking stack, the
QUIC transport layer was
rewritten in Swift.
37:32
Later this month, the project
will be open sourced and
available
37:36
for cross-platform use
hrough SwiftNIO integration.
37:40
You can follow along or get
involved
37:42
through the vibrant
open source community on
Swift.org.
37:45
Further down the stack, more
security and performance
critical systems
37:50
moved to Swift this year.
37:51
The TrueType font rendering
engine replaced decades of
hand-optimized C
37:55
with Swift code that's not only
memory safe, but also faster.
38:00
At the lowest level, we've
written hundreds of thousands of
lines
38:04
of Swift code across bare metal
firmware, coprocessors, and
drivers.
38:08
For the 27 releases, we've
started writing parts of the
core operating system kernel
38:15
in Swift.
38:16
As Swift becomes more capable in
these domains, we're staying
true
38:20
to one of Swift's most important
design goals:
38:24
it's fun.
38:24
It's natural to write and
iterate on your ideas in Swift,
and the compiler is there
38:30
to catch mistakes along the way.
38:32
The latest updates are focused
on improving your workflow
38:35
so you can focus on the fun
part:
38:38
writing great code with
confidence.
38:40
Swift 6.4 is here, built to make
everyday tasks feel effortless.
38:46
I'll show you just a few
examples.
38:47
When your code base is
undergoing a migration or
incremental adoption
38:51
of new features, sometimes it's
not realistic to address all
compiler warnings
38:56
across your project at once.
38:58
You can now suppress warnings in
specific parts of your code, and
you can promote
39:03
warnings to errors in places
where you want strict
enforcement.
39:07
Availability attributes can get
long and repetitive when you're
writing code
39:11
for multiple Apple platforms.
39:12
Now, instead of listing out
every Apple platform with the
same version number,
39:18
you can simply write
'anyAppleOS'.
39:20
The limitation on async calls
in a defer block is gone,
39:25
and awaiting inside a defer just
works.
39:26
No matter what you're building,
Swift's compiler diagnostics
39:31
are a daily companion,
helping you catch mistakes early
39:35
and guiding you toward correct
code.
39:37
If you've spent time writing
Swift code,
39:39
you've probably encountered
this error message:
39:42
"The compiler is unable to type
check this expression in
reasonable time."
39:46
This can happen in complex
operator expressions, closures,
39:50
or in deeply nested
SwiftUI view bodies.
39:54
This is frustrating,
and we've made it a lot better.
39:56
In many common cases, code that
hit this fallback error will now
either
40:02
compile successfully or give you
a more actionable error to work
with.
40:07
We know this area is important
for a smooth workflow,
40:10
and we're continuing to invest
in it.
40:12
Swift 6.4 makes you more
productive in day-to-day code,
40:15
and it brings that same care
to the more specialized corners
40:19
of your project.
40:20
There's never been a better time
to go full stack with Swift.
40:24
Now back to Josh.
40:26
So those are the platform
improvements in this year's
releases.
40:31
Now, to move ahead, sometimes we
have to leave something behind.
40:35
As we said last year, macOS
Tahoe was the final release to
support Intel Macs.
40:40
The transition of macOS to Apple
silicon is now complete,
enabling us to focus
40:46
on a single architecture
across the entire ecosystem.
40:50
This can benefit your apps as
well.
40:52
You can now ship Apple
silicon-only binaries on the Mac
App Store,
40:56
reducing your app's download
size and letting you focus your
testing
41:01
on a single architecture.
41:02
And with all the refinements to
the new design with Liquid
Glass,
41:05
it's time to complete
your migration there too.
41:08
We'll be removing support for
opting to use the old design.
41:12
So once your app is recompiled
with Xcode 27, it will
automatically
41:16
begin to use the new design
with Liquid Glass.
41:20
With so many improvements across
the system, your apps and games
41:24
will look and feel better than
ever on this year's releases.
41:27
Now, let's turn to your
productivity and the tools you
use
41:32
to build with and for our
platforms.
41:35
Intelligence is deeply
transforming how you write code,
41:38
add new features, and build
apps.
41:41
Last year, we brought AI coding
assistance to Xcode,
41:45
and so many of you embraced it
immediately.
41:48
It's helping you write code
faster and adopt new APIs more
easily.
41:52
This space moves really fast, so
we've picked up the pace of our
releases,
41:57
delivering new Xcode
capabilities to you faster than
ever before.
42:02
Earlier this year, we brought
coding agents to Xcode, along
with tools allowing
42:07
agents to grab a preview, search
documentation, and more,
42:12
powered by the
Model Context Protocol.
42:14
With MCP, Xcode also connects to
the tools you already use,
42:18
from design apps like Figma
to services like GitHub.
42:22
And Xcode includes a built-in
integration for agents from
Anthropic, OpenAI,
42:28
and now Google.
42:30
Today, Xcode adds support for
Agent Client Protocol,
42:33
so you can bring any compatible
agent into Xcode.
42:37
ACP support and Gemini
integration
42:39
are shipping in an update
to Xcode 26 available today.
42:43
And there's more
coming in Xcode 27.
42:46
Here's Ken.
42:48
From the first line of code
to the App Store,
42:50
Xcode is where you build
the best apps for Apple
platforms.
42:53
Millions of you live in it for
writing and debugging your code
42:57
with coding agents right
alongside,
42:58
designing interfaces in SwiftUI
and previewing them in real
time,
43:02
testing across devices and
simulators to catch issues
before your users do,
43:08
and profiling performance
with instruments, keeping your
apps fast,
43:13
responsive, and efficient.
43:15
This year, Xcode has two big
stories.
43:17
The first is intelligence, and
we have a lot to talk about in a
minute.
43:22
The second is the daily
experience, how Xcode feels to
use.
43:27
Now just like you, we spend
hours in Xcode every day.
43:29
We build all our operating
systems and apps with it.
43:35
In fact, we build Xcode with
Xcode.
43:38
So it needs to feel like home
while being fast, fun, and
personal.
43:43
And we've heard your feedback
and improved Xcode across the
board.
43:48
It's faster at loading projects.
43:51
We fixed top crashes and spins.
43:53
Debug sessions are more
reliable, with faster expression
evaluation,
43:58
and a console that can handle
more intensive logging without
hitching.
44:03
Xcode 27 is 30% smaller.
44:06
Now, Apple silicon-only,
44:08
with agents, documentation, and
other components downloading in
the background,
44:13
so you're always up to date.
44:15
Now, let's take a look at the
experience.
44:17
First, your Xcode settings are
now automatically saved to
iCloud.
44:21
When I'm setting up a new Mac
like this, Xcode offers to
import them.
44:26
I'll pull in the settings from
my iMac.
44:29
I can sign in with my Apple ID.
44:31
Xcode fills in my Git config
too.
44:33
And just like that, I'm ready to
code with my new Mac.
44:37
Now, let's create a new project.
Watch this.
44:39
I'll select new project, then
app and boom, I'm in the editor.
44:45
No file name, no bundle ID, no
setup.
44:49
Of course I can specify all
those things later when I'm
ready.
44:52
This is great for exploring an
idea, a new API, or prototyping
a view.
44:59
Alright, now I'll open the
Origami project.
45:02
Xcode 27 looks beautiful with
the design refinements of macOS
27.
45:09
Crisp and clean.
Let's customize it.
45:13
In Xcode 27, you can make
the toolbar your own.
45:16
It's easy to rearrange things,
so I can add what I need and
remove what I don't.
45:21
The activity view is now tucked
neatly into the document title
over here,
45:25
so there's even more room
for the things I want.
45:28
The navigation buttons,
canvas toggle, editor splits,
45:30
they're all right up here
on the toolbar.
45:34
Now I'll add a shortcut to
quickly create a new coding
assistant conversation
45:38
and that'll be useful
a little bit later.
45:41
Next and super fun, themes.
45:44
Color now flows throughout the
entire app, not just the editor.
45:48
You can personalize everything
from the background to syntax
colors
45:53
and dial in that perfect shade
of purple for your keywords.
45:56
And Xcode 27 comes with
gorgeous new choices.
46:00
Let me show you a few of my
favorites.
46:02
Emerald.
That feels fresh.
46:05
You can almost smell it.
46:06
How about something
with a little bit more energy?
46:10
Neon Noir.
Electric. Love it.
46:14
Light or dark?
Every theme supports both.
46:17
Here's Coral Reef.
I feel relaxed already.
46:20
And when I'm working on multiple
projects at the same time,
46:24
I can set a different theme for
each.
46:26
Makes it super easy to tell them
apart at a glance.
46:29
All right, let's get back to
work.
46:30
Next, Xcode Cloud, which gives
you continuous integration and
delivery
46:36
built right into Xcode.
46:38
I'll set up my Origami project
to use it.
46:40
I'll click get started, grant
access to my repository, and
that's it.
46:45
I can kick off my first cloud
build.
46:48
No App Store Connect setup
needed.
46:50
And Xcode Cloud builds
are up to twice as fast,
46:54
now supporting Apple Vision Pro
and apps using Metal on Apple
silicon.
47:00
Next, Previews.
47:01
They are the best way to iterate
on UI and the easiest way to see
47:05
how your views look across
variants, like accessibility
sizes, orientations,
47:11
and localizations.
47:12
And now you can see variations
for any property.
47:15
I'll open this view here
that shows a craft note.
47:18
It renders differently based on
the CraftState enum,
47:21
which has four different values.
47:23
Now, I can pass that enum to the
preview and just like that -
47:27
I get a grid showing all the
states of my UI.
47:31
All four in one glance.
47:31
Next, another one I'm excited
about.
47:35
When testing your app, you use
real hardware to evaluate
performance,
47:40
use sensors,
and test real-world conditions.
47:42
And you use simulators to cover
older OSes and devices that you
don't have.
47:48
Xcode 27 brings both together in
the new Device Hub.
47:53
It replaces Simulator and it
does a whole lot more too.
47:57
Let me show you.
47:58
When I first run my app, the
window looks like the Simulator
I know.
48:02
I can easily rotate, grab a
screenshot and jump back to the
home screen,
48:08
just like I'm used to.
48:10
When I extend the view, I can
now change device properties
48:13
and test how my app responds
to different system settings.
48:16
Like switching to dark mode,
increasing the font size, and
more.
48:20
We rebuilt the experience from
the ground up for the highest
fidelity possible.
48:26
So I can pinch to zoom, use
two-finger scrolling, and like
in Previews,
48:31
I can dynamically resize the
simulator to see how my iOS app
48:35
handles different sizes.
48:36
I can also manage and interact
with physical devices from the
same place,
48:41
like this iPhone here on my
desk.
48:43
I'll launch the Origami app
right here from my Mac.
48:47
And I can interact with it.
48:48
All the convenience of the
simulator with the fidelity of
real hardware
48:53
in a single place.
48:54
That is a quick look at the
experience in Xcode 27.
48:59
And beyond the experience,
the biggest changes this year,
49:02
the ones that will truly
accelerate you, are in
intelligence.
49:08
Kevin, over to you.
49:09
What a great time to be a
developer.
49:11
Intelligence is transforming
how you build apps.
49:14
Agentic coding, together with
Apple platforms, frameworks, and
tools,
49:20
helps you bring ideas to life.
49:21
Xcode 27 takes the next big step
in agentic coding, leveraging
the full power
49:27
of the best models and agents
directly into Xcode.
49:31
Agents are woven into every
layer of the Xcode experience,
49:33
from the way you interact with
them to a set of tools
49:37
that help you get the best
results.
49:39
Tools like understanding your
project, searching
documentation,
49:44
building, and testing.
49:45
And Xcode 27 helps you even more
with new tools
49:48
like rendering previews with
variants, interacting with the
simulator,
49:53
localizing your app,
debugging, and more.
49:57
And this goes beyond tools.
49:58
When using agents in Xcode,
every answer is grounded in
Swift,
50:03
SwiftUI, in Apple frameworks.
50:05
That's why, when building for
Apple platforms,
50:08
Xcode is the best place
to code with agents.
50:11
Let me show you what this looks
like across every stage of app
development.
50:15
From starting with an idea to
implementing and validating it,
to improving it,
50:20
like adding new languages
or fixing issues.
50:22
First, I'm gonna add something
fun to the Origami app.
50:26
My daughter, she loves
making origami with me.
50:29
I want to surprise her with a
feature
50:30
that makes up a little
choose-your-own-adventure story
50:33
about the characters
that we make together.
50:35
I'll start with a new
conversation with the agent.
50:38
I'll create one here from the
toolbar.
50:39
It opens right in the editor,
just like any other file.
50:44
Here's what I want to build.
50:46
In my Origami project,
50:46
I want a button that generates
a choose-your-own-adventure
story
50:50
for my daughter.
50:51
That alone would get me good
results, but I had something a
little more specific
50:55
in mind,
so I'll add some more details.
50:57
She'll start by picking some
options, like the setting and an
item to use
51:03
in the story.
51:03
The app will generate the first
page, and then let her pick what
comes next.
51:08
I want to use the latest
Foundation Models APIs
51:11
and present it with beautiful
typography.
51:13
When using a coding agent,
the best results come
51:16
from collaborating on the
implementation and design first,
51:19
before any code is written.
51:21
So I'll add /plan to the prompt.
51:23
And I'm gonna ask for a diagram
while I'm at it.
51:26
I find it easier
to review the plan that way.
51:29
Let's get this started.
51:30
The agent is exploring my
project using Xcode tools to
help it efficiently
51:34
understand my code base, its
architecture and patterns, to
find the best way to
51:39
build the feature, and it's
asking some clarifying
questions.
51:44
Do I want to persist it?
51:44
Yes. And how many options
for the next part of the story?
51:49
Two to three is good.
51:50
And the agent continues
to create the plan.
51:53
Let's skip forward in time.
51:54
My plan is now ready, and it
shows right next to the
conversation
51:59
in beautifully rendered
markdown.
52:00
It's very easy to review,
and I can also refine it.
52:03
Here, the current implementation
has a fixed set of settings and
items to choose.
52:09
I'd love if she could add her
own.
52:11
I'll add that as a comment.
52:14
And now the plan looks good.
52:16
Let's kick it off.
52:17
Now Xcode and the agent work
together to implement the plan.
52:20
Xcode shows everything that's
changing, like code and
previews.
52:24
As it runs, I can refine the
implementation.
52:26
Like here, I'm gonna add a fun
image filter to the story's hero
image.
52:32
It looks like Xcode is done
building my feature.
52:34
There's still a lot of code, and
the previews look great.
52:39
Let's just run it.
52:39
I'll open an Origami project,
tap the new toolbar icon, and
just like we asked,
52:46
page one offers
an item and a setting.
52:49
I'll pick a forest and a wand,
52:51
and oh look, there's the button
if I wanted to add my own.
52:54
And here's the first page of the
story with that gorgeous hero
image.
52:59
My daughter's gonna love this.
53:00
What was just an idea a couple
minutes ago is now something I
can run in my app.
53:05
This is amazing!
53:06
Now, building a feature is more
than writing code.
53:09
It's also making sure it does
what it's supposed to do.
53:12
Xcode 27 can help you with that
too, with new tools for agents
to check their work.
53:17
For example, agents can validate
the logic of your app by running
tests,
53:21
try ideas in isolation using
playgrounds, like experimenting
with APIs,
53:27
and check visual changes with
Previews in light and dark mode,
53:31
different orientations, text
sizes, or localizations.
53:35
And now agents can interact with
your app in the simulator.
53:40
Let me show you.
53:41
I want to test different
combinations of settings, items,
even customized ones.
53:46
Xcode launches Origami and
Device Hub and starts testing
those for me.
53:51
The agent can tap, swipe, and
type.
53:55
When it's done, I get a summary
of the tests, and I can see all
the screenshots
54:01
it created along the way.
54:02
And just like that, the Origami
app has a new story feature,
designed, built,
54:05
and tested end-to-end.
54:09
Next, let's see how we can use
agentic coding to improve our
app.
54:14
Agents in Xcode can help with
all kinds of engineering tasks,
like adopting new APIs,
54:21
making your app more accessible,
and more.
54:24
Let's localize our Origami app.
54:26
I'll start with French.
54:27
Xcode automatically adds a new
language to the strings catalog,
54:32
then works with the agents
to translate strings
54:35
across the entire project.
54:36
This is more than a
word-for-word translation.
54:39
Xcode looks at each string in
its context, the surrounding
code, UI, the action,
54:45
to find the best translation.
54:46
And when it's done, I can see
all the translations here in the
String Catalog.
54:52
Let's build and run.
54:53
My app is now localized!
54:56
Fantastique!
54:57
Building a great app also means
responding to the feedback and
data from your users.
55:02
The Organizer already gives you
insights into how your app is
doing
55:06
in the real world - crashes,
hangs, performance metrics,
55:10
anonymized and aggregated.
55:12
Now, you can use agents to help
you find issues that matter
most, and fix them.
55:17
I'll ask Xcode to pull up the
top crashes from the latest
release.
55:21
I get a list of crashes ranked
by how often they happen.
55:25
Oh, that first one is from an
update I pushed last week.
55:29
Let's fix it.
55:31
Xcode looks at the symbolicated
crash log, figures out where in
my project
55:36
this happens, identifies the
issue, reproduces the crash,
makes the fix,
55:44
and then validates it.
55:46
And just like that, our issue is
fixed.
55:48
That's agents at work with Xcode
across every stage of your
development, planning,
55:54
building, and improving.
55:55
You'll be amazed when you see
Xcode and agents bring your
ideas to life.
56:00
Finally, let's talk about what
makes all of this possible.
56:04
Xcode 27 ships with the
expertise of Apple's engineers
and designers
56:07
built right in as a corpus of
skills, documentation, and MCP
tools.
56:14
Think of them as specialists.
56:15
A SwiftUI specialist that knows
how to structure your view and
data flow.
56:19
An accessibility specialist that
knows what makes an interface
work for everyone.
56:24
Specialists for universal
sizing, testing, and
performance.
56:29
In fact, so much
of what we've seen to this point
56:31
is powered by one of these
specialists.
56:34
And you can bring your own!
56:36
Xcode integrates all of them
in the same way.
56:37
Plugins.
56:40
It's a format used by many
agents and widely adopted by the
community.
56:44
It's amazing to see how many of
these you have already been
building and sharing.
56:48
A plugin can contain skills,
just markdown files that teach
the agent new tasks.
56:54
It can contain tools using the
Model Context Protocol.
56:59
And we've added one new
capability to plugins.
57:01
With the Agent Client Protocol,
a plugin can bring an agent of
your choice.
57:07
Installing one is easy.
57:08
You can use the command line or
paste a git URL right into
Xcode.
57:12
And partners like Figma and
GitHub make it even easier to
set up with just one click.
57:18
And then I can put it all
together.
57:20
I can tell Xcode to implement a
Figma design in SwiftUI, refine
it for different
57:25
variants, make it resizable
using a skill, and post a PR to
GitHub.
57:31
How cool is that?
57:32
That's Agentic Coding in Xcode
27.
57:36
From an idea to an app, at every
step.
57:37
Built for how you create,
refine, and ship, and reach your
users
57:44
wherever they are.
57:44
We can't wait to see what great
things you make next!
57:48
Back to you, Josh.
57:51
It's a huge year for Xcode and
for many of our other developer
tools as well.
57:56
Like the all-new Reality
Composer Pro 3, which has been
completely rebuilt for
58:02
crafting production-ready 3D
experiences using RealityKit.
58:06
It brings support for character
animations, more realistic
lighting,
58:08
and live previews that let you
see the results of your edits
58:14
as you make them
using Mac Virtual Display.
58:17
And there's even more for game
developers in this year's
releases,
58:21
including a major update
to Game Porting Toolkit,
58:24
which dramatically cuts
the time it takes to bring games
58:27
to Apple platforms by adding
AI skills for coding agents.
58:32
And new Metal command line tools
give agents direct control
58:36
during development and
debugging, bringing best
practices
58:38
for game development on Apple
platforms to every step of your
porting journey.
58:45
So that's developer
productivity.
58:47
Across the 2027 releases, there
are so many new capabilities to
build on,
58:53
like the App Intents framework,
which lets you connect your app
58:56
to Apple Intelligence,
and the Foundation Models
framework
59:00
and Core AI,
which enable you to bring
59:02
powerful generative intelligence
features directly into your
apps.
59:07
There are platform improvements
across design, Swift, and
SwiftUI
59:08
that make your apps faster, more
flexible, and easier to build.
59:16
And Xcode has even more
expansive support for agentic
coding.
59:22
and we've only just
scratched the surface.
59:24
There are over 100 sessions to
dive deep into everything we've
covered today,
59:30
including Apple Intelligence,
Xcode 27, Design, and more.
59:35
All these sessions are available
on the Apple Developer app, the
website, YouTube,
59:39
and new this year on Bilibili.
59:43
And there's so much more
happening online throughout the
week.
59:48
Sign up for Group Labs, online
panels, and Q sessions
59:52
with Apple engineers and
designers.
59:55
And connect with us
on the Apple Developer Forums
59:57
to ask questions,
and follow the conversation
00:00
about the latest tools
and technologies.
00:02
And the opportunities to connect
extend well beyond this week.
00:07
You can Meet with Apple around
the world and online in hands-on
workshops, labs,
00:09
and events to learn and connect
as a community throughout the
year.
00:19
We love when we can meet you in
person.
00:21
And there are many opportunities
to do that in our Developer
Centers,
00:26
located in Cupertino, Shanghai,
Singapore, and Bengaluru.
00:31
And we're excited to announce
the opening of our fifth this
fall in Berlin,
00:36
home to one of Europe's most
vibrant developer and designer
communities.
00:39
We can't wait to see you there
or in one of our events online.
00:46
Whether this is your first WWDC
or your 25th, thank you.
00:52
Your work inspires and drives
us.
00:55
We use the apps and play the
games that you all build.
00:59
So, our greatest hope is that
everything we talked about today
01:03
will enable your next great idea
to come to life.
01:08
We can't wait to see what you do
next.
01:10
Enjoy WWDC.
01:14
Letras y Traducción
[Español]
Bienvenido al 2026
Plataformas Estado de la Unión.
Este es uno de nuestros favoritos
momentos del año donde llegamos
para compartir las novedades
con las tecnologías, el
marcos y las herramientas que
utilizas todos los días
para crear aplicaciones increíbles y
juegos.
Aplicaciones que nos inspiran,
que elevan el listón de lo que es
posible
y eso nos empuja
para construir aún mejor
tecnologías.
Nos encanta conectarnos con tanta gente
de ti.
Escuchar sobre tus pasiones,
sus desafíos,
y cómo podemos ayudarlo mejor
tu trabajo.
Tus comentarios dan forma a algunas de las
tecnologías más importantes que
nosotros construimos.
Y el año pasado, en ninguna parte
eso más cierto que con lo nuevo
diseño
con Vidrio Líquido
y con Apple Intelligence.
Ambos fueron temas muy importantes en
los 26 lanzamientos, y son claves
nuevamente este año,
con muchos de nuestros esfuerzos
influenciado por sus comentarios.
El diseño y la inteligencia son ambos
tan importantes porque ellos
mejora
lo que tienen de especial tus aplicaciones.
El cuidado y el oficio que
poner en ellos.
Con interfaces únicas
y experiencias ricas
moldeadas por su dominio profundo
experiencia.
Combinado con mejorado
capacidades de inteligencia, usted
ahora puede crear funciones
que no estaban disponibles anteriormente
posible.
Para resaltar las novedades,
profundizar en tres áreas clave.
Primero, Apple Intelligence, con
nuevas formas de traer generación
inteligencia
directamente en tus aplicaciones,
y nuevas integraciones
con inteligencia del sistema
para que los usuarios vuelvan a tu
aplicaciones.
En segundo lugar, mejoras en la plataforma,
con mejoras de diseño y más
diseño de interfaz de usuario flexible,
actualizaciones de Swift y SwiftUI,
y mejoras que hacen que tu
aplicaciones más rápidas,
más adaptables y más fáciles de
construir.
Y finalmente, desarrollador
productividad, tomando agentes
codificar aún más,
junto con mejoras que hacen
Xcode más rápido y más personal.
Tenemos mucho que cubrir, así que
empezar con Apple
Inteligencia.
En el corazón de Apple
La inteligencia es Apple.
Modelos de cimentación.
Trabajando junto con Google
y aprovechar las tecnologías
detrás de su familia Gemini de
modelos,
creamos la última
La Fundación Apple modela
para potenciar nuestra Apple Intelligence
experiencias y proporcionar incluso
mejor soporte
para las formas en que estás usando
Inteligencia en tus aplicaciones.
Adaptamos estos modelos para ejecutar
en el dispositivo y en la nube privada
Calcular.
Potencia de los modelos Apple Foundation
La inteligencia de Apple y tu
las aplicaciones también pueden usarlos
, a través de la Fundación
Marco de modelos.
Este año, el marco
capacidades se están expandiendo a
incluye entrada de imágenes y soporte
para modelos de servidor.
Entonces, si tienes
una tarea más compleja
que requiere los más avanzados
modelos de frontera
la API ahora se puede integrar con
el proveedor del modelo de nube de su
elección.
Para garantizar el inicio de una
El modelo de nube grande es como
lo más accesible posible,
incluso si estás escribiendo tu
primera aplicación,
desarrolladores con menos de
2 millones de App Store por primera vez
descargas
podrán usar
Modelos de Apple Foundation
ejecutándose en Private Cloud Compute
sin costo de API en la nube.
Es acceso al nivel fronterizo.
inteligencia con incomparable
protecciones de privacidad.
Porque empezar
La exploración de ideas
no debería limitarse
por los costos de infraestructura.
Con estas mejoras, el
Marco de modelos de base ahora
ofrece una única API
que admite cualquier modelo que usted
necesidad.
Además de las funciones que
construye dentro de tus aplicaciones, Apple
La inteligencia también puede
hacer emerger su aplicación
en más lugares del mundo
sistema,
brindando a los usuarios más formas de
descubrirlo y volver a él.
El marco de intenciones de la aplicación
conecta tu aplicación a Apple
Inteligencia,
aprovechando el núcleo
tecnologías del sistema operativo,
como la semántica Spotlight
índice.
Organiza y emerge
contexto personal de cualquier
aplicación compatible.
La caja de herramientas de la aplicación,
que identifica características
disponible en todas las aplicaciones
para atender una solicitud de usuario.
Y el orquestador del sistema,
que lo coordina todo
mientras protege la privacidad del usuario.
Juntos, en la aplicación y en todo el sistema
experiencias de desbloqueo de inteligencia
que
ninguno de los dos podría lograrlo solo.
Tus aplicaciones son más potentes gracias a
inteligencia.
Y la inteligencia hizo más
significativo para sus aplicaciones.
Profundicemos en estos marcos
y vea cómo transformarán
lo que pueden hacer sus aplicaciones.
Aquí están Richard y Mary Beth.
El marco de los modelos básicos
es una API Swift nativa
que te brinda acceso directo
al mismo modelo en el dispositivo que
impulsa la inteligencia de Apple.
Y muchos de ustedes ya lo han hecho
lo adoptó, creando experiencias
para aplicaciones de compras
como Wayfair,
aplicaciones educativas como CellWalk,
aplicaciones deportivas locales como
CricHeroes y más,
todos ejecutándose en el dispositivo
sin costos de infraestructura
ni compensaciones en materia de privacidad.
Es increíble ver cómo has
Empujó los límites de lo que es un
El modelo en el dispositivo puede hacer.
Tenemos actualizaciones interesantes para
usted.
Comencemos con una vista previa de
el impulsado por la inteligencia
características
que podrás crear hoy.
Mary Beth, te toca a ti.
Este año, estamos construyendo un
aplicación de muestra todo sobre el
Artesanía de papel japonés de origami.
Es un lugar para relajarse y disfrutar
creativo con papel.
Te daré un recorrido rápido.
Nuestra aplicación comienza con una hermosa
Galería de mis proyectos de origami.
¿Y qué tienen de especial estos?
es que he usado base
modelos
para adaptar proyectos de origami
para coincidir con los intereses de una persona
y materiales
con comentarios paso a paso.
Por supuesto, es más divertido
manualidades con amigos.
Entonces nuestra aplicación tiene un chat integrado.
Es un lugar divertido y centrado en planificar
reuniones y charlas sobre manualidades.
Ahora estoy trabajando en un genial
función para combinar las personas
intereses
en un proyecto de origami.
Toma, tomaré este documento.
Rachel está trayendo y mezclando en un
foto de mi perro
para generar un proyecto divertido
para que todos nos unamos.
Con modelos de base
marco, mi aplicación analiza el
Imágenes de inspiración
para tener una idea de los materiales.
tengo y este tema de perro que tengo
en mente.
Incluso traduce el japonés.
texto y usa todo esto
contexto
para pensar en algunas opciones.
Elegiré este.
La inteligencia sigue entrando
un tutorial totalmente interactivo.
Esa es una vista previa rápida.
Hablemos del marco.
Este año, vamos a tomar
el marco de Foundation Models
al siguiente nivel.
Primero, obtienes nuevas capacidades
como indicaciones multimodales con
texto e imágenes.
Esto abre nuevas categorías de
experiencias que puedes construir
con comprensión de imágenes.
Es tan sencillo como adjuntar un
imagen a su mensaje.
Además de esto, la Visión
framework ahora está integrado,
brindándole herramientas diseñadas específicamente
el modelo puede usar
como OCR para texto preciso
extracción,
y lectores de códigos de barras para una rápida
escaneo de código todo en el dispositivo.
A continuación, hablemos del servidor.
modelos.
Los modelos integrados en el dispositivo son increíblemente
útil para muchas tareas.
Sin embargo, a veces es posible que desees
modelo más grande para un más complejo
flujo de trabajo.
Es por eso que estamos ampliando el
marco para que puedas llamar fácilmente
modelos de servidor
como Claude, Gemini y más
para usar funciones como herramienta
llamado y generación guiada.
Y cualquier proveedor de modelos puede
crear un paquete Swift que
cumple
con el protocolo del modelo de lenguaje.
Para que elijas el que quieras
para tu aplicación.
Además de esto, estamos
abriendo el acceso a aquellos de
estás empezando con la IA
utilizar la Fundación Apple
Modelo
ejecutándose en Private Cloud Compute
sin costo de API en la nube,
que te brinda acceso a
Inteligencia de nivel de frontera
mientras se garantizan los datos de sus usuarios.
no está almacenado ni es accesible
para Apple ni para nadie más.
Tus usuarios tendrán acceso a
características que aprovechan la nube
modelo todos los días,
y suscriptores de iCloud+
tendrá acceso ampliado.
No importa el modelo que quieras
uso, puedes cambiarlo fácilmente.
Esto hace
el marco Foundation Models
la mejor manera de ejecutarlo
cualquier modelo de lenguaje grande en su
aplicación.
Con más modalidades
y más modelos a tu disposición
yemas de los dedos,
lo siguiente que necesitarás
Hay más formas de ponerlos
trabajo.
Es por eso que presentamos un
Nuevo paquete Swift de código abierto,
cargado con herramientas prediseñadas
para ayudarle a comenzar
con conceptos como habilidades y
utilidades para el contexto
gestión.
Por ejemplo, una gestión de tareas
aplicación como Tiimo puede usar el
paquete
para incorporar una habilidad que se adapta
su tono y recomendaciones para
los datos del usuario,
entregando un brief personalizado
para ayudarlos a estar al tanto de
su día.
Este espacio evoluciona muy rápidamente.
Las abstracciones del mañana pueden ser
muy diferente a la de hoy.
Entonces estas utilidades de
el paquete de código abierto son
creado
con nuevo edificio fundamental
bloques llamados perfiles dinámicos.
Estas son nuevas API declarativas
en los Modelos de Fundación
marco n.°{18} para crear una IA verdaderamente adaptable
experiencias con menos código,
...
para que puedas orquestar habilidades
y subagentes,
intercambiar herramientas dentro y fuera,
y actualizar las instrucciones en el
volar.
Te explicaré cómo
Poderes de perfiles dinámicos
inteligencia en la aplicación Origami.
Primero, abramos Xcode.
Empezaré con un
LanguageModelSession, que muchos
de ustedes ya usan.
Ahora, en lugar de crear un
sesión con un modelo fijo,
herramientas e instrucciones,
con perfiles dinámicos,
tienes la libertad
para actualizar continuamente su
sesión.
Entonces elegiré un perfil para el
LanguageModelSession
y comience con lo familiar
Sintaxis rápida del generador de resultados.
Aquí en el cuerpo, definiré mi
primer perfil como lluvia de ideas
ayudante
que va a generar proyecto
ideas basadas en las fotos que doy
eso.
Agregaré modificadores para usar
Lenguaje de computación en la nube privada
modelo
con temperatura elevada
para la creatividad.
Ahora la belleza de una Dinámica
El perfil es que este cuerpo
resuelva siempre
en un solo perfil
conduciendo mi sesión a la vez,
pero puedo cambiar entre tantas
Perfiles
según mis necesidades de función en el mismo
sesión.
Entonces cambiaré de perfil
basado en el estado de mi aplicación.
Entonces puedo agregar en un segundo
Perfil para manejar el tutorial
generación.
Uso de computación en la nube privada
de nuevo con el nivel de razonamiento establecido
a profundo,
ya que este es mi mayor
tarea desafiante.
Por último, agregaré un perfil que
explica cualquier jerga de origami,
como "valley fold",
que el usuario no
entender.
Esta es una tarea más pequeña y agradable.
Puedo enviar el dispositivo
SystemLanguageModel
para guardar en llamadas al servidor.
Veámoslo en acción.
Aquí en mi tutorial, ahora puedo
toca este término yo no
entender,
y el modelo en el dispositivo
genera una buena explicación.
En perfiles dinámicos,
Estoy intercambiando modelos,
pero todo se comparte
la misma transcripción continua.
Esto significa más contextual
inteligencia con menos
incitación.
Ahora usemos eso en mi
Perfil tutorial.
Las instrucciones y herramientas pueden ser
Intercambiado dentro y fuera también.
Entonces usaré el modelo de vista de mi aplicación.
para comprobar si el tutorial ha sido
generado,
y si es así, agregaré
instrucciones y herramientas para ayudar
el modelo
brinda comentarios de alta calidad
adaptado al usuario.
Este cuerpo vuelve a calcular cada
turno de modelo, por lo que mi sesión
manténgase actualizado.
Finalmente, ¿ves cómo mis tres
Los perfiles de origami se parecen un poco a
¿Tres agentes de IA?
Eso se debe a que los perfiles dinámicos
están diseñados para ser adaptables
bloques de construcción.
Entonces, si quieres crear IA
agentes o habilidades
o cualquier otro nivel alto
abstracción, puedes.
Con el enfoque de la flexibilidad
y componibilidad, estos nuevos
API
de los modelos básicos
framework están aquí para crecer
usted.
Para ayudarte a llevar todo esto a
tus aplicaciones,
tendrás acceso
hasta un conjunto completo de herramientas,
desde la creación hasta las pruebas,
al envío con confianza.
Eso incluye el nuevo
Marco de evaluaciones,
que le brinda la capacidad
para probar sus indicaciones y
valide
que su sistema basado en inteligencia
Las características funcionan de manera confiable.
Los modelos Foundation actualizados
instrumento te ayudará
Visualice y depure el comportamiento del modelo
en sus aplicaciones.
Y la nueva herramienta de línea de comando FM
le permite solicitar el modelo correctamente
desde la terminal.
Y hay mucho más,
como un SDK de Python,
herramienta que llama con imágenes,
y una nueva herramienta RAG
impulsada por Core Spotlight que es
privado para su aplicación.
Esos son los modelos básicos
marco, proporcionándole
acceso perfecto a
múltiples modelos con todas las novedades
capacidades en el Swift nativo
API.
Además, estamos haciendo algo grande.
A finales de este verano, el marco
será de código abierto.
Entonces, las mismas API Swift que usas
en su aplicación ahora puede ejecutarse en su
servidor también,
que le ofrece una completa de extremo a extremo
Flujo de trabajo de IA en cualquier lugar donde lo implemente
Rápido.
Has visto cómo la Fundación
El marco de modelos se conecta a
modelos de terceros,
Private Cloud Compute y el
modelo en el dispositivo.
Tienes la flexibilidad que necesitas
Necesito conseguir el modelo adecuado para
el trabajo.
Y cuando quieras traer un
modelo específico en su aplicación y
ejecútelo en el dispositivo,
ahí está Core AI.
Core AI es un marco completamente nuevo
integrado directamente en la plataforma,
junto con herramientas de soporte
y tecnologías.
Está diseñado para ser la mejor manera
para traer y ejecutar modelos en
dispositivo en sus aplicaciones.
Ofrece resultados sin concesiones
rendimiento a través de un moderno
API Swift segura para la memoria,
con ajustes exhaustivos
capacidades de grano fino
gestión de intereses
y especialización de modelos
a núcleos de GPU personalizados.
Y existen herramientas basadas en Python
junto con el marco, por lo que
puede convertir
y optimizar sus modelos de PyTorch
para el tiempo de ejecución de Core AI.
El marco está respaldado
mediante una integración profunda
en una nueva cadena de herramientas para desarrolladores,
con compilación anticipada,
Instrumentos Core AI dedicados,
y un potente depurador visual
para rastrear los valores del tensor
directamente hasta su original
Código fuente de Python.
Y está diseñado a escala
con su computación disponible.
Para que puedas ejecutar una visión compacta
modelo en la aplicación de tu iPhone
para consultas de cámara en tiempo real.
O implementar miles de millones
parámetro LLM en una aplicación de Mac
en su escritorio
para impulsar un asistente agente
para complejos, de varios pasos
flujos de trabajo.
Sea cual sea el dispositivo, sea cual sea
el modelo, todo se ejecuta en el dispositivo
sin dependencias del servidor
y cero costos simbólicos.
Core AI está optimizado para
rendimiento en Apple Silicon,
y potencia
Apple Intelligence experimenta
en todo el sistema, incluido
Siri.
Y este año, Apple
La inteligencia ofrece aún más
oportunidades para los desarrolladores.
Pasemos a Lori.
Apple Intelligence se basa en
contexto personal de todo
aplicaciones,
entiende lo que hay en la pantalla,
y puede tomar medidas para conseguir
cosas hechas.
Y ahora puedes integrarte
con sus capacidades
a través de App Intents
marco.
Así es como nuestras plataformas
entender lo que sus aplicaciones pueden
hacer.
Con él, puedes hacer
El contenido de tu aplicación es más fácil de
encuentre
y sus capacidades más fáciles de
use
a través del botón Acción,
Atajos, widgets y en Siri
IA.
Los esquemas de intenciones de aplicación crean
integración con Siri
capacidades fáciles.
Los esquemas son reconocibles
estructuras que Siri entiende
profundamente,
construido sobre años de modelo de lenguaje
entrenamiento.
Proporcionamos esquemas de entidad
para describir el contenido y
conceptos con los que trabaja su aplicación,
y esquemas de intención para
describiendo las acciones que puede
realizar.
Los esquemas de entidad permiten personal
comprensión del contexto.
Al contribuir con el contenido de tu aplicación
contenido al centro de atención
índice semántico,
puedes ayudar a tus usuarios a encontrar
información de tu aplicación
rápida y fácilmente
con atribución a tu
aplicación.
Las claves de indexación para importantes
las propiedades del contenido están construidas
justo en,
lo que significa más comprensión
de menos código.
Comprensión de la intención de Siri
esquemas significa que las personas pueden hacer
pide con naturalidad.
No necesitan aprender
frases específicas
y no tienes que definir
ellos en su código.
Los esquemas cubren aplicaciones comunes
categorías
como gestión de tareas,
edición de fotografías y
comunicación,
e incluye un conjunto completo
de acciones apoyadas por el sistema.
Simplemente adopte la intención relevante
esquemas para las acciones de su aplicación
puede realizar
para que estén disponibles para su
usuarios.
Y debido a que estos esquemas
están definidos por el sistema,
se beneficiarán de futuras
actualizaciones.
Eso significa como el idioma de Siri.
la comprensión evoluciona
o a medida que agregamos nuevo soporte para
idiomas o dialectos regionales,
tus intents funcionarán allí
también, sin ningún cambio en su
código.
Combinando estas capacidades
con las nuevas Ver Anotaciones
API permitirá a sus usuarios
hacer referencia y tomar medidas sobre el
contenido en tu aplicación cuando está activada
pantalla.
Para que tus usuarios puedan interactuar con
su aplicación de manera conversacional,
diciendo lo que le parezca natural
ellos, no órdenes que tienen que dar
memorizar
Ahora te mostraré cómo
Hemos hecho que nuestra aplicación Origami funcione.
con Siri.
Ya tengo algunas entidades y
intenciones que describen las de mi aplicación
contenido
y acciones, y las entidades
ajustarse a la IndexedEntity
protocolo,
para que puedan ser indexados en
Foco.
Al conformarse también a una entidad
esquema, Siri podrá
descubrir y razonar
sobre el contenido de mi aplicación.
Me aseguraré de que mi mensaje,
Contacto y conversación
todas las entidades se ajustan
a los esquemas de entidad relevantes
utilizando la macro @AppEntity.
Estoy indexando estas entidades en
Destacar cuando mi aplicación finaliza
iniciando
para asegurarse de que todo esté en orden
sincronización.
He reconstruido para obtener lo último
cambios, y ahora veamos qué
Puedo hacerlo,
incluso cuando no estoy en la aplicación.
Hola Siri, ¿quién viene?
¿Noche de origami?
Siri: basado en tus mensajes en
Origami, se parece a Kevin,
Mary Beth, Rachel,
y Richard están discutiendo
noche de origami.
¿Qué trae Richard?
Siri: Richard mencionó que es
pensando en traer pizza.
Impresionante.
Pero ahora quiero hacer un seguimiento,
lo que significa que necesito actuar
esta información.
Puedo hacer que el contenido sea Siri
encontrado procesable conforme
una intención
para el esquema sendMessage.
Esta vez estoy usando el
Macro @AppIntent,
ya que se trata de una acción
en lugar de contenido.
Construiré y ejecutaré de nuevo, y
ahora puedo decir, Siri, enviar mensajes de texto
Richard,
"¿Puedes hacer una de las pizzas?
¿vegetariano?"
Siri: De Origami: Listo para
enviarlo?
Sí.
Siri: Está enviado.
Genial. Mensaje enviado.
También me gustaría permitir que la gente
hacer referencia a lo que hay en la pantalla en mi
aplicación
simplemente diciendo "la segunda
mensaje" o "esta foto".
La nueva API Ver anotaciones
me permite asociar mis puntos de vista con
entidades,
que luego se pueden pasar
a los intents de mi aplicación, haciéndolos
procesable.
La vista Mi lista de mensajes contiene
todos los mensajes individuales en un
conversación.
Puedo usar un nuevo modificador de vista
para asignar cada fila de mensaje
a su respectiva MessageEntity.
Probémoslo.
Hola Siri, envía esta foto a
Kevin y diga:
"Rachel nos consiguió algo de papel.
para practicar nuestros pliegues.
¿Qué color te gustaría?"
Siri: De Origami:
¿Listo para enviarlo?
Sí.
Siri: Está enviado.
Y Siri envía la foto con mi
mensaje.
Al combinar el contexto personal,
acciones comunes de aplicaciones,
y reconocimiento en pantalla,
tu aplicación puede formar parte de
El tejido inteligente de la
sistema.
A través de Siri, los usuarios pueden acceder
a través del lenguaje natural,
descúbrelo a través del lenguaje semántico
busca,
e intégralo
en sus flujos de trabajo diarios.
Ahora, volvamos a Josh.
Esta es nuestra visión de una
plataforma inteligente.
Experiencias ricas y nativas y
lenguaje natural inteligente
interfaces
trabajando juntas.
Como desarrolladores de aplicaciones, esto
representa un increíble
oportunidad.
Puedes mejorar la calidad de tu aplicación
experiencias a través de la naturaleza
lenguaje con Siri,
crear potentes funciones de IA
con los modelos de fundación
framework,
e incluso ejecutar tus propios modelos
en el dispositivo con Core AI.
Si estás usando un modelo personalizado
para potenciar una función dentro de su
aplicación,
Core AI es la tecnología adecuada
para usar.
Tus modelos funcionarán
eficientemente en todos los dispositivos,
y está integrado en el
plataforma, para que tus aplicaciones siempre
Benefíciese
de las últimas correcciones y
mejoras.
Y si eres un entusiasta que
está experimentando, entrenando,
investigando,
o perfeccionando la generación
modelos, o si está ejecutando un
servidor de inferencia local,
nuestro marco de matriz, MLX,
facilita la exploración de
innovaciones de vanguardia
y tecnologías.
Ahora es compatible con Metal 4, GPU
Aceleradores neuronales, y puede
incluso escalar
la capacitación en múltiples Mac
con RDMA sobre Thunderbolt.
Es todo de código abierto y es
más rápido que nunca.
La amplitud de capacidades
ofrecido por Apple Inteligencia
y con tecnología
Apple Silicon hace que Apple
plataformas el mejor lugar para
construir y entregar
la próxima generación de
aplicaciones con inteligencia mejorada y
juegos.
Ahora echemos un vistazo a un nivel
más profundamente en lo que hace que todo esto
posible:
los sistemas de los que dependen tus aplicaciones,
desde los marcos que llamas
hasta los procesos que programan
tu trabajo, gestiona tu memoria,
y renderice su interfaz de usuario.
Echamos un vistazo especialmente de cerca
en el rendimiento y la calidad
de estas bases y podrás
ver multitud de plataformas
mejoras
en las versiones de este año.
Cuando reconstruyes con el nuevo
SDK, tus aplicaciones se iniciarán
más rápido
y siéntete más receptivo.
Verás mejoras y
mejoras en la plataforma en
marcos multimedia,
búsqueda y accesibilidad,
mejoras en Swift y
SwiftUI y mucho más,
especialmente en torno al diseño.
El año pasado, el nuevo diseño
con Liquid Glass
trajo un diseño unificado
idioma
creado para un mundo donde tu
la experiencia se mueve entre dispositivos.
El nuevo diseño está creando aplicaciones.
más expresivo y encantador
y, al mismo tiempo, resulta familiar al instante
a los usuarios.
Se ve muy bien en aplicaciones como Tide
Guía, donde sutil, interactiva.
aspectos destacados
responden a medida que los usuarios se desplazan
datos de mareas y cartas.
Y SketchPro, donde es translúcido
Los paneles y controles de pincel
permiten que las obras de arte se vean, incluso
mientras cambia entre herramientas.
A lo largo del último año,
Hemos estado perfeccionando el diseño,
y ese viaje continúa
con un nuevo conjunto de actualizaciones de diseño.
en los 27 lanzamientos.
Aplicaciones que ya han adoptado
Liquid Glass se beneficia
de muchas de estas mejoras
automáticamente.
Para contarte más, aquí está Cindy.
En los lanzamientos de este año, podrás
vea las actualizaciones de los fundamentos
de cómo se construye Liquid Glass,
mejoras al nuevo diseño
que mejoran la coherencia,
y nuevas formas para que las aplicaciones iOS
se adapten a todos los dispositivos
y tamaños de pantalla.
Repasemos los cambios que harás
ver en tus aplicaciones.
Para mantener excepcional
legibilidad, ajustamos Liquid
Vidrio
para que se difunda más efectivamente
contenido complejo detrás de esto.
Y para establecer más profundidad y
separación, también introdujimos
un borde oscurecido
junto con especular más brillante
aspectos más destacados.
También lo hicimos más
personalizable con un nuevo control deslizante
en la configuración
para ajustar Liquid Glass
desde ultra claro hasta
completamente teñido,
permitir a los usuarios elegir el
aspecto que funcione mejor para ellos.
Aplicaciones que ya utilizan Liquid Glass
obtener estas mejoras
automáticamente
cuando se ejecuten en el año
libera sin siquiera necesidad de
recompilar.
Liquid Glass se adapta perfectamente
a una variedad de accesibilidad
configuración que
usuarios pueden elegir, como
reducir la transparencia o
contraste creciente.
Y ahora macOS 27 también es compatible
el entorno de "mostrar fronteras"
valor,
igual que iOS.
Para que puedas adaptar tu macOS
controles personalizados de la aplicación para esto
configuración también.
Las barras laterales se expanden hasta los bordes
Mac y iPad, proporcionando más claridad
estructura
sin dejar de refractar el contenido
desde tu aplicación y el fondo de pantalla.
Y los íconos en la barra lateral recuperan
su color usando tu aplicación
color de acento,
que le da más personalidad a tu aplicación
y dejar más claro cuál
La ventana es clave.
Las API de lista y etiqueta proporcionan
estas actualizaciones automáticamente
y admiten personalización
el tinte por artículo.
Y ahora todas las ventanas en macOS
también tiene la misma esquina más cerrada
radio,
asegurando una mayor coherencia
en todas las aplicaciones.
Cuando el contenido se desplaza hacia abajo
barras flotantes, una barra de herramientas uniforme
aparece en la parte superior
y mantiene el texto legible
mientras mejora el contraste.
Este efecto se aplica
automáticamente para estándar
barras de herramientas
y se pueden personalizar usando
el efecto de borde de desplazamiento existente
API.
También pensamos en cómo los iconos
y se pueden utilizar menús
intencionalmente
para llamar la atención
las acciones más importantes,
tanto en macOS como en iPadOS.
Mientras los iconos están ocultos por
Por defecto, hay una API para mostrar
iconos
para acciones clave de la aplicación.
También estamos actualizando cómo Liquid
El cristal aparece en los íconos,
haciéndolos más nítidos y más
definido.
Se aplica esta representación actualizada
a todos los íconos de aplicaciones,
y hemos introducido nuevos
características como la refracción
que pueden ser selectivamente
Se utiliza para añadir carácter.
Y con Icon Composer,
ahora puedes diseñar tus íconos
de varias capas
de Vidrio Líquido.
Se ha actualizado con nuevas
características de anotación para agregar
refracción
o marcar el contenido de Liquid Glass
efectos.
Y proporciona un interactivo
vista previa de cómo quedará tu ícono
busque
en versiones anteriores.
Juntas, estas actualizaciones
culminar en un enfoque más centrado y
experiencia accesible
en todas tus aplicaciones y en
plataformas.
A continuación, hablemos de la aplicación.
adaptabilidad.
aplicaciones de iOS aparecen en más lugares
que nunca,
en iPad como aplicación de iPhone o en
Mac a través de iPhone Mirroring.
Cuando tu aplicación iOS aparece en
estos otros contextos con mayor
pantallas,
usuarios quieren poder tomar
Aprovecha el espacio extra
para ver más información.
Así que este año presentaremos
soporte para cambiar el tamaño de las aplicaciones iOS
en iPhone Mirroring y en iPad.
Veamos cómo funciona esto
con la aplicación Origami.
Una vez que reconstruyas con la última versión
SDK,
tu aplicación se actualiza automáticamente
optó por cambiar el tamaño.
Dado que Origami es una aplicación SwiftUI,
ya está aprovechando
del ciclo de vida y el estándar de la escena
soporte de marco para básico
redimensionamiento.
Si ya estás usando SwiftUI,
Diseño automático o respondiendo a
cambios de clase de tamaño, estás
bien encaminado
para admitir la capacidad de cambio de tamaño total.
Si tienes vistas personalizadas, podrás
quiero actualizarlos para usar
diseño automático
y colecciones de rasgos
para decisiones de diseño.
Usando el nuevo iOS redimensionable
simulador y vistas previas,
puedes probar en una variedad de
tamaños de pantalla directamente en Xcode,
para que veas exactamente
cómo funciona su diseño.
Y estamos proporcionando una habilidad para
agentes de codificación que te ayudarán
encuentre y solucione
problemas comunes de cambio de tamaño.
Ahora, en lugar de diseñar para
dispositivos específicos y
orientaciones,
estás diseñando para una dinámica
gama de tamaños y aspecto
proporciones.
Para brindar la mejor experiencia
Cuando utilices iPhone Mirroring,
actualiza tu aplicación para poder
Adaptarse y soportar cualquier tamaño.
Simulador redimensionable, vistas previas,
y iPhone Mirroring lo hacen
fácil
para garantizar que tu aplicación sea lo más dinámica posible
y flexible posible.
A continuación, hablemos de SwiftUI.
Aquí está Franck.
SwiftUI es la mejor manera de construir
Aplicaciones para cualquier dispositivo Apple.
Diseñamos SwiftUI para capturar
todo lo que sabemos
sobre la creación de excelentes aplicaciones
en nuestras plataformas.
Maneja con gracia el
complejidades
de diseño, animación,
e integración de plataforma
para que puedas concentrarte en lo que hace
tu aplicación es tuya.
Y a medida que nuevas capacidades como
Se agregan Liquid Glass, se obtienen aplicaciones
estas funciones fácilmente
porque están diseñadas
con SwiftUI en mente.
Nuevas aplicaciones como The Goat
están construidos con SwiftUI
porque quieren sentir
verdaderamente como en casa en Apple
plataformas.
The Goat es un desarrollo de juego
ambiente que trae la apertura
fuente del motor Godot
para dispositivos Apple.
Comenzó en iPad, se expandió a
iPhone, y cuando llegó el momento
traerlo a Mac,
se sintió completamente natural.
Y aplicaciones que usaban anteriormente
multiplataforma o web
tecnologías
como Notion están migrando
su interfaz de usuario a SwiftUI
porque quieren un nivel de
rendimiento y coherencia de la interfaz de usuario
que otras tecnologías no pueden
entregar.
Con potente codificación agente
herramientas, portar código a Swift
nunca ha sido tan fácil.
Por supuesto, utilizamos SwiftUI
nosotros mismos cada vez que construimos
aplicaciones.
Por ejemplo, SwiftUI lo hizo
fácil de crear una nueva aplicación Siri
permitiéndonos
compartir código en todos nuestros
plataformas y Creator Studio
aplicaciones como Logic Pro,
crean nuevas funciones con SwiftUI
para alto rendimiento
y soporte multiplataforma.
Ya que confiamos en SwiftUI
nosotros mismos, cada mejora que hagamos
crear nuestras propias aplicaciones
se convierte en una mejora
para tus aplicaciones también.
Y este es un gran año para
Interfaz de usuario rápida.
Con interacciones más ricas que
ayudarle a escribir menos código personalizado,
con mayor velocidad para crear sus aplicaciones
mucho más rápido,
y finalmente, con nuevo
capacidades para sus aplicaciones.
Comencemos con las interacciones.
Este año, SwiftUI trae más
interacciones dinámicas con su aplicación
como contenedores reordenables,
lo que hace que sea súper fácil
agregar arrastre
para reordenar a cualquier contenedor.
Construyendo un reordenamiento de cuadrícula
experiencia fuera de listas,
como con esta cuadrícula
en la aplicación Origami,
solía requerir mucho código.
Ahora, es tan simple como
agregando .reorderable() a tu
Para cada
y .reorderContainer()
al padre.
Y así, puedo
personalizar el orden de mis
Modelos de origami.
SwiftUI maneja el ascensor y el
suelta animaciones y funciona
con cualquier contenedor
como grids y stacks.
Ahora, por los modelos de Origami siento una
Un poco menos orgulloso de
SwiftUI ahora admite deslizar
acciones dentro de cualquier contenedor como
bueno.
Puedo eliminar una fila personalizada con un
desliza
agregando el existente
Modificador .swipeActions() a mi
fila
y .swipeActionsContainer()
al contenedor desplazable.
Esto proporciona una gran flexibilidad
para acciones rápidas en mi costumbre
fila.
Finalmente, selección de texto.
También se volvió más flexible.
En iOS, ocurre lo mismo.
selección de fidelidad total
ya encontrada
en TextField y TextEditor.
Y en macOS, ahora es compatible
renderizadores de texto personalizados, texto
vitalidad,
y texto vertical.
A continuación, echemos un vistazo a
velocidad.
Esto siempre es una prioridad para
nosotros, pero más aún este año,
y verás muchos
mejoras sin cambios
de tu parte.
Para empezar, hemos ido gradualmente
unificando las arquitecturas de
SwiftUI, AppKit,
y UIKit, y este año,
comparten una base común en
muchos controles.
Entonces, dondequiera que se ejecute su aplicación,
pueden beneficiarse de
lo mismo en la linea
mejoras.
Por ejemplo, los selectores de menú en
macOS
ahora está mejor equipado
para manejar sin problemas listas grandes
de artículos.
Y en diseños de pila anidados,
mientras que SwiftUI solía hacerlo
medir a cada niño múltiples
veces
para resolver su flexibilidad,
ahora hace un cortocircuito
cálculos
donde no son necesarios,
significa que los diseños ahora cambian de tamaño
hasta el doble de rápido.
Y nada salva el rendimiento
como evitar trabajos innecesarios.
SwiftUI ahora solo se inicializa
indicar los objetos cuando son los primeros
cargado.
Anteriormente, un nuevo temporal
instancia del objeto de estado
se crearía
cada vez que se crea la vista
reiniciado.
Obtienes esta mejora por
libre porque el estado ahora es vago
bajo el capó
y se convirtió
de una propiedad dinámica a una
macro.
Y a la hora de cargar
imágenes, AsyncImage evita
También los despidos.
Ahora almacena en caché su contenido
automáticamente usando el estándar
Almacenamiento en caché HTTP,
para que las imágenes se descarguen una vez
y solo se vuelve a buscar cuando es necesario.
Finalmente, hablemos de nuevos
capacidades que comienzan con
barras de herramientas.
Con la nueva capacidad de cambio de tamaño
características, optimizando su aplicación
para un rango dinámico
de tamaños y relaciones de aspecto
es más importante que nunca.
Y las barras de herramientas son centrales
a esa experiencia.
Este año, SwiftUI te ofrece
control más preciso sobre cómo la barra de herramientas
Los elementos se adaptan al espacio.
Utilice la nueva prioridad de visibilidad
modificador para marcar tu más
elementos importantes en alto.
Y SwiftUI los mantiene visibles
más tiempo a medida que el espacio se reduce.
Acciones menos destacadas, como
archivar o eliminar, se puede agregar
a
el menú adicional de las nuevas barras de herramientas
contenedor, que los agrupa en
un menú adicional.
Y finalmente, el nuevo
topBarPinnedUbicación final
ancla los elementos
al borde de salida,
no importa cómo la barra de herramientas
reflujos.
Ahora, cuando cambio el tamaño de la ventana,
la barra de herramientas se mantiene organizada
exactamente como quiero.
Los botones importantes permanecen visibles.
Los que no tienen prioridad están en
el menú adicional y compartir es
siempre fijado
al borde de salida.
También se pueden distinguir pestañas
con la nueva función de pestaña destacada
fijar la pestaña
hasta el borde posterior del
pantalla.
SwiftUI también abre nuevos caminos
para aplicaciones basadas en documentos
con un documento nuevo
infraestructura que proporciona una
toneladas de funcionalidades
listas para usar,
como acceso URL de primera clase
para una personalización total
lectura y escritura en disco,
del tipo que impulsa las aplicaciones
como Xcode o Pages.
Por ejemplo, con acceso directo
a la URL del archivo, ahora tiene
la flexibilidad
para leer solo las partes de un archivo
necesitas y escribe solo el
piezas que cambiaron,
no el archivo completo.
También puedes observar y actualizar
atributos del documento
usando el proporcionado
configuración observable.
La nueva API de documentos se integra
profundamente con Swift moderno,
con soporte para observación,
Concurrencia rápida y mucho
más.
Por último, aquí hay algo bonito.
impresionante.
El marco de vista previa espacial
ofrece a las aplicaciones Mac nuevas formas
de extenderse en el espacio alrededor de los usuarios
usando Apple Vision Pro.
Cuando adoptes esta nueva API en
su aplicación, un modelo 3D puede convertirse
espacial
cuando transmites a Apple Vision
Pro, permitiendo a sus usuarios
obtener una vista previa, editar,
y compartir objetos y modelos
en tiempo real.
Más allá de los que hemos mencionado
ya hay muchos otros
Nuevas mejoras,
incluida una mejor verificación de tipos.
rendimiento con contenido
constructores,
una nueva API de enlace de alertas y para
soporte para ajustar el fundido cruzado
transiciones.
Juntos, estas plataformas
las mejoras aportan más velocidad,
interacciones más ricas y
nuevas y poderosas capacidades para
SwiftUI que puedes tomar
ventaja de.
Ahora, echemos un vistazo a Swift
mismo.
Aquí está Holly.
Swift está diseñado para ser el
Idioma que utilizas en cada
capa de la pila.
Ya sea que estés construyendo
aplicaciones móviles con todas las funciones,
servicios a escala de Internet o
firmware integrado, Swift ayuda
escribes código que es rápido,
expresivo y seguro.
Rendimiento, profundidad y rendimiento de Swift
interoperabilidad inigualable
es lo natural
sucesor de C y C++ para
sistemas y servidores de bajo nivel
programación.
Y su accesibilidad y
expresividad lo hacen ideal para
desarrollo de nivel superior
como aplicaciones y marcos.
Creemos que Swift es el único
lenguaje con esta amplitud.
Eso es lo que hace de Swift un
Idioma al que puedes seguir llegando.
porque a medida que tu pila crece.
Incluyendo fuera de Apple
plataformas, donde se encuentran las herramientas para
desarrollo en Linux,
Windows, Android y la web
están disponibles en Swift.org.
Muchos de ustedes están ampliando su
uso de Swift para agregar
plataformas
y el servidor para que puedas reutilizar
codifica y benefíciate de Swift
alto rendimiento
en toda su pila, como
Flighty, que usa Swift en
sus servicios
para compartir el código que rastrea
visitas al aeropuerto
entre la aplicación y el backend.
O GoodNotes, que usa Swift
para que WebAssembly traiga la aplicación
a la web,
Chrome OS, Android y Windows,
reutilizando más de 100.000 líneas de
código.
O Frameo, que usa Swift-Java
interoperabilidad para compartir Swift
bibliotecas
entre la aplicación iOS y el
Software PhotoFrame escrito en
Java.
La interoperabilidad significa que puedes
llevar Swift a C, C++ y
Sistemas Java
que ya tienes.
Para que puedas obtener los beneficios de Swift
en cada capa sin
reescribir.
En Apple, hemos estado construyendo
con Swift en cada capa de nuestro
propia pila.
Fundación abrió el camino
para marcos Objective-C
para pasar a Swift nativo
debajo del capó.
AppKit y UIKit lo han seguido
adaptarse mediante el uso de Swift y SwiftUI
ampliamente
en su implementación.
WebKit, la web de código abierto
motor que impulsa Safari,
es un motor grande y crítico para la seguridad
Base de código C++.
Usando C++ seguro de Swift
interoperabilidad, WebKit es
Reemplazo de componentes principales
con versiones Swift.
incrementalmente.
En la pila de redes, el
La capa de transporte QUIC fue
reescrito en Swift.
A finales de este mes, el proyecto
será de código abierto y
disponible
para uso multiplataforma
a través de la integración de SwiftNIO.
Puedes seguirnos o recibir
involucrado
a través de la vibrante
comunidad de código abierto en
Swift.org.
Más abajo en la pila, más
seguridad y rendimiento
Los sistemas críticos
se trasladaron a Swift este año.
La representación de la fuente TrueType
El motor reemplazó décadas de
C
optimizado manualmente con código Swift que no solo es
Memoria segura, pero también más rápida.
En el nivel más bajo, tenemos
escrito cientos de miles de
líneas
de código Swift a través del metal desnudo
firmware, coprocesadores y
conductores.
Para las 27 versiones, hemos
Comenzó a escribir partes del
kernel del sistema operativo principal
en Swift.
A medida que Swift se vuelve más capaz en
estos dominios, nos quedamos
true
para uno de los más importantes de Swift
objetivos de diseño:
es divertido.
Es natural escribir y
iterar sobre sus ideas en Swift,
y el compilador está ahí
para detectar errores en el camino.
Las últimas actualizaciones están enfocadas
sobre cómo mejorar tu flujo de trabajo
para que puedas concentrarte en la diversión
parte:
escribir código excelente con
confianza.
Swift 6.4 ya está aquí, creado para hacer
Las tareas cotidianas se sienten sin esfuerzo.
Te mostraré solo algunos
ejemplos.
Cuando tu código base es
en proceso de migración o
adopción incremental
de nuevas características, a veces es
no es realista abordar todos
advertencias del compilador
en todo el proyecto a la vez.
Ahora puedes suprimir las advertencias en
partes específicas de su código, y
puedes promocionar
advertencias sobre errores en algunos lugares
donde quieres estricto
cumplimiento.
Los atributos de disponibilidad se pueden obtener
largo y repetitivo cuando estás
escribiendo el código
para múltiples plataformas Apple.
Ahora, en lugar de enumerar
cada plataforma Apple con el
mismo número de versión,
simplemente puedes escribir
'cualquierAppleOS'.
La limitación de las llamadas asíncronas
en un bloque de aplazamiento se ha ido,
y esperando dentro de un aplazamiento acaba de
Funciona.
No importa lo que estés construyendo,
Diagnóstico del compilador de Swift
son un compañero diario,
ayudándole a detectar errores a tiempo
y guiándole hacia la corrección
código.
Si has pasado tiempo escribiendo
Código Swift,
que probablemente hayas encontrado
este mensaje de error:
"El compilador no puede escribir
comprueba esta expresión en
tiempo razonable."
Esto puede suceder en situaciones complejas.
expresiones de operador, cierres,
o en profundamente anidados
Cuerpos de vista SwiftUI.
Esto es frustrante,
y lo hemos hecho mucho mejor.
En muchos casos comunes, codifique eso
presione este error de respaldo ahora
compila exitosamente o te da
un error más procesable para funcionar
con.
Sabemos que esta área es importante
para un flujo de trabajo fluido,
y seguimos invirtiendo
en ello.
Swift 6.4 te hace más
productivo en el código del día a día,
y aporta el mismo cuidado
a los rincones más especializados
de tu proyecto.
Nunca ha habido un mejor momento
para ir completo con Swift.
Ahora volvamos a Josh.
Entonces esas son la plataforma
mejoras en este año
lanzamientos.
Ahora, para seguir adelante, a veces
hay que dejar algo atrás.
Como dijimos el año pasado, macOS
Tahoe fue el lanzamiento final para
Compatible con Mac Intel.
La transición de macOS a Apple
el silicio ahora está completo,
permitiéndonos centrarnos
en una única arquitectura
en todo el ecosistema.
Esto puede beneficiar a tus aplicaciones como
bueno.
Ahora puedes enviar Apple
binarios solo de silicio en Mac
App Store,
reduce la descarga de tu aplicación
tamaño y permitiéndole enfocar su
probando
en una sola arquitectura.
Y con todas las mejoras para
el nuevo diseño con Liquid
Vidrio,
es hora de completar
tu migración allí también.
Eliminaremos el soporte para
optando por utilizar el diseño antiguo.
Entonces, una vez que tu aplicación esté recompilada
con Xcode 27, lo hará
automáticamente
comienza a utilizar el nuevo diseño
con Vidrio Líquido.
Con tantas mejoras en todo
el sistema, tus aplicaciones y juegos
se verá y se sentirá mejor que
nunca en los lanzamientos de este año.
Ahora, pasemos a tu
productividad y las herramientas que
use
para construir con y para nuestro
plataformas.
La inteligencia es profundamente
transformar la forma de escribir código,
agregar nuevas funciones y crear
aplicaciones.
El año pasado, incorporamos la codificación con IA
asistencia para Xcode,
y muchos de ustedes lo aceptaron
inmediatamente.
Te está ayudando a escribir código
más rápido y adoptar más nuevas API
fácilmente.
Este espacio se mueve muy rápido, así que
Hemos acelerado el ritmo de nuestra
lanzamientos,
entregando nuevo Xcode
capacidades para usted más rápido que
nunca antes.
A principios de este año, trajimos
agentes de codificación para Xcode, junto con
con herramientas que permiten a
agentes obtener una vista previa, buscar
documentación y más,
impulsado por
Protocolo de contexto modelo.
Con MCP, Xcode también se conecta a
las herramientas que ya utilizas,
de aplicaciones de diseño como Figma
a servicios como GitHub.
Y Xcode incluye una función incorporada
integración para agentes de
Anthropic, OpenAI,
y ahora Google.
Hoy, Xcode agrega soporte para
Protocolo de cliente de agente,
para que puedas traer cualquier compatible
agente en Xcode.
Soporte ACP y Gemini
La integración
se envía en una actualización.
a Xcode 26 disponible hoy.
Y hay más
próximamente en Xcode 27.
Aquí está Ken.
Desde la primera línea de código
a la App Store,
Xcode es donde construyes
las mejores aplicaciones para Apple
plataformas.
Millones de ustedes viven en él durante
escribir y depurar su código
con agentes de codificación correctamente
además,
diseñar interfaces en SwiftUI
y previsualizarlos en real
tiempo,
pruebas en todos los dispositivos y
simuladores para detectar problemas
antes de que lo hagan sus usuarios,
y rendimiento de creación de perfiles
con instrumentos, manteniendo tu
aplicaciones rápidas,
responsivas y eficientes.
Este año, Xcode tiene dos grandes
historias.
La primera es la inteligencia, y
tenemos mucho de qué hablar en un
minuto.
El segundo es el diario.
experiencia, cómo se siente Xcode
uso.
Ahora, al igual que tú, gastamos
horas en Xcode todos los días.
Construimos todas nuestras operaciones
sistemas y aplicaciones con él.
De hecho, construimos Xcode con
Xcódigo.
Por eso es necesario que te sientas como en casa
siendo rápido, divertido y
personales.
Y hemos escuchado tus comentarios
y Xcode mejorado en todo el
tablero.
Es más rápido al cargar proyectos.
Arreglamos fallas y giros superiores.
Las sesiones de depuración son más
confiable, con expresión más rápida
evaluación,
y una consola que pueda manejar
tala más intensiva sin
haciendo autostop.
Xcode 27 es un 30% más pequeño.
Ahora, solo Apple Silicon,
con agentes, documentación y
otros componentes descargando en
el fondo,
para que siempre estés actualizado.
Ahora, echemos un vistazo a
experiencia.
Primero, tu configuración de Xcode es
ahora se guarda automáticamente en
iCloud.
Cuando estoy configurando una nueva Mac
así, Xcode ofrece
importarlos.
Introduciré la configuración de
mi iMac.
Puedo iniciar sesión con mi ID de Apple.
Xcode completa mi configuración de Git
también.
Y así, estoy listo para
código con mi nueva Mac.
Ahora, creemos un nuevo proyecto.
Mira esto.
Seleccionaré un nuevo proyecto y luego
aplicación y boom, estoy en el editor.
Sin nombre de archivo, sin ID de paquete, sin
configuración.
Por supuesto que puedo especificar todos
esas cosas más tarde cuando estoy
listo.
Esto es genial para explorar una
idea, una nueva API o creación de prototipos
una vista.
Muy bien, ahora abriré el
Proyecto de origami.
Xcode 27 se ve hermoso con
las mejoras de diseño de macOS
27.
Crujiente y limpio.
Personalicémoslo.
En Xcode 27, puedes hacer
la barra de herramientas tuya.
Es fácil reorganizar las cosas,
para poder agregar lo que necesito y
eliminar lo que no.
La vista de actividad ahora está oculta
claramente en el título del documento
por aquí,
así que hay aún más espacio
por las cosas que quiero.
Los botones de navegación,
alternancia de lienzo, divisiones del editor,
están todos aquí arriba
en la barra de herramientas.
Ahora agregaré un acceso directo a
crear rápidamente una nueva codificación
Conversación del asistente
y eso será útil.
un poquito más tarde.
Temas siguientes y súper divertidos.
El color ahora fluye por todo el
toda la aplicación, no sólo el editor.
Puedes personalizar todo
desde el fondo hasta la sintaxis
colores
y elige ese tono perfecto
de morado para sus palabras clave.
Y Xcode 27 viene con
magníficas nuevas opciones.
Déjame mostrarte algunos de mis
favoritos.
Esmeralda.
Eso se siente fresco.
Casi puedes olerlo.
¿Qué tal algo?
¿Con un poco más de energía?
Neón negro.
Eléctrico. Me encanta.
¿Claro u oscuro?
Cada tema admite ambos.
Aquí está el arrecife de coral.
Ya me siento relajado.
Y cuando estoy trabajando en varios
proyectos al mismo tiempo,
Puedo establecer un tema diferente para
cada uno.
Hace que sea muy fácil decírselo
aparte de un vistazo.
Muy bien, volvamos a
trabajo.
A continuación, Xcode Cloud, que ofrece
tu integración continua y
entrega
integrada directamente en Xcode.
Configuraré mi proyecto de Origami
para usarlo.
Haré clic en comenzar, otorgar
acceso a mi repositorio, y
eso es todo.
Puedo iniciar mi primera nube
construir.
Sin configuración de App Store Connect
necesario.
Y compilaciones de Xcode Cloud
son hasta el doble de rápidos,
ahora son compatibles con Apple Vision Pro
y aplicaciones que usan Metal en Apple
silicio.
A continuación, Vistas previas.
Son la mejor manera de iterar
en la interfaz de usuario y la forma más sencilla de ver
cómo se ven tus vistas
variantes, como la accesibilidad
tamaños, orientaciones,
y localizaciones.
Y ahora puedes ver variaciones
para cualquier propiedad.
Abriré esta vista aquí
que muestra una nota artesanal.
Se representa de forma diferente según
la enumeración CraftState,
que tiene cuatro valores diferentes.
Ahora puedo pasar esa enumeración al
vista previa y así:
aparece una cuadrícula que muestra todos los
estados de mi interfaz de usuario.
Los cuatro de un solo vistazo.
A continuación, otro que me emociona
acerca de.
Al probar tu aplicación, utilizas
hardware real para evaluar
rendimiento,
usar sensores,
y probar condiciones del mundo real.
Y usas simuladores para cubrir
SO y dispositivos más antiguos que
no tengo.
Xcode 27 reúne ambos en
el nuevo Centro de dispositivos.
Reemplaza Simulator y
hace mucho más también.
Déjame mostrarte.
Cuando ejecuto mi aplicación por primera vez, el
La ventana se parece al simulador.
Lo sé.
Puedo rotar fácilmente, agarrar un
captura de pantalla y volver a la
pantalla de inicio,
tal como estoy acostumbrado.
Cuando extiendo la vista, puedo
ahora cambie las propiedades del dispositivo
y pruebe cómo responde mi aplicación
a diferentes configuraciones del sistema.
Como cambiar al modo oscuro,
aumentar el tamaño de la fuente y
más.
Reconstruimos la experiencia desde
el suelo para lo más alto
fidelidad posible.
Para poder pellizcar para hacer zoom, uso
desplazamiento con dos dedos y me gusta
en Vistas previas,
puedo cambiar dinámicamente el tamaño del
simulador para ver cómo mi aplicación iOS
maneja diferentes tamaños.
También puedo gestionar e interactuar
con dispositivos físicos del
mismo lugar,
como este iPhone aquí en mi
escritorio.
Iniciaré la aplicación Origami
aquí mismo desde mi Mac.
Y puedo interactuar con él.
Toda la comodidad del
simulador con la fidelidad de
hardware real
en un solo lugar.
Ése es un vistazo rápido a la
experiencia en Xcode 27.
Y más allá de la experiencia,
los mayores cambios de este año,
los que realmente
acelerarte, estás en
inteligencia.
Kevin, te toca a ti.
¡Qué gran momento para ser
desarrollador.
La inteligencia se está transformando
cómo se crean aplicaciones.
Codificación agente, junto con
Plataformas, frameworks y
te ayuda a dar vida a tus ideas.
Xcode 27 da el siguiente gran paso
en codificación agente, aprovechando
todo el poder
de los mejores modelos y agentes
directamente en Xcode.
Los agentes están entretejidos en cada
capa de la experiencia Xcode,
de la forma en que interactúas con
a un conjunto de herramientas
que le ayudarán a obtener lo mejor
resultados.
Herramientas como entender tu
proyecto, buscando
documentación,
construcción y pruebas.
Y Xcode 27 te ayuda aún más
con nuevas herramientas
como renderizar vistas previas con
variantes, interactuando con el
simulador,
localizar su aplicación,
depuración y más.
Y esto va más allá de las herramientas.
Al usar agentes en Xcode,
cada respuesta se basa en
Swift,
SwiftUI, en frameworks de Apple.
Por eso, al construir para
Plataformas Apple,
Xcode es el mejor lugar
codificar con agentes.
Déjame mostrarte cómo se ve esto
como en cada etapa de la aplicación
desarrollo.
Desde comenzar con una idea hasta
implementarlo y validarlo,
para mejorarlo,
como agregar nuevos idiomas
o solucionar problemas.
Primero, voy a agregar algo
diversión para la aplicación Origami.
Mi hija, ella ama
haciendo origami conmigo.
Quiero sorprenderla con un
característica
que compensa un poco
historia de elige tu propia aventura
sobre los personajes
que hacemos juntos.
Empezaré con uno nuevo
conversación con el agente.
Crearé uno aquí desde el
barra de herramientas.
Se abre directamente en el editor,
como cualquier otro archivo.
Esto es lo que quiero construir.
En mi proyecto de Origami,
Quiero un botón que genere
una aventura para elegir tu propia
historia
para mi hija.
Solo eso me haría bien
resultados, pero tuve algo que
un poco más específico
en mente,
así que agregaré algunos detalles más.
Ella comenzará escogiendo algunas
opciones, como la configuración y un
elemento para usar
en la historia.
La aplicación generará el primer
página y luego déjela elegir qué
viene lo siguiente.
Quiero usar la última versión
API de Foundation Models
y preséntelas con hermosas
tipografía.
Al utilizar un agente de codificación,
los mejores resultados provienen
de colaborar en el
implementación y diseño primero,
antes de escribir cualquier código.
Entonces agregaré /plan al mensaje.
Y voy a pedir un diagrama
mientras estoy en ello.
Me resulta más fácil
revisar el plan de esa manera.
Comencemos con esto.
El agente está explorando mi
proyecto usando herramientas Xcode para
ayudarle de manera eficiente
a comprender mi código base, su
arquitectura y patrones, para
encuentre la mejor manera de
crear la función y es
pidiendo algunas aclaraciones
preguntas.
¿Quiero conservarlo?
Sí. y cuantas opciones
para la siguiente parte de la historia?
Dos o tres es bueno.
Y el agente continúa
para crear el plan.
Avancemos en el tiempo.
Mi plan ya está listo y
se muestra justo al lado del
conversación
bellamente renderizada
rebaja.
Es muy fácil de revisar,
y también puedo refinarlo.
Aquí, la implementación actual
tiene un conjunto fijo de configuraciones y
elementos a elegir.
Me encantaría que pudiera agregarla.
propio.
Lo agregaré como comentario.
Y ahora el plan parece bueno.
Comencemos.
Ahora Xcode y el agente funcionan
juntos para implementar el plan.
Xcode muestra todo lo que
cambiando, como código y
vistas previas.
Mientras se ejecuta, puedo refinar el
implementación.
Como aquí, voy a agregar un divertido
filtro de imagen para el héroe de la historia
imagen.
Parece que Xcode está listo
construyendo mi función.
Todavía hay mucho código y
las vistas previas se ven geniales.
Ejecutémoslo.
Abriré un proyecto de Origami,
toque el nuevo icono de la barra de herramientas y
tal como lo pedimos,
página uno ofrece
un elemento y un entorno.
Escogeré un bosque y una varita mágica,
y oh mira, ahí está el botón
si quisiera agregar el mío.
Y aquí está la primera página del
historia con ese hermoso héroe
imagen.
A mi hija le encantará esto.
Lo que fue solo una idea de pareja
hace minutos ahora es algo que
se puede ejecutar en mi aplicación.
¡Esto es increíble!
Ahora, crear una función es más
que escribir código.
También se está asegurando de que así sea
lo que se supone que debe hacer.
Xcode 27 puede ayudarte con eso
también, con nuevas herramientas para agentes
para comprobar su trabajo.
Por ejemplo, los agentes pueden validar
la lógica de su aplicación ejecutando
pruebas,
probar ideas de forma aislada utilizando
parques infantiles, como experimentar
con API,
y verifique los cambios visuales con
Vistas previas en modo claro y oscuro,
orientaciones diferentes, texto
tamaños o localizaciones.
Y ahora los agentes pueden interactuar con
tu aplicación en el simulador.
Déjame mostrarte.
Quiero probar diferentes
combinaciones de configuraciones, elementos,
incluso personalizados.
Xcode lanza Origami y
Device Hub y comienza a probar
esos para mi.
El agente puede tocar, deslizar y
tipo.
Cuando termina, aparece un resumen
de las pruebas, y puedo ver todo
las capturas de pantalla
que creó a lo largo del camino.
Y así, el Origami
la aplicación tiene una nueva función de historia,
diseñado, construido,
y probado de un extremo a otro.
A continuación, veamos cómo podemos usar
Codificación agente para mejorar nuestra
aplicación.
Los agentes en Xcode pueden ayudar con
todo tipo de tareas de ingeniería,
como adoptar nuevas API,
hacer que su aplicación sea más accesible,
y más.
Localicemos nuestra aplicación Origami.
Empezaré con el francés.
Xcode agrega automáticamente un nuevo
idioma al catálogo de cadenas,
luego trabaja con los agentes
para traducir cadenas
en todo el proyecto.
Esto es más que un
traducción palabra por palabra.
Xcode mira cada cadena en
su contexto, el entorno
código, interfaz de usuario, la acción,
para encontrar la mejor traducción.
Y cuando esté hecho, puedo ver
todas las traducciones aquí en el
Catálogo de cadenas.
Construyamos y ejecutemos.
¡Mi aplicación ahora está traducida!
¡Fantástico!
Crear una aplicación excelente también significa
respondiendo a los comentarios y
datos de sus usuarios.
El Organizador ya te da
Información sobre cómo es tu aplicación.
haciendo
en el mundo real: falla,
bloqueos, métricas de rendimiento,
anonimizados y agregados.
Ahora puedes utilizar agentes para ayudarte
encuentras problemas que importan
la mayoría y solucionarlos.
Le pediré a Xcode que abra el
principales fallos de la última
liberación.
Aparece una lista de fallos clasificados
por la frecuencia con la que ocurren.
Oh, ese primero es de un
actualización que envié la semana pasada.
Arreglemoslo.
Xcode mira lo simbolizado
registro de fallos, descubre en qué parte
mi proyecto
sucede esto, identifica el
problema, reproduce el bloqueo,
realiza la corrección,
y luego la valida.
Y así, nuestro problema es
fijo.
Esos son agentes trabajando con Xcode
en cada etapa de tu
desarrollo, planificación,
construcción y mejora.
Te sorprenderás cuando veas
Xcode y los agentes traen tu
ideas a la vida.
Finalmente, hablemos de lo que
hace que todo esto sea posible.
Xcode 27 se envía con el
experiencia de los ingenieros de Apple
y diseñadores
construidos como un corpus de
habilidades, documentación y MCP
herramientas.
Piense en ellos como especialistas.
Un especialista en SwiftUI que sabe
cómo estructurar su visión y
flujo de datos.
Un especialista en accesibilidad que
sabe lo que constituye una interfaz
trabajo para todos.
Especialistas en universal
dimensionamiento, pruebas y
rendimiento.
De hecho, mucho
De lo que hemos visto hasta este momento,
funciona con uno de estos
especialistas.
¡Y puedes traer el tuyo!
Xcode los integra todos
de la misma manera.
Complementos.
Es un formato usado por muchos
agentes y ampliamente adoptado por el
comunidad.
Es sorprendente ver cuántos de
estos ya has sido
construir y compartir.
Un complemento puede contener habilidades,
solo archivos de rebajas que enseñan
al agente nuevas tareas.
Puede contener herramientas usando el
Protocolo de contexto modelo.
Y hemos agregado uno nuevo
Capacidad para complementos.
Con el protocolo cliente-agente,
un complemento puede traer un agente de
tu elección.
Instalar uno es fácil.
Puedes usar la línea de comando o
pega una URL de git directamente en
Xcódigo.
Y socios como Figma y
GitHub hace que sea aún más fácil
configúrelo con un solo clic.
Y luego puedo ponerlo todo
juntos.
Puedo decirle a Xcode que implemente un
Diseño de Figma en SwiftUI, refinar
para diferentes
variantes, hazlo redimensionable
usar una habilidad y publicar un PR en
GitHub.
¿Qué tan genial es eso?
Eso es codificación agente en Xcode
27.
De una idea a una aplicación, en cada
paso.
Diseñado para tu forma de crear,
refinar, enviar y llegar a su
usuarios
dondequiera que estén.
Estamos ansiosos por ver qué gran
cosas que haces a continuación!
Volviendo a ti, Josh.
Es un gran año para Xcode y
para muchos de nuestros otros desarrolladores
herramientas también.
Me gusta la nueva realidad
Composer Pro 3, que ha sido
completamente reconstruido para
crear 3D listo para producción
experiencias usando RealityKit.
Brinda soporte para el personaje.
animaciones, más realistas
iluminación,
y vistas previas en vivo que te permiten
vea los resultados de sus ediciones
a medida que las realiza
utilizando la pantalla virtual de Mac.
Y hay aún más para el juego
desarrolladores en este año
lanzamientos,
incluida una actualización importante
a Game Porting Toolkit,
que reduce drásticamente
el tiempo que lleva llevar los juegos
a las plataformas Apple agregando
Habilidades de IA para agentes de codificación.
Y nuevas herramientas de línea de comandos de Metal
dar a los agentes control directo
durante el desarrollo y
depurar, traer lo mejor
prácticas
para el desarrollo de juegos en Apple
plataformas para cada paso de tu
viaje de porteo.
Entonces ese es el desarrollador
productividad.
En las versiones de 2027, hay
Hay tantas nuevas capacidades para
desarrollar,
como el marco de App Intents,
que le permite conectar su aplicación
a Apple Intelligence,
y los modelos de fundación
marco
y Core AI,
que le permiten aportar
poderosa inteligencia generativa
funciones directamente en su
aplicaciones.
Hay mejoras en la plataforma
en diseño, Swift y
SwiftUI
que hace que tus aplicaciones sean más rápidas y más
flexible y más fácil de construir.
Y Xcode tiene aún más
amplio soporte para agentes
codificación.
y acabamos de
rayado la superficie.
Hay más de 100 sesiones para
profundizar en todo lo que tenemos
cubierto hoy,
incluyendo Apple Intelligence,
Xcode 27, Diseño y más.
Todas estas sesiones están disponibles
en la aplicación Apple Developer, el
sitio web, YouTube,
y novedad de este año en Bilibili.
Y hay mucho más
sucediendo en línea durante todo el
semana.
Regístrese en Group Labs, en línea
paneles y sesiones Q
con ingenieros de Apple y
diseñadores.
Y conéctate con nosotros
en los foros de desarrolladores de Apple
para hacer preguntas,
y siga la conversación
sobre las últimas herramientas
y tecnologías.
Y las oportunidades para conectarse
extenderse mucho más allá de esta semana.
Puedes reunirte con Apple alrededor
el mundo y en línea en la práctica
talleres, laboratorios,
y eventos para aprender y conectarse
como comunidad en todo el
año.
Nos encanta poder encontrarnos contigo en
persona.
Y hay muchas oportunidades
para hacer eso en nuestro Desarrollador
Centros,
ubicados en Cupertino, Shanghai,
Singapur y Bangalore.
Y estamos emocionados de anunciar
la apertura de nuestro quinto este
otoño en Berlín,
hogar de uno de los parques más
desarrollador y diseñador vibrante
comunidades.
Estamos ansiosos por verte allí
o en uno de nuestros eventos online.
Si esta es tu primera WWDC
o el 25, gracias.
Tu trabajo inspira e impulsa
nosotros.
Usamos las aplicaciones y jugamos
juegos que todos ustedes construyen.
Entonces, nuestra mayor esperanza es que
todo lo que hablamos hoy
permitirá tu próxima gran idea
para venir a la vida.
Estamos ansiosos por ver qué haces
siguiente.
Disfrute de la WWDC.
[Inglés]
Show
Vocabulario clave
Comenzar la práctica
| Vocabulario | Significados |
|---|---|
|
incredible /ɪnˈkrɛdəbl/ B2 |
|
|
inspire /ɪnˈspaɪər/ B2 |
|
|
feedback /ˈfiːdbæk/ B1 |
|
|
intelligence /ɪnˈtɛlɪdʒəns/ B2 |
|
|
enhance /ɪnˈhæns/ B2 |
|
|
expertise /ˌɛkspɜːrˈtiːz/ C1 |
|
|
generative /ˈdʒɛnərətɪv/ C2 |
|
|
flexible /ˈflɛksəbl/ B1 |
|
|
productivity /ˌprɒdʌkˈtɪvəti/ B2 |
|
|
leveraging /ˈliːvərɪdʒɪŋ/ C1 |
|
|
infrastructure /ˈɪnfrəˌstrʌktʃər/ B2 |
|
|
unparalleled /ʌnˈpærəlɛld/ C2 |
|
|
privacy /ˈpraɪvəsi/ B1 |
|
|
orchestrate /ˈɔːrkɪstreɪt/ C2 |
|
|
transform /trænsˈfɔːrm/ B2 |
|
🧩 Descifra "" – cada frase y palabra será más clara con la app!
💬 No dejes que las palabras te detengan – ¡la app se encarga de todo!
Estructuras gramaticales clave
-
These were both huge themes in the 26 releases, and they're key again this year, with many of our efforts influenced by your feedback.
➔ Frase de participio pasado (Oración relativa reducida)
➔ La frase "influenced by your feedback" modifica a "efforts", actuando como una construcción pasiva.
-
If you have a more complex task requiring the most advanced frontier models, the API can now integrate with the cloud model provider of your choice.
➔ Primer condicional con frase participial
➔ La frase "requiring..." funciona como un adjetivo que modifica a "task", explicando su naturaleza dentro de la cláusula condicional "if".
-
Developers with fewer than 2 million first-time App Store downloads will be able to use Apple Foundation Models running in Private Cloud Compute with no cloud API cost.
➔ Futuro simple (predicción/habilidad) + Frase preposicional
➔ La frase "with no cloud API cost" es una frase preposicional que proporciona detalles adicionales sobre las condiciones de la habilidad.
-
It organizes and surfaces personal context from any supported app.
➔ Estructura Sujeto-Verbo-Objeto (SVO) con verbos transitivos
➔ "Organizes" y "surfaces" son verbos transitivos que requieren el objeto "personal context" para completar su significado.
-
Because getting started exploring ideas shouldn't be held back by infrastructure costs.
➔ Voz pasiva con sujeto de gerundio
➔ La frase de gerundio "getting started exploring ideas" actúa como sujeto, modificada por la construcción pasiva "shouldn't be held back."
-
You can pick the one you want for your app.
➔ Oración relativa (reducida)
➔ La cláusula "(that/which) you want" funciona como una oración relativa que identifica a "the one."
-
This makes the Foundation Models framework the best way to run any large language model in your app.
➔ Estructura de objeto complejo
➔ La estructura utiliza "makes" + [objeto] + [complemento de objeto], donde el framework se define como la mejor manera.
-
Because getting started exploring ideas shouldn't be held back by infrastructure costs.
➔ Verbo modal en voz pasiva
➔ El modal "shouldn't" expresa una recomendación o expectativa sobre el estado de las cosas, combinado con "be held back" para la pasiva.
Canciones relacionadas