Those Who Swift - Issue 276

The iOS 27 public beta shipped on July 13 — which means the conversation just shifted from “what did Apple announce” to “what happens when I actually run this.” This issue is about that gap.

If you’ve installed the beta and hit something surprising, hit reply — I’m collecting real-world beta friction for a future issue.

with Divya Ravi — Technical Editor, iOS engineer, creator of FoundationModelsKit

Every year the public beta gets framed as a gift: try the new features early, play with Siri, see what’s coming. That framing is comfortable, and for most users it’s correct. For developers, it’s a trap — because the public beta isn’t the moment you preview iOS 27. It’s the moment the clock on your existing app starts ticking out loud.

Here’s the mental model shift I’d push this cycle: a beta is not a demo of the future. It’s a dry run of a migration you have already been assigned, whether you’ve accepted the ticket or not.

Why “it still works on my device” is the most dangerous sentence in July.

The trap with betas is that your app usually does still launch. You install iOS 27, open your app, tap around, and nothing obviously breaks. That’s the false negative that costs teams their September. Because the things that break in a major OS transition rarely break at runtime on day one — they break at the boundaries: at build time when you move to the new SDK, at submission time when a new requirement gets enforced, and at the edges of APIs whose behavior shifted by a few degrees rather than flipping outright.

Consider the shape of this year’s mandates. Building against the iOS 27 SDK now enforces the UIScene lifecycle — an app that hasn’t migrated doesn’t degrade gracefully, it fails to launch. The Liquid Glass opt-out that teams leaned on for a year to buy time is now simply ignored. These aren’t features you opt into. They’re floors you fall through if you weren’t ready. And critically: none of them show up if you only test by installing the beta on a phone and tapping around. They show up when you rebuild.

The real work is boundary testing, not feature testing.

The instinct in beta season is to test the new stuff — the shiny APIs, the headline features. That’s backwards. The new stuff isn’t shipping in your app until you write it. What’s shipping in your app in September is everything you already wrote, recompiled against a new SDK, running on an OS whose assumptions moved. So the highest-value beta work is regression work: rebuild against the new SDK today, and watch what your existing code does at the three boundaries that actually matter —

Build boundary: does the project compile against the iOS 27 SDK, and do the new SDK-enforced requirements (scene lifecycle, launch storyboard, design compatibility) pass? This is where “won’t launch” bugs live, and it’s a compile-and-run-once check, not a feature you have to exercise.

Behavioral boundary: do the APIs you already depend on still behave identically? Major-version transitions are where a method that returned one thing quietly starts returning another under specific conditions. These are the expensive bugs, because your code is “correct” and the ground moved.

Submission boundary: will App Store Connect accept the build? Some requirements aren’t enforced at runtime at all — they’re enforced at upload, in September, when you have no runway left.

Why this is really an architecture question in disguise.

If migrating to a new SDK is a scramble every single year, that’s not an Apple problem — it’s a signal about your codebase. The teams that move through a beta cycle in an afternoon are the ones whose apps were built so the OS is a dependency they can swap, not a foundation poured into every layer. Clean scene management, a UI layer that doesn’t assume a specific design system, submission requirements encoded in CI rather than in someone’s memory — these are the things that turn “OS migration” from a summer-eating project into a checklist.

The public beta is the cheapest, lowest-stakes environment you will ever get to find out which kind of codebase you actually have. Use it as the dry run it is — not the preview it’s dressed up as. The teams treating July as playtime are the same teams that will be firefighting in September. The ones treating it as a deadline will ship the day iOS 27 goes GA and never think about it again.

Rebuild against the SDK this week. Not because the new features demand it — because your existing app already does.

Agree, disagree, already knee-deep in a scene-lifecycle migration? Hit reply — I read every one.

New here? Subscribe free to get “Under the Hood” and the week’s best iOS picks every issue.

Makwan Barzan on the mandatory UIScene lifecycle, the ignored Liquid Glass opt-out, and the enforced launch screen.

Wesley Matlock on routing one LanguageModelSession across on-device, Private Cloud, or frontier.

The three ways to bridge callbacks into async/await, and exactly what each trades away.

Nathan Fennel on layer shaders, the Timeline API, and chaining multi-step motion.

Jordan Morgan on using AI agents for the craft around the app, not just the code.

Stewart Lynch's clean, modern replacement for the old Reachability class.

The latest across Swift, Apple, AI, and the community.

The merge window is open now, closing July 24, with release targeted for the end of July — worth tracking if you ship Swift on Linux or Windows.

Natalia Panferova flags a real footgun: class-typed @Entry defaults get reallocated on every access, so SwiftUI sees a "new" value each time and re-evaluates views that shouldn't update. The fix is a one-line move to stable storage.

Rahul breaks actors down from first principles — how they protect shared mutable state by serializing access, why that eliminates data races by design, and how to reach for them instead of locks and dispatch queues.

Covers the age-rating/Time Allowances change, Creative Assets, Asset Library, Personalized Collections — the big developer-facing App Store update.

The technical rundown of what's new and changed in the iOS 27 SDK — AppKit, SwiftUI, StoreKit, Metal, and more.

Apple's running feed of App Store Connect, TestFlight, and submission changes — TestFlight now accepts Xcode 27 beta builds, and IAPs can be submitted standalone. — this one's a feed not a permalink, but it's the honest home for "the latest submission changes"

Fatbobman digs into why List won't smoothly interpolate a row whose height changes dynamically, then builds a pure-SwiftUI fix using Animatable, a custom Layout, LayoutValueKey, and state decoupling.

Xcode's MCP bridge grew from 20 tools to 47 in the Xcode 27 beta. Amy Worrall skips the agent entirely and drives RenderPreview directly over JSON-RPC, turning Xcode into a rendering service for a SwiftUI preview gallery.

A thorough guide to on-device LLM inference — how Core AI, Foundation Models, and your app logic layer together, plus the larger model, on-device fine-tuning, expanded context, and full tool calling.

A walkthrough of the new SwiftUI APIs landing this cycle — lazy @State, faster compiles, reorderable(), swipe actions beyond List, and the new Document protocol.

SwiftCon is back as part of nextapp devCon (Oct 7–9) — six mobile-dev conferences under one roof, spanning Swift, Android, Flutter, React Native, AI, and XR. Worth a look if you're planning fall conference travel.

Thanks for reading Those Who Swift!

Subscribe for free to receive new posts. 👇