What's new in Xcode 27

Highlight

Xcode 27 embeds Coding Agent in the main editor, supports the /plan command for plan-first execution, adds Device Hub for unified simulator and device debugging, brings Metric Goals and agent-driven performance recommendations to Organizer, and adds a Top Functions view in Instruments for finding performance bottlenecks quickly.

Core Ideas

A reshaped workspace: from one-size-fits-all to personal

Opening Xcode used to mean accepting a fixed toolbar layout. The scheme picker, run button, and editor mode controls were crowded into the jump bar. Long branch names were truncated. Want to reorder controls? You could not.

Xcode 27 gives the toolbar back to developers. (01:14) History navigation and editor controls move from the jump bar to the top toolbar, build progress appears below the window title, and the branch picker moves to the bottom status bar, finally leaving enough room for long branch names. Most importantly, the toolbar now supports drag-and-drop insertion, removal, and reordering, so you can put the controls you use most where your hands expect them.

The theme system also gets a major update. (02:23) The Appearance panel has two sliders: one controls text color intensity, and the other controls background intensity. Push the background intensity up and the editor background becomes a vivid gradient. Not happy with presets? Customize a base hue and all derived colors follow automatically. Even better, each workspace can have its own theme, so your company project can use cool tones while your side project uses Neon Noir. The window color alone tells you which codebase you are editing.

Visual noise while coding is reduced too. (01:07) Inline issues in Xcode 27 use a lighter style and are visually distinct from post-build warnings and errors. Predictive issue hints that appear while you type are subtle; confirmed issues after a build use full-intensity colors or disappear if they are automatically resolved.

Open and write: standalone Swift files and untitled projects

Previously, quickly validating a SwiftUI component meant creating a full app project and waiting for Xcode indexing before you could write code. That delay could last tens of seconds, long enough for the idea to fade.

Xcode 27 removes the assumption that you need a project before you can code. (06:08) From the File menu, you can create an Untitled Project directly. There is no save dialog interrupting you. Write first, name and save later. If you do not like it, discard it without leaving traces.

Standalone Swift files are even lighter. (07:13) Double-click a .swift file and, even if it belongs to no project, Xcode 27 can show Playground results and UI previews in Canvas. If a teammate sends an algorithm implementation or UI prototype, you can open it and see the result without cloning an entire project.

Coding Agent: from completion to engineering collaboration

The Coding Agent in Xcode 27 is no longer just a chat window in the sidebar. It becomes a first-class citizen in the editor. (07:50) Conversation history moves into editor panels, so you can organize agent conversations with tabs and split views just like code files. A new Agent entry button appears in the center of the toolbar, letting you start a new conversation or task with one click.

The /plan command is the centerpiece of this update. (08:31) Before asking the Agent to change code, you can use /plan to make it produce an implementation plan. The Agent gathers necessary context and can even spawn sub-agents to work in parallel. After the plan is generated, you can review each step, add inline feedback, and only then let the Agent execute. During execution, all code changes appear live in the right panel, and generated files or screenshots are easy to inspect.

The Coding Assistant sidebar becomes a task board. (09:28) All parallel agent conversations and tasks are listed there, with unread messages and input-needed states clearly visible, making it easier to switch across multiple tasks.

Device Hub: one console for simulators and physical devices

Debugging iOS apps used to split your attention. The Simulator lived in one window, and physical device debugging had a separate flow. Xcode 27 unifies both through Device Hub. (09:57)

When you run an app on an iPhone 17 Pro simulator, Device Hub opens a compact window exactly sized to the device. The window can expand to reveal the Inspector and more controls. (10:26) You can switch high contrast, change Dynamic Type size, and test Dark Mode directly in Device Hub instead of digging through layers of Simulator settings.

iPhone Mirroring testing is integrated too. (11:02) The iPhone Mirroring window on macOS 27 supports resizing, and Device Hub lets you test behavior across aspect ratios and content sizes. If your SwiftUI views already support resizable windows on iPad and Mac, this usually requires no extra work.

Physical device support is the most practical part. (11:52) Simulators and physical devices appear side by side in the sidebar. An app running on a paired iPad Pro can be viewed and controlled directly in Device Hub. One Mac can now test several device form factors at the same time.

Localization: Agents handle the full translation flow

Multilingual localization has always been labor-intensive. Extract strings, create a String Catalog, translate each entry, and test layouts. Every step costs time.

Xcode 27 lets Agents take over much of the work. (13:35) If you ask in an Agent conversation to “set up localization for the project,” the Agent scans the code, makes sure string literals can be localized, creates a String Catalog, and fills translations for all UI strings. The whole process takes only a few conversation turns.

