iOS 27 for Developers: Breaking Changes and New APIs

Apple announced iOS 27 at the WWDC keynote on June 8, 2026, and the developer betas went out the same week. Most of the coverage you've seen is about Liquid Glass getting prettier and Siri getting smarter. That's the consumer story. The developer story is sharper: open your project in Xcode 27, hit build, and a couple of things that used to be warnings are now hard failures.

I went through the iOS 27 beta release notes, the developer documentation, and Apple's own developer newsroom posts to pull out what actually matters when you compile. This is a developer spec, not a feature reel. We'll cover the breaking changes that can reject your app, the deprecations you should start migrating off, the new design rules you can no longer skip, and the genuinely interesting new frameworks (Core AI, Foundation Models, and a pile of smaller ones). Where Apple has not committed to something publicly, I'll say so instead of guessing.

When does iOS 27 ship and what do you build it with?

iOS 27 ships in the usual rhythm: betas now, public beta in July, and general release expected in September 2026, though Apple has not published an exact date. The whole family moved together, so iPadOS 27, macOS 27, watchOS 27, tvOS 27, and visionOS 27 all landed at the same keynote.

The toolchain is where the practical facts are. iOS 27 builds with Xcode 27, which bundles the iOS and iPadOS 27 SDK and runs the Swift 6.4 compiler. Two things about Xcode 27 are worth knowing before you download it: it's Apple-silicon only now (Intel Macs can't run it), and the install is about 30% smaller than Xcode 26.

Here's the part that saves you from panic: there is no deadline forcing you onto the iOS 27 SDK yet. Apple's submission floor is still the iOS 26 SDK with Xcode 26, which became mandatory on April 28, 2026. The "Upcoming Requirements" page lists nothing past that. So you don't have to ship against iOS 27 in a hurry. You should still test against it early, because the breaking changes below are easier to fix in June than in a September release scramble.

What breaks when you recompile against the iOS 27 SDK?

Two changes are hard gates that stop your app cold, and a few more are quieter source-level breaks. Start with the two that matter most, because they're the ones that turn a routine recompile into a rejected build or a crash on launch.

First, a launch screen is now required. Apps built with the 27.0 SDK must declare one of UILaunchScreen, UILaunchStoryboardName, UILaunchScreens, or UILaunchStoryboards in Info.plist, or the App Store rejects the upload. Second, the scene-based lifecycle is now required. If your app still boots through the old app-based lifecycle without a scene manifest, it fails to launch on iOS 27.

If you've been putting off scene adoption, this is the forcing function. The fix is a UIApplicationSceneManifest in your Info.plist and a UIWindowSceneDelegate:

<key>UIApplicationSceneManifest</key>
<dict>
  <key>UIApplicationSupportsMultipleScenes</key>
  <true/>
  <key>UISceneConfigurations</key>
  <dict>
    <key>UIWindowSceneSessionRoleApplication</key>
    <array>
      <dict>
        <key>UISceneConfigurationName</key>
        <string>Default Configuration</string>
        <key>UISceneDelegateClassName</key>
        <string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
      </dict>
    </array>
  </dict>
</dict>

The next one bites SwiftUI code. @State is now a macro. Apple calls it source-compatible "with exceptions," and the exceptions are real. You can no longer set an initial value both at the declaration and in init (the init value gets discarded), the auto-synthesized init is disabled for private members using @State, generic inference is weaker, and @State won't compose with other property wrappers. So this pattern stops doing what you think:

struct CounterView: View {
    @State private var count = 0          // declaration value
 
    init(startingAt count: Int) {
        _count = State(initialValue: count) // discarded under the macro
    }
    // ...
}

There's also a cluster of UIKit changes. UIApplication.statusBarFrame, statusBarOrientation, statusBarStyle, and isStatusBarHidden are deprecated and can now return NaN or null, so read from the window scene instead:

// Deprecated in iOS 27
let style = UIApplication.shared.statusBarStyle
 
// Use the scene's status bar manager
let style = view.window?.windowScene?.statusBarManager?.statusBarStyle

