What’s new in Xcode 27

Hey, I'm Jake, a designer on the Xcode team.

My colleague Breckin and I are super excited to share what's new in Xcode 27. We've really been into paper airplanes lately and have been working on an app to manage our grand fleet. It's been a blast! Xcode 27 makes it super easy to kick off tasks with Coding Agents, quickly iterate on new project ideas, and its workspace is more customizable than ever! Let's dig into what's new. We'll start with the new workspace look and feel and how it can be customized.

Next, we'll check out how easy it is to kick off a new project when an idea strikes. Then we'll dig into the awesome new updates for working with coding agents in the editor.

After that, we'll take a look at how Device Hub makes it a breeze to evaluate apps on devices and simulators.

Then, Breckin will share how to keep an app's experience soaring after launch. Let's start with the workspace.

The Toolbar and Themes in Xcode have been revamped to allow for more customization. And when editing code, inline issues now get a subtle look, to minimize distractions while typing. Here's the standard look for the new workspace in Xcode 27.

Let's take a look at the Toolbar. Some controls that were previously in the jump bar, like history navigation and editor controls, have moved up into the Toolbar.

Activity information, like build progress, appears under the window title.

In the center, we have our new entry point for working with coding agents, more on that in a bit, and our trusty scheme and destination picker.

In the top right, we have controls for adding tabs and editor panes, customizing your editor's settings, and a 3-way chooser for swapping between editor modes.

The first option displays previews & playgrounds in the canvas.

The second reveals related content in the Assistant Editor.

And the last enters a mode to review source control changes.

Oh, and speaking of source control… the branch picker has moved to the bottom bar where it can more easily fit long, beautiful branch names.

But the best part about the new Toolbar is that it's fully customizable. Now you can add or remove your favorite items and reorder them to your heart's content.

Customizing the workspace goes beyond just the Toolbar. With Xcode 27's new themes, you can choose from beautiful presets, or simply play around with a couple sliders to tune a theme in your own way. Let me show you… The new Appearance panel in Xcode's settings window has everything you need to configure a theme. The standard theme has been revamped to be brighter and more colorful. I can play around with the first slider here to influence the intensity of the text colors.

And the second slider lets me ramp up the background intensity.

now we can see a full window background color. And if I keep bringing the intensity all the way up, my background turns into a vibrant gradient.

And of course, I'm not locked into these starting tints. I can choose other values, like a pink tint for my background, and my theme automatically updates for this new color palette.

If I want to choose another theme, I can browse a list of presets.

To get in the mindset of soaring through the sky, I'll use a theme with a lot of blue tones like Neon Noir. And I love how this one looks with a high background intensity.

Of course, if I want to specify individual colors, I have the full list below. Every value in here is generated from that base palette I've been editing. When I customize a value, like setting my keyword color to pink, the choice is locked in. Edits I make to the palette will no longer influence this color. And it's easy to use this reset action if I want to restore it back to being an automatic color.

Fonts use a similar customization system. These basic fonts for code, prose, and console, act as the palette which generates how fonts are used in my other editors. If I change the size, variation, or family, the rest of the fonts will automatically update in turn.

Something I love about these themes is how it influences the entire workspace window, including other editors. If I check out my project settings, I can see a subtle tint of my theme coming through the background.

There's one more thing to know about themes, you're not limited to just one! If you want, you can pick a separate theme for a given workspace. Your font settings are saved separately, so it's super easy to swap out themes depending on your mood or workflow.

Like you saw, to help get myself into the mindset of paper aerodynamics I like to use the Neon Noir theme for my paper airplane project.

This helps identify at a glance which project is which. So, if you find yourself needing to quickly differentiate projects that are perhaps eerily similar side-by-side, try giving them unique themes. Oh, and while themes for the light appearance have a subtle look to them, in the dark appearance, they can be truly vibrant and expressive. Go give those background sliders a whirl.

Warnings and errors have also been revamped to work with the new themes. Predictive or "live" issues have a new subtle look to them to reduce distractions while you type. And to differentiate them from warnings and errors you get when you build.