String Catalog itself is updated too. (15:22) After selecting a language, click Generate Translations and the Agent generates translations in the background. You can watch progress either in the Agent conversation or in the String Catalog. Once translation completes, run the app immediately and check for layout truncation or text overflow.

TestFlight users can participate in translation review. (15:52) Native speakers can submit translation suggestions just like regular feature feedback, forming a review loop.

Organizer: from seeing data to solving problems

Organizer in Xcode 27 is no longer just a display case for data. It becomes an assistant that actively helps solve issues. (17:16)

The Overview page is redesigned to put diagnostics and metric charts in the same view. (17:58) A spike in the top metric chart shows where something went wrong, and the diagnostics below point directly to code locations, so you do not need to jump between pages.

Two new metrics are added: Storage and Hitches. (18:21) Storage separates document size, data size, and binary size to help you find the best place to reduce app footprint. Hitches goes beyond the old scroll stutter detection and covers Liquid Glass and SwiftUI animation scenarios, making animation issues that were previously invisible easier to find.

Metric Goals replaces the old Recommendations. (19:38) Goals are calibrated against apps with similar functionality and technology stacks, while also considering your app’s own historical baseline. They cover more metrics, including hang rate, disk writes, battery use, storage, and hitches.

The most useful feature is Generate Recommendations. (20:32) Select a performance issue in Organizer, click Generate Recommendations, and the Agent analyzes the diagnostics and proposes fixes. You can iterate on different repair directions until you find one that fits your codebase.

Instruments: Top Functions goes straight to the bottleneck

Performance debugging is painful when you are searching blind. Instruments call trees can be deep, and finding the real bottleneck takes time.

Xcode 27 adds the Top Functions view. (22:02) Select a time range, click Top Functions, and Instruments lists the most expensive functions by elapsed time. Operations that are cheap once but accumulate huge cost because they are called frequently become obvious in this view.

The session example is typical: (22:51) the paperPhysics function dominates the Top Functions list because its loop iteration count was set too high. It was debug code that nobody changed back. Reducing iterations from the debug value to 5 immediately removes the animation hitch. After profiling again, Top Functions no longer shows the app’s own methods, proving the issue was fixed.

Xcode Cloud: CI/CD in one start flow

Xcode Cloud setup is much simpler in Xcode 27. (25:28) Click Get Started, confirm the app and development team, connect the remote repository, then click Start First Build. That is the whole three-step setup. Afterward, every commit to main or a feature branch can automatically build and test. Build results integrate seamlessly with TestFlight and the App Store.

Details

Toolbar customization and editor mode switching

The right side of the Xcode 27 toolbar includes a three-way selector that controls editor mode: (01:46)

• First item: show previews and Playground results in Canvas
• Second item: show related content in Assistant Editor
• Third item: enter Source Control change review mode

// Test UI with the #Preview macro in a standalone Swift file
import SwiftUI

struct AirplaneStatsView: View {
    let designName: String
    let glideRatio: Double
    
    var body: some View {
        VStack(alignment: .leading) {
            Text(designName)
                .font(.headline)
            Text("Glide ratio: \(glideRatio, specifier: "%.2f")")
                .foregroundStyle(.secondary)
        }
        .padding()
    }
}

#Preview("Classic design") {
    AirplaneStatsView(designName: "Dart", glideRatio: 3.5)
}

#Preview("High-performance design") {
    AirplaneStatsView(designName: "Nakamura Lock", glideRatio: 5.2)
}

Key points:

• The #Preview macro also works in standalone Swift files without a project context.
• You can name previews to distinguish scenarios in Canvas.
• This is useful for quickly validating UI components, testing algorithm prototypes, and sharing code snippets.

Collaborating with Agents through /plan

/plan is the core entry point of the Xcode 27 Agent workflow: (08:31)

/plan
Add statistics to the paper airplane app, showing the glide ratio,
flight distance, and airtime for different designs. Consider SwiftUI layout
and Dynamic Type support.

Agent execution flow:

1. Gather project context, including code structure and dependencies.
2. Analyze requirements and create an implementation plan.
3. Spawn sub-agents to explore different solutions in parallel.
4. Generate a structured plan document with a step checklist.
5. Let the developer review the plan and add inline feedback.
6. After confirmation, begin implementation and show changes live.

Key points:

• /plan makes the Agent think before changing code, avoiding blind edits.
• The planning phase can iterate repeatedly without touching actual code.
• Implementation changes appear live in the right panel and can be interrupted at any time.

Agent-driven localization workflow

The Xcode 27 localization flow has two steps: initial setup and incremental language addition.

Initial setup, performed in an Agent conversation: (13:35)

Please set up localization for the project, starting with Spanish.

The Agent automatically:

1. Scans string literals in the code.
2. Replaces hard-coded strings with String(localized:) calls.
3. Creates a Localizable.xcstrings file.
4. Generates Spanish translations.

Incrementally adding a language in the String Catalog interface: (15:22)

// String interpolation lets the Agent correctly extract translations with placeholders
func boardingMessage(gate: String, time: String) -> String {
    String(localized: "Please proceed to gate \(gate) for boarding at \(time).")
}

Key points:

• Use string interpolation instead of concatenation so String Catalog can correctly recognize variable placeholders.
• The Agent translates with project context and Xcode’s language style guides.
• After translation completes, run the app immediately and check for layout truncation.

Understanding Organizer Metric Goals

Metric Goals compare against these dimensions: (19:38)

Comparison dimension	Description
Similar apps	A peer group of apps with similar functionality and technology stacks
Historical baseline	Performance data from your app’s previous versions
Target threshold	Reasonable targets calibrated by Apple from the data above

Storage metric breakdown: (18:26)

• Documents: user documents and data
• Data: app caches and databases
• Binary: app bundle size, which affects cellular downloads and launch time

Hitches coverage: (19:11)

• Scroll animation hitches, as before
• Liquid Glass rendering
• SwiftUI view transition animations
• UI animations not triggered by scrolling

Using Instruments Top Functions

Standard flow for finding performance bottlenecks: (22:02)

1. Run the app from Xcode, either on a simulator or a physical device.
2. Open Instruments and choose Time Profiler.
3. Record the app while reproducing the hitch.
4. Select the time range where the hitch happened on the timeline.
5. Click the Top Functions button.
6. Review the function list sorted by elapsed time.
7. Use Cmd+Shift+O in Xcode to jump to the corresponding code.
8. Record again after the fix and confirm the problem function disappears from Top Functions.

// Before the fix: high-frequency computation left over from debugging
func paperPhysics() {
    // Bug: too many iterations, causing each frame to take too long
    for _ in 0..<10000 {
        simulateAirflow()
    }
}

// After the fix: lower the precision requirement
func paperPhysics() {
    for _ in 0..<5 {
        simulateAirflow()
    }
}

Key points:

• Top Functions is good at finding problems where each call is cheap but the call count is extremely high.
• If your app’s own methods no longer appear in Top Functions after the fix, that is strong evidence that performance improved.
• Compare Instruments recordings before and after the fix to quantify the improvement.

Practical Ideas

1. Prototype UI components in standalone Swift files

• What to do: Before integrating into a real project, use a standalone .swift file plus #Preview to quickly validate complex UI component states.
• Why it matters: You do not need to wait for project indexing or deal with target dependencies, so the edit-preview loop is very fast.
• How to start: Choose File > New > Swift File, write the component code, add the #Preview macro, and Canvas will show the preview automatically.

2. Let Agents maintain your String Catalog

• What to do: Every time you add new UI copy, ask the Agent to extract it, translate it, and update the String Catalog.
• Why it matters: It avoids the tedious and error-prone work of manually maintaining string keys, and the Agent can produce more accurate translations with context.
• How to start: Ask in an Agent conversation to “update localization,” or click Generate Translations in String Catalog.

3. Use Device Hub for accessibility regression testing

• What to do: Before each release, quickly run through high contrast, large text, and Dark Mode scenarios in Device Hub.
• Why it matters: Device Hub turns these switches into quick controls, reducing test cost from minutes to seconds.
• How to start: Expand the Device Hub window and find the accessibility controls in Inspector.

4. Monitor release quality with Organizer Metric Goals

• What to do: After each release, check Metric Goals in Organizer and watch whether Storage, Hitches, and Hang Rate meet their targets.
• Why it matters: Goals are based on peer app comparisons and historical baselines, helping you discover performance regressions before users complain.
• How to start: Go to Window > Organizer, choose the app, and inspect metric trends on the Overview page.

5. Use Top Functions instead of guess-based performance tuning

• What to do: When animations hitch or responsiveness drops, use Instruments Top Functions first to find the true hotspot.
• Why it matters: It avoids inefficient intuition-driven edits and repeated testing. One recording can expose the root cause.
• How to start: Choose Product > Profile, select Time Profiler, reproduce the issue, select the time range, and click Top Functions.

Related Sessions

• Xcode, agents, and you - A deeper look at the full agent workflow in Xcode 27
• Get the most out of Device Hub - Advanced Device Hub workflows, including file operations, data containers, and configuration evaluation
• Profile, fix, and verify: Improve app responsiveness with Instruments - Hands-on practices for performance analysis with Instruments
• Build, deliver, and automate with Xcode Cloud - A complete guide to configuring Xcode Cloud CI/CD workflows
• Translate your app using agents in Xcode - A deep dive into agent-driven localization and best practices