A few more to scan for: menu item images are hidden by default on iPadOS and macOS 27 (set preferredImageVisibility on UIMenuElement to bring them back), UISearchController center placement now renders the scope bar inline with the search field, and UIKit presentation trait inheritance now walks the superview chain instead of jumping to the presentation controller, so custom UIPresentationController subclasses may need a look.

Which APIs and frameworks are deprecated in iOS 27?

Three deprecations are worth acting on now, even though none of them break your build today. Deprecations are free to ignore until the year they aren't, and these all have clean replacements already shipping.

There's one Swift toolchain trap that isn't a framework deprecation but will waste your afternoon if you hit it. Swift 6.4 adds new stat() instance methods on FilePath and FileDescriptor. If you wrote your own extensions that call an unqualified stat(), the call can now resolve to the wrong thing. Disambiguate with Darwin.stat().

On the security side, iOS 27 tightens TLS in a set of system processes (MDM, declarative device management, Automated Device Enrollment, profile install, app install, and software updates). Those servers now need to support TLS 1.2 minimum with App Transport Security compliant cipher suites and certificates, or the connections fail. If you run enterprise device management infrastructure, this is the line item to verify before your fleet updates.

What is Liquid Glass and why can't you opt out anymore?

Liquid Glass is Apple's system design language from iOS 26, and in iOS 27 it's refined rather than renamed, with one change that affects every app: you can no longer opt out. iOS 26 shipped a temporary Info.plist key that let apps keep the old look while they adapted. iOS 27 removes that escape hatch. Any app recompiled with Xcode 27 automatically adopts the new design.

What "refined" means in practice: refreshed system materials, updated typography, and reworked tab bars and navigation bars. App icons render sharper automatically, and users get a transparency slider in Settings to tune the effect. None of that is opt-in. So if your layout leaned on the old material blur or assumed specific bar metrics, test it against the beta now.

There's a second design change that's easy to miss because it sounds like a feature: iOS apps are now resizable, both on large iPad displays and through iPhone Mirroring on the Mac. Resizable means your layout has to respond to live size changes, not just rotation. If you have hard-coded frames or assumed a fixed width, this is the moment that breaks. It's the same discipline good adaptive layouts already follow, but iOS 27 makes it non-optional for more surfaces.

What can you build with Core AI and the Foundation Models framework?

iOS 27 splits on-device AI into two layers: Foundation Models is the high-level Swift API for generating content, and Core AI is the lower-level framework for running your own models. They're different tools, and the distinction matters when you decide what to build.