As you make changes to your code, Xcode will automatically predict issues as if you were going to kick off a new build. These predictions use a subtle background that blends in with your theme so you can keep your focus primarily on what you're typing. When do you build, the subtle predictions will either turn into build warnings and errors with a full intensity color or they will be dismissed if they were resolved.

Ah! Speaking of editing code, Breckin just sent me a great idea for our app. I want to try the idea out in a new project.

Xcode 27 makes it a breeze to to kick off new projects for testing out new ideas like this, or for creating the foundation of your next great app. Let's check it out… I can create a project from Xcode's File menu. Then I can choose from a list of starting points, depending on the kind of project I have in mind. If I want to use SwiftUI, App is a great choice.

If I don't need UI, I can keep it simple with a macOS Command Line Tool.

If I want to create a library that others can use, I could choose Swift package. And Playground is a great choice when I just need a simple standalone Swift file with a Playground macro. In my case, I want to make an app.

A brand new untitled project is created, no questions asked. Literally! I can take my time and play around in this project to flesh out my idea.

When I'm ready, I can choose to give it a name and save it, or discard the project entirely.

These untitled projects make it a breeze to try out something in a blank canvas.

Oh! I just got something else from Breckin. This time, it's a Swift file.

Opening the Swift file gives me a new workspace window. Even though this file isn't a part of a project, Xcode 27 can display playground results and UI previews in the canvas! This makes it easy to share lightweight ideas with each other, and what Breckin shared here looks like a great start for how airplane stats could appear in our app. I want to add something like this to the real project. Coding agents could really help here.

Working with coding agents in Xcode 27 has been supercharged. It's easier than ever to kick off and stay on top of parallel agent tasks and conversations. The transcript has moved into the editor pane, so you can compose it with other editors with tabs, splits, or whatever suits your workflow. The editor also includes an easy way to see what the agent changed and any artifacts that got produced.

Remember that fancy button in our Toolbar? I can use it to kick off a new conversation or task for a coding agent. The conversation appears as an editor, so it works with tabs, split editor panes, or however you want to organize your workspace. I really liked Breckin's idea for adding stats for different kinds of paper airplane designs, so I could kick off a simple request… But I want to dig into how this feature should work with the agent before we start making changes. I can use the plan command for that.

Using slash plan will use the plan tool.

I can take the time to specify all the details I want my agent to consider. Then the agent will gather the necessary context for this plan without making any changes yet. While it's exploring, it can kick of sub-agents to work in parallel.

In this case, I need to provide some input on how to tackle the problem. I'll give some guidance so it can keep working towards creating the plan. Once the plan is ready, I can read it over, give inline feedback, or have the agent go ahead with implementation.

As the agent works, any changes it makes to the codebase appear on the right-hand side.

Any produced files, artifacts, or screenshots will appear here as well. This is a great way to see how my app is evolving as the agent interacts with the app in the simulator and in previews.

While I let the agent dig into implementing the plan, I'll open up the coding assistant sidebar.

It contains a list of my other agent conversations and tasks that may be happening in parallel.

The sidebar list makes it easy to check in on conversations and see if they need any input or have unread messages.

And there's so much more here to explore, I recommend checking out the session "Xcode, agents, and you" to get the full look at agentic workflows in Xcode 27.

Now that the plan is implemented, I want to try out the app. When launching an app on a simulator, it will open as a new window in Device Hub. As the name implies, Device Hub has some great ways to explore and evaluate your app across simulators and physical devices, let's take a look. If I choose to run my app on iPhone 17 Pro simulator, I get a new window from Device Hub. You can see the window is compact and sized to fit the device. I have some quick actions like going home, taking a screenshot, or rotating the device. But I can also expand the window, which grants more space and access to more controls.

I can open the Inspector and get even more ways to evaluate my app. It's important to test an app with different accessibility settings. For example, I can increase contrast, choose a larger dynamic type size, and try out my app with a dark appearance.

The app is looking good with these settings, so let's go back to the defaults.

For my iPhone app, it's also important to consider how it appears in iPhone Mirroring. On macOS 27, the iPhone Mirroring window can be resized, so it's also a good idea to test out my app in the new resize mode.

I can try out different aspect ratios and content sizes.

