iOS 27 shipped, and now the real work starts — not adopting the shiny new features, but finding where they rub against the app you’ve already built. Liquid Glass is the most visible example: stunning in the keynote, strange in a UIKit view that predates it by a decade. But it’s the same story across the cycle — the gap between what demos cleanly and what survives contact with a real, aging codebase. This week is about that gap, and the field notes people are writing as they hit it.
Hit an iOS 27 surprise in your own app? Reply and tell me — I’m collecting the good war stories.
with Divya Ravi — Technical Editor, iOS engineer
There’s a particular moment in every major design transition that nobody puts in the keynote. It’s the moment you build your project against the new SDK, launch the app you’ve shipped for years, and watch something you didn’t touch look subtly, unmistakably wrong. A button with the wrong corner. A bar that doesn’t blur where it used to. A control that was crisp yesterday and is now floating in a way you never asked for. Welcome to Liquid Glass in production.
I want to talk about that moment honestly, because the discourse around a new design language tends to split into two unhelpful camps. One says it’s gorgeous and you should adopt it everywhere immediately. The other says it’s a regression and you should fight it. Both miss the actual engineering reality, which is more interesting and more useful: a system-wide design language is not a coat of paint you apply. It’s a set of assumptions the framework now makes about your views — and the friction you feel is the distance between those new assumptions and the ones your codebase was built on.
Here’s the thing about Liquid Glass specifically. It’s a material, and materials are contextual by nature. A glass button assumes it sits on top of something worth seeing through. A minimizing bar assumes there’s content behind it that benefits from the effect. These are reasonable assumptions — until they meet a ten-year-old UIKit view hierarchy that was architected when every surface was opaque and every layer was flat. The framework does its best to adapt your old views to the new material, and most of the time it succeeds. The pitfalls live in the cases where it can’t, and those cases are exactly the ones a keynote demo will never show you, because keynote demos are built fresh, in the new world, with none of the accumulated assumptions of a real app.
This is why “just adopt it” is bad advice and “just fight it” is worse. The right posture is the one experienced engineers take toward any system-level change: understand what the framework now assumes, audit where your app violates those assumptions, and decide — deliberately, view by view — where to adapt and where to opt out. Liquid Glass gives you compatibility escape hatches for a reason. They’re not admissions of failure. They’re the framework acknowledging that your app has history, and history has weight.
The deeper lesson here isn’t about glass at all. It’s about what a design language actually is, underneath the marketing. It’s a contract about how surfaces relate to each other — depth, translucency, hierarchy, motion. When Apple changes that contract, every view you own is silently re-signed under the new terms, whether you read them or not. The apps that transition well aren’t the ones that adopt fastest or resist hardest. They’re the ones that treat the new contract as something to actually read — to understand where their existing UI agrees with it, where it conflicts, and where a five-minute opt-out saves a week of chasing a visual bug that was never a bug, just a disagreement about assumptions.
And Liquid Glass is only the most visible instance of a pattern that runs through this whole release. The same gap shows up everywhere real apps meet iOS 27: in the rendering model, in the architecture decisions that determine how easily you adapt, in the long-standing rough edges the framework quietly smoothed while you weren’t looking. The friction isn’t a bug in the release. It’s the tax every mature codebase pays when the platform moves — and the apps that pay it cheaply are the ones built to bend.
So if you’re staring at a control that looks wrong this week and you didn’t change it, you’re not losing your mind. The framework changed the terms. Go read them — the field guides are already being written, and the good ones map the pitfalls before you fall in. That’s the whole job this cycle: not adopting blindly, not resisting reflexively, but understanding precisely where the new platform meets the girder of everything you already built.
What’s the strangest Liquid Glass behavior you’ve encountered in a real app? Hit reply—the best examples may appear in next week’s issue.
iOS 27 meets real apps — the friction, the fixes, and the field notes. Liquid Glass leads, but the theme runs deeper: rendering, architecture, and the rough edges the framework quietly smoothed.
Fatbobman documents the issues appearing when Liquid Glass meets existing UIKit code, including UIBarButtonItem, UITabBarController, WKWebView, and UIStepper, with practical workarounds for each.
A strong field guide for teams updating mature UIKit apps.
📍Level: Advanced
Livsy Code explores how Liquid Glass interacts with custom SwiftUI button shapes—and how to keep control of the corners when the defaults don’t fit your design.
📍Level: Intermediate
Sagar Unagar examines the new caching behavior in AsyncImage and what it means for network usage, repeated image loads, and scrolling performance.
📍Level: Intermediate
The latest across Swift, Apple, AI, and the community.
John Sundell on how actor isolation actually works with protocols — one of those foundational topics that quietly trips up even experienced developers as concurrency tightens.
📍Level: Advanced
Soumya Mahunt makes the case against reaching for @unchecked Sendable as an escape hatch — what it really costs you, and the safer patterns that get you the same result.
📍Level: Advanced
Daniel Saidi open-sources ListKit — reusable view components and extensions for the list problems everyone re-solves from scratch, from sectioning to selection to reordering.
📍Level: Intermediate
Nikita Vasilev breaks down what actually happens when your code hops threads under Swift 6.2's approachable concurrency — and how to reason about it instead of guessing.
📍Level: Intermediate
Point-Free adds sectioned queries to SQLiteData — a clean way to drive sectioned SwiftUI lists straight from your database without hand-rolling the grouping.
📍Level: Intermediate
Apple's monthly developer digest rounds up the latest across the 27 platform releases — new documentation, sample code, and release notes, plus design resources and WWDC26 follow-ups worth a scan.
Matthaus Woolard on maintaining responsive canvas interactions under the new rendering model using frame reprojection — a look under the hood of how modern SwiftUI stays smooth under load.
📍Level: Advanced
Artem Mirzabekian shares an agent skill built around a practical iOS testing strategy.
It’s a useful example of turning team conventions—what to test, how to structure tests, and which edge cases matter—into repeatable instructions an AI coding agent can follow.
📍Level: Intermediate
Rudrank Riyam gives a coding agent a real engineering task, step away fro several hours, and the checks whether the final report matches what actually happened.
An honest account of where long-running agent work succeeds- and where human verification is still essential.
📍Level: Intermediate
Lee young-jun needed an in-app numeric keyboard and discovered SwiftUI's TextField gives you no clean hook for it — so he went spelunking through the UIKit view hierarchy to find the underlying UITextField and swap its inputView. A genuinely instructive walk through the messy reality of bridging SwiftUI and UIKit, dead ends included, ending with a sharp note on why banking and OTP apps ship custom keyboards in the first place.
📍Level: Advanced
Thorsten Stark walks through taking a SwiftData app from local persistence to multi-device CloudKit sync, including model constraints, container setup, and duplicate- record problems caused by concurrent device updates.
📍Level: Intermediate
Stewart Lynch explains image caching in SwiftUI end to end — why uncached liimage loading hurts scrolling performance, how a caching layer helps, and how to build one clearly.
📍Level: Intermediate
Thanks for reading Those Who Swift!
Subscribe for free to receive new posts. 👇
No posts
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.