Foundation Models is now a single Swift generation API that spans the on-device system language model, Private Cloud Compute models, Core AI, and MLX, plus third-party providers through a new Language Model protocol. In iOS 27 it adds image input (so it's multimodal), server model support, and Dynamic Profiles, which let you swap the model, tools, or instructions mid-session. Apple also said the framework is going open source later in summer 2026, with the same Swift APIs running server-side. The basic shape is the same friendly session you may have seen in iOS 26:

import FoundationModels
 
let session = LanguageModelSession()
let reply = try await session.respond(
    to: "Summarize this support ticket in one sentence."
)
print(reply.content)

Guided generation still uses the @Generable macro to get typed structs back instead of parsing strings, and tool calling lets the model invoke your functions (including on-device Vision tools like OCR and barcode reading). The exact signatures are still moving during beta, so check the current docs before you wire anything load-bearing.

Core AI is the bring-your-own-model path. It's built into the OS, tuned for Apple silicon, and lets you load, specialize, and run custom models fully on-device with ahead-of-time compilation. Apple ships Python tools to convert PyTorch models to Apple silicon, and Core AI is what powers the new on-device Siri under the hood. If you've been running a model through a third-party runtime to keep it on-device, this is the native option.

One pricing fact that's genuinely useful: developers in the Small Business Program (under 2 million lifetime first-time downloads) get the next-generation Apple Foundation Models on Private Cloud Compute at no cloud API cost. That's a real lever for indie and small-team apps that want server-grade inference without a per-token bill. If you've been comparing this with wiring up your own model router, my take on Claude Skills vs MCP vs Projects covers how to think about where the model logic should live.

What new frameworks ship in iOS 27 beyond AI?

Plenty, and several are the kind of thing you'd otherwise build yourself. Here are the ones worth knowing about, grouped by what they do.

• Evaluations framework: validates AI feature behavior across changing conditions, going beyond unit tests. If you ship anything model-driven, this is how Apple wants you to test it.
• App Intents Testing framework: validates App Intents through real system pathways without UI automation, which has been a pain point for years.
• App Intents (expanded): adds entity schemas that contribute content to the Spotlight semantic index, intent schemas for natural-language actions without predefined phrases, and a View Annotations API that maps views to entities so Siri can reference what's on screen.
• Music Understanding framework: analyzes audio across six dimensions on-device.
• NowPlaying framework: connects your app's playback to the Lock Screen, Control Center, Dynamic Island, and CarPlay through one API.
• SwiftUI additions: reorderable containers (drag to reorder across lists and grids), document-based apps with direct disk access, lazily loaded subviews that prefetch for smoother scrolling, and a Spatial Preview framework for 3D model viewing.
• WidgetKit: widgets are now customizable through App Intents with dynamic styling.
• Image Playground API: the generative model is reimagined on Private Cloud Compute and can produce photorealistic images in-app.

App Intents is the one I'd prioritize. It's the connective tissue between your app and Siri's new personal context and on-screen awareness, and the entity and intent schemas are how your content shows up in places you don't control directly.

How does Xcode 27 change your build and test loop?

Xcode 27 changes two habits: the Simulator is gone, and coding agents are built in. The first is structural. Device Hub replaces the Simulator, unifying virtual and physical devices in one place so you diagnose and reproduce issues across both from inside the IDE. If your scripts or CI reference the Simulator by name, that's a migration to plan.

The second is the agentic coding story. Xcode 27 integrates agents from Anthropic, Google, and OpenAI that can run your tests, run the app in the new Device Hub, try code in a Playground, pull a crash from the Organizer and fix it, and localize your app. It's extensible too, through plugins and MCP tools and the Agent Client Protocol, with GitHub and Figma as first-party plugin installs. There's also an fm command-line tool and a Python SDK for scripting Foundation Models outside the app. If you already work with CLI coding agents, the best Claude skills for developers translate cleanly to this workflow.

The smaller quality-of-life wins add up: iCloud settings sync so your Xcode setup follows you across Macs, a fully customizable toolbar, app-wide color themes, faster project loads, and Xcode Cloud builds up to twice as fast. Apple also mentioned that parts of the OS kernel are now written in Swift, which is more of a milestone than a developer-facing API, but it tells you where the platform is heading.

Should you adopt iOS 27 now or wait?

Wait to ship against it, but test against it this week. Since there's no deadline forcing the iOS 27 SDK, you don't need to rush a release. But the two hard build gates (launch screen and scene-based lifecycle) plus the @State macro change are exactly the kind of thing that's a calm afternoon now and a fire drill the week of general release. Pull the beta, recompile, and fix the build failures while there's no pressure.

The more interesting question is what iOS 27 unlocks. Core AI plus free Private Cloud Compute for small developers is the first time running real models, on-device or server-side, is a default capability instead of a research project. If you've been waiting for a reason to put a model in your app without a cloud bill, this is it. The breaking changes are the cost of entry. The AI frameworks are why you'd want to pay it.

For the primary details, see Apple's iOS 27 what's new for developers, the iOS and iPadOS 27 release notes, and Apple's developer newsroom post on the new intelligence frameworks and tools.

Keep Reading

• Branch.io Deep Linking and Mobile Attribution Explained. The mobile-growth side of shipping apps, once your iOS 27 build is clean.
• Claude Skills vs MCP vs Projects: Which One Should You Use?. Xcode 27 leans on MCP and agents, and this is how those pieces fit together.
• 10 Best Claude Skills for Developers in 2026. Practical agent workflows that map onto Xcode 27's new agentic coding.