My iPhone app already has great support for resizing thanks to the standard SwiftUI views I'm already using and the effort I've already put into making my custom views and layouts support resizable windows on iPad and Mac, so this is already looking great.

Device Hub makes it a breeze to work with simulators, but the coolest thing is what I've shared so far works with physical devices as well! If I open the sidebar, I see a combined list of simulators and devices. I have a paired iPad Pro already running my app, and I can see and control it directly in Device Hub! Now I can try my app out on many different form factors right on my Mac! Device Hub is super powerful and unlocks a lot of great workflows like working with files, data containers, evaluating app configurations, and more. We have a whole session on it, go check out "Get the most out of Device Hub".

I've had a lot of fun getting my app up and running, but delivering a truly great app is about so much more than those prototyping sessions and building out the initial features.

My colleague Breckin will share how Xcode 27 keeps your app soaring after launch! Thanks Jake! It's a nice one! It's true, there's a lot of distance between a prototype and a finished app. Our app works, but it isn't ready for the world yet. Let's close that distance with some other updates in Xcode 27. First, we'll prepare for departure with app Localization. Then, we'll keep the wings de-iced with updates to Organizer.

Performance is incredibly important, so we'll cover how Instruments helps us keep our app level with the horizon. And finally we'll make sure our Paper Airplanes continue to soar into Xcode Cloud. I'll start with Localization. Jake and I want to bring the joy of flying perfectly-folded paper airplanes to people around the world. Localization is the natural place to start. And in Xcode 27, my coding agent takes on a lot of the work.

Everybody wins when you localize your app, because you can reach more people in more languages. But localization can be a big undertaking. Thankfully, Xcode 27 makes it much easier and faster to localize your app. Because my agent is a large language model, it is perfect for suggesting appropriate translations for my strings.

I've created a new conversation. I'll ask the agent to setup localization for our app's project. You can choose as many languages as you like, but I decided to start with Spanish. The agent reads through our app's code, ensures string literals are ready for localizable references, and creates a String Catalog containing every UI string. Just a few turns of conversation, and the app is ready to be translated.

By opening the String Catalog I can observe the agent working through the list in efficient batches. Let's check how the agent is doing by returning to the chat.

Great! It's done. The agent analyzed our app, performed any code changes necessary for localization, created a String Catalog, and translated every UI string into Spanish just as I requested.

When the agent generates translations, it uses the full context of your project as well as language-specific style guidance from Xcode. Within minutes, our Paper Airplanes app has a localized build I can run. I can test it immediately, fixing common issues like awkward layout or truncated text.

I like to use The String Catalog for focused, per-language work. I reviewed the Spanish translations, they looked great. I've added a new entry for Simplified Chinese. I can add languages with the + button in the bottom left.

And new in Xcode 27, with a language selected in the String Catalog I can click the Generate Translations button.

The agent goes to work in the background, adding localization for Simplified Chinese. I can check on its progress at any time, either in the agent conversation itself or by inspecting the String Catalog entries as they fill in. When the agent is finished, I can run the app to spot check these changes. If all is well I can distribute an update to our new users for testing.

A great way for native speakers to review our app's support for their language is through TestFlight! TestFlight users can provide translation feedback just as they would provide feedback for any other feature in the app.

Localization in Xcode has never been easier or faster; here are a few more tips to reach more people than ever before with your app.

Ask the agent to ensure the existing strings in your code are ready for localization.

It's best to start with just one or two languages, so issues are easy to spot. And be sure to test the app - even if you don't read every language - to catch those awkward layout or truncated text issues early. And remember that in addition to any internal testing you perform, TestFlight is perfect for getting feedback from native speakers.

There's a lot more to localization than what we covered today. For a deeper dive into these translation features, check out "Translate your app using agents in Xcode". And for some true immersion into the world of app localization, land on "Code-along: Explore localization with Xcode".

