Tomorrow marks the official release of iOS 26, and a large number of users are likely to upgrade immediately to experience the brand-new Liquid Glass design language. Compared to previous years, this year’s adaptation workload is significantly heavier—especially for apps with complex interactions, which may face many unexpected issues.
Liquid Glass isn’t just a visual refresh; it also introduces significant changes to interaction logic. Some system components differ drastically from older versions, and with many unresolved bugs still present at launch, users may find it hard to tell whether issues come from the system itself or from the apps. In the weeks ahead, developers will likely face an uphill battle, juggling user support and explaining that not all problems are their own.
Whether you love or dislike the new style, Liquid Glass will undoubtedly become a major selling point for the new iPhone. But if Apple were more proactive in providing comprehensive system components and documentation earlier, the ecosystem could embrace this new design language sooner and deliver a more consistent, polished experience to users.
Have you completed your Liquid Glass adaptation?
Recent Recommendations
We Need to Talk About Observation
Three years after the Observation framework’s debut, Jared Sinclair compares Observation with Combine’s ObservableObject. While Observation reduces @Published boilerplate, improves UI update efficiency, supports nested composition, and better aligns with structured concurrency and SwiftUI, it has notable drawbacks: @State replacing @StateObject causes frequent object recreation with high initialization costs; withObservationTracking is complex, hard to discover and use correctly, and lacks a unified cancellation mechanism; Observations, despite introducing AsyncSequence, still has unclear cancellation and lifecycle management that can lead to memory issues; compared to Combine’s AnyCancellable, the new approach is significantly less concise and user-friendly.
Nevertheless, the author believes @Observable is still Apple’s right direction, especially promising when combined with SwiftUI and SwiftData. However, Apple’s API design for non-UI programming scenarios lacks “opinionation,” leaving developers to make architectural trade-offs.
Should you opt-in to Swift 6.2’s Main Actor isolation?
Swift 6.2 introduces Default Actor isolation configuration, allowing developers to set default isolation for targets. Setting it to Main Actor makes code more intuitive like the early days of “executing on the main thread by default.” While this design aims to simplify development in certain concurrency scenarios, it raises questions: how should different targets choose appropriate settings? In this article, Donny Wals shares his thoughts and strategies.
In Xcode 26, App Targets enable Main Actor by default while SPM Packages don’t, a discrepancy that may confuse beginners or those unfamiliar with the feature. Perhaps it would be better to provide explicit options during project creation, allowing developers to make clear choices from the start.
Date Range picker in SwiftUI
Many apps require users to select date ranges (week, month, year, or custom intervals), but the system DatePicker often falls short. Kyryl Horbushko employs a “divide and conquer” design approach, breaking down the complex date range picker into multiple independent components (SegmentPicker, various date pickers, etc.), and cleverly uses MultiDatePicker with state management to achieve continuous date range selection, avoiding the need to rebuild complex calendar components. The solution showcases the powerful combination of protocols, generics, and SwiftUI.
Understanding SwiftUI’s TimelineView: A Deep Dive
TimelineView is a container view without its own appearance that redraws its content at scheduled time points, making it perfect for building real-time clocks, timers, animated visualizations, live data displays, or frame-by-frame animations. In this article, Kyle Ye not only introduces common TimelineView usage but also shares numerous implementation details from recreating this feature in OpenSwiftUI. The application and analysis of @Attribute also provides excellent reference for understanding and mastering OpenAttributeGraph.
The Swift Android Setup I Always Wanted
Swift 6 introduces official Android NDK support, solving the long-standing barrier to using Swift on Android. Developers can now directly import Android without manually handling headers. Mikhail Isaev demonstrates how to elegantly use Swift on Android with JNIKit, detailing the complete workflow of quickly setting up Swift Android projects through VSCode + Dev Containers + Swift Stream IDE, which automatically pulls Docker images and toolchains and generates Gradle projects after configuration.
JNIKit wraps the tedious JNI C API into Swifty interfaces, greatly simplifying Swift-JVM interaction including class loading, object caching, and cross-thread environment binding.
SwiftUI Redraw System In Depth: Attributes, Recomputation, Diffing and Observation
Optimizing app performance in SwiftUI hinges on reducing unnecessary view redraws. However, this involves state management, dependencies, view comparison, and other mechanisms that many developers still don’t fully understand despite SwiftUI being available for years. In this article, Mathis Gaignet breaks down SwiftUI’s redraw process into four layers: “attributes → recomputation → diffing → observation,” and combines Self._printChanges(), Instruments’ Effect Graph, Core Animation, and other tools to demonstrate through extensive experiments how different view declaration approaches impact performance.
Tools
Swift-Build GitHub Action
Configuring cross-platform CI/CD for Swift projects has never been easy. Leo G Dion’s open-source swift-build GitHub Action simplifies everything: with just a few lines of configuration, you can run Swift Package Manager builds and tests on macOS and Linux, with built-in intelligent caching strategies that significantly boost CI efficiency. For deeper insights into how it works, check out the author’s detailed introduction.
The Action is available on GitHub Marketplace, ready to add to your workflows, completely free.
AppKitUI
Many macOS developers still use AppKit but envy SwiftUI’s declarative syntax and data binding. Darren Ford’s AppKitUI elegantly bridges this gap: it provides SwiftUI-like chaining syntax, data binding, and layout systems for AppKit controls, letting you build complex NSView interfaces without XIB files, even supporting real-time preview in Xcode Preview. Compatible back to macOS 10.13, it’s perfect for projects that need to support older systems while enjoying modern development experience.