Jake and I have folded quite a few languages into our Paper Airplanes app. We're almost ready for takeoff. Between Jake's work earlier and mine here, we were ready to put our app in front of people, people, through TestFlight and then launching on the App Store. But shipping isn't the finish line. It's where we learn how our app actually behaves in the world. That's where the Organizer comes in. The conversation between our app and its users keeps going long after the App Store launch. And the Organizer is where a lot of that conversation lives. In Xcode 27, it does more than collect reports. It also helps me act on them. The Organizer has always been where I see what my users are running into, and where I can make our app better. But… seeing the issue is one thing. Figuring out what to do about it is another. In Xcode 27, the Organizer goes further. It helps me see more issues and can even recommend ways to fix common issues, like hangs. hangs. For our app, that's the difference between "I know there's a hang" and "here's where the hang is, and here's what I should try next." Xcode 27 brings four new things to the Organizer. The redesigned Overview surfaces the highest-impact issues first, so I can focus immediately on big trouble spots.

The Overview page puts diagnostics and metrics in the same view. A spike in the metric chart up top tells me that something needs attention. The diagnostics below show me where in the code to start looking. One screen, instead of jumping between two.

New metrics for storage and animation hitches flag issues the old metrics couldn't see.

In Xcode 27, there is a new Storage metric that shows how much space our app and our app's data have been taking up. Storage on a phone is shared across every app, so when one app over-uses it, every app feels it. The metric breaks down documents, data, and binary size – since binary size impacts cellular downloads and launch time. It tells me what my app's footprint is, and where to focus for the biggest size reduction wins. You can see that version 1.0 and 1.01 of our app were quite large. This let Jake and I know that we should compress some images. The App Size chart shows that this made a big difference, one our users could feel. The Organizer has tracked animation performance for a while, in the context of scrolling hitches. The new hitches metric surfaces issues in more places than scrolling, like understanding how apps use Liquid Glass and SwiftUI views. The updated metric gives me a more complete picture, including animations the old one missed. For our app, that's the difference between catching a choppy animation and not. Speaking of which, it looks like we introduced a pretty bad hitch in version 1.3… I'll make a note to take a look at that when I'm done exploring the Organizer.

In Xcode 27, app recommendations have become Metric Goals, Last year, the Organizer started showing recommendations for launch time. Xcode 27 offers an expanded set of goals for your app to meet. They are achievable, realistic, and based on technical and functional similarities between your app and other apps. and they cover more metrics: hang rate, disk writes, battery, and the storage and hitches metrics we just discussed.

The goals are calibrated to my app, compared with similar apps based on what my app actually does, and what technologies it's built with. And alongside those, comparisons include our app's own historical baselines, so we can see whether we're getting better or encountering some unexpected turbulence.

Organizer is great at providing information about issues impacting your users, but you may be wondering how to fix them. New in Organizer, you can get guided performance analysis and generate recommendations using coding agents.

A lot of the time I spend on a regression is just figuring out why it happened, and how to reproduce it. That's the part Generate Recommendation tackles. From the Organizer, I click Generate Recommendations..., pick my project, and the agent works through the diagnostic data with me. Like any agentic tool, I can iterate. Try a different angle, try a different fix, until something fits the codebase. And that's a tour of Organizer in Xcode 27.

But a great app does more than just work. It also has to do its job fast, and not drain the battery. The more efficient our app is, the longer our users stay in the park instead of diverting for an unscheduled charging stop. Tuning our app's performance is one of my favorite parts of app development. A fast, efficient app keeps our users in the air longer. That's where Instruments comes in. And in Xcode 27, Instruments fits right alongside the rest of my work.

Every app has its rough edges. Even our Paper Airplanes app. Some show up right away, others take more digging, like that animation hitch the Organizer showed me earlier. Instruments is what I reach for when I want to know what my app is really doing. And in Xcode 27, finding the answers takes a lot less time.

When my app feels slow, the first question is always: where is the time really going? Performance investigation has always felt like detective work, and Instruments has been my favorite partner. New in Xcode 27, Top Functions makes the patterns jump out faster. I want to try to reproduce that hitch the Organizer flagged. I have our app's project open in Xcode 27. I'll run it in the Simulator and try to reproduce the animation problem.

Oooh… looks like the plane is having a little engine trouble. Let's do that again and think about what might be happening.

We're definitely spending too much time on each frame. I have an idea about what's wrong, but with Instruments there's no need to guess.

Oh. Jake just sent me an Instruments recording. Jake's CPU profile shows a bunch of activity on the right. I selected that time range.

I've pressed the Top Functions button and I can see that we're spending a lot of time in several parts of my app. Top Functions is perfect for finding performance problems that arise due to expensive operations that are performed many times. In this case we can see that we are doing a lot of work in the animation pipeline. The top function is paperPhysics, which looks very expensive indeed. Let's go back to Xcode and look at this function.

I'll use one of my favorite shortcuts CMD+Shift+O to bring up Quick Open.

I can open a file but I can also type the name of a function or other piece of code.

There it is! Oh! Oops, I'm iterating way too many times in this loop. We don't need to simulate our airplane that accurately for this animation. This is some code from a debugging session that I accidentally left in. I'll fix that by reducing it to 5, the number I really wanted.

That should fix the issue. I'll launch the app again in the simulator to confirm.

The hitch has disappeared. Top Functions pointed me directly to the most expensive part of the code. Thankfully the fix was simple and we'll soon have much happier flyers. I recorded another run in Instruments after making the fix. It's much better. Notice, none of our app's methods show up in Top Functions now. That's a great sign! We have real evidence that our next update will not only make our users happy, but their batteries too. Top functions in Instruments helps me reveal where my app is really spending its time. Instruments is truly an incredible tool to see exactly what your app is doing, and, by the way, processor trace is the coolest thing ever. Speaking of exploring all of the awesome features in Instruments, there's so much more that I'd love to show you including how you can compare performance runs so you know whether code changes actually improved things or made it worse. But we have an app update to ship. thankfully, there's a deep library of performance-related sessions. If your app is turbocharged with agentic features you'll definitely want to soar over to "Debug and profile agentic app experiences with Instruments". We also recommend you dive deeper by checking out "Profile, fix, and verify: Improve app responsiveness with Instruments".

At this point, people are loving our app and we don't want to impact their experience. Every change is a chance to break what's already working. And shipping updates without knowing whether a regression snuck in is a stunt plane maneuver that no one wants to try. Thankfully, that's the next thing Xcode 27 has my back on. Catching regressions is one of the parts of app development I'd rather not do by hand. Every fix and every new feature I add brings with it a chance to break something I already shipped. That's where Xcode Cloud comes in! Xcode Cloud is a Continuous Integration and Delivery service built right into Xcode, and made expressly for developers shipping to Apple platforms.

It builds and tests your app in the cloud, in parallel, across multiple devices, Xcode and OS versions. And in Xcode 27, it's easier and faster than ever to get started with Xcode Cloud.

I'll set up our app's Unit and UI Tests to run in Xcode Cloud automatically when we make changes to our main or feature branches. Each run will be a great signal for potential regressions. I'll click the Get Started… button to start the set up.

The app and developer team look correct, so I'll click Next.

I'll connect Xcode Cloud to our remote source code repository...

and that's it! Once I click Start First Build our build and test workflow is ready to run on every commit! The benefits of using Xcode Cloud don't stop there. Xcode Cloud also helps you deliver your app to users, seamlessly integrating with TestFlight and the App Store.

There's a lot more to Xcode Cloud than what I showed today. For a deeper dive, check out "Build, deliver, and automate with Xcode Cloud" and for more on how to extend Xcode Cloud to work with your own services and more, watch the session "Extend your Xcode Cloud workflows".

The work I covered today is the work I keep coming back to. From delivering new features to ensuring what already works keeps working. Whether I'm creating or refining, Xcode 27 meets me there. Jake, I'll hand the controls back to you. Thanks Breckin! As you saw, Xcode 27 is there for you every step of the way through your app's lifecycle. From fleshing out initial ideas into prototypes, working collaboratively with agents, localizing your app, and resolving issues in the field, Xcode can help you focus on what truly matters — making something special. It's been a blast sharing what's new, but there's even more to discover. Download XCode27, customize it for your workflow, and explore the new features. You can find more info in the release notes and in this session's resources. And there are ton of other sessions beyond what we've already recommended you check out out, and loads more goodies to explore, so get out there and have a great WWDC!