Several months after the Swift forums first announced the formation of an Android Community Workgroup in February 2025, Swift.org has now officially launched an Android Workgroup. This marks the beginning of officially led efforts to support Swift on Android. With this, Swift developers may soon benefit from improved toolchains and a better development experience on Android.
However, alongside this excitement, we must also acknowledge a sobering reality: most Swift developers have long operated within Apple’s tightly integrated ecosystem. The APIs we use daily are often deeply coupled with Apple system frameworks. While the Swift community and Apple have made strides—such as the ongoing pure-Swift rewrite of Foundation and the growing number of cross-platform libraries—these efforts still fall short of meeting the broader demands of real-world cross-platform development.
Not long ago, the Swift Package Index added compatibility indicators for Android and Wasm, on top of its existing support for Apple platforms and Linux. This reflects a clear intention within the community to promote and encourage multi-platform adoption. I took this opportunity to adapt two of my own libraries for Linux. While the adaptation itself was relatively straightforward—thanks to GitHub Actions for surfacing build errors—the experience revealed a notable lack of a convenient and unified environment for cross-platform development. As support for more platforms becomes necessary, building a robust, safe, and developer-friendly adaptation infrastructure will become increasingly critical.
In recent years, Swift’s multi-platform strategy has accelerated significantly. But to truly position Swift as a first-class language for cross-platform development, we can’t rely solely on Apple or the official Swift team. Every Swift developer has a role to play. The stronger Swift becomes, the more we all benefit. Building a thriving, multi-platform Swift ecosystem is a task that calls for collective effort.
Original
NotificationCenter.Message: A New Concurrency-Safe Notification Experience in Swift 6.2
NotificationCenter has long been a staple of iOS development, offering developers a flexible broadcast–subscribe mechanism. However, as Swift’s concurrency model has advanced, the traditional approach. To eliminate these pain points, Swift 6.2 introduces a brand-new, concurrency-safe notification protocols in Foundation: NotificationCenter.MainActorMessage and NotificationCenter.AsyncMessage. Leveraging Swift’s type system and concurrency isolation, it validates both posting and observing at compile time, completely eradicating common problems like “wrong thread” or “payload type mismatch.”
Recent Recommendations
Reverse-Engineering Xcode’s Coding Intelligence Prompt
In Xcode 26, Apple officially launched the highly anticipated AI coding assistant — Coding Intelligence. Compared to other AI programming tools on the market, does Apple have its own philosophy in designing system prompts? Peter Friese conducted an in-depth reverse engineering analysis using Proxyman. These extracted prompt contents not only shed light on how Coding Intelligence operates, but also reflect Apple’s preferences for modern development practices — such as a strong recommendation to use Swift Concurrency (e.g. async/await, actor) over Combine, and favoring Swift Testing framework and macros for writing tests. These design details serve as important indicators of Apple’s evolving development paradigm.
SwiftUI Design System Considerations: Semantic Colors
Handling semantic colors elegantly remains a challenging part of designing SwiftUI APIs. In this article, Magnus Jensen systematically analyzes the pros and cons of common approaches and proposes a macro-based solution aiming for readability, type-safety, and contextual awareness. If you’re working on a scalable and maintainable design system for your SwiftUI project, this is a valuable read.
Memory Efficiency in iOS
As project complexity grows, memory issues become inevitable — including leaks, system warnings, or even app terminations due to excessive usage. Diagnosing and managing memory is a true test of a developer’s experience and understanding. In his two-part series, Anton Gubarenko outlines a complete and practical framework for evaluating, diagnosing, and optimizing memory usage in iOS apps. A must-read for developers aiming to build robust and memory-efficient apps.
What is @concurrent in Swift 6.2?
Recent Swift updates and Xcode 26 make it clear that the Swift team is aiming to improve the concurrency development experience. With new default behaviors, developers can now write safer concurrent code without needing to understand all the fine details upfront. The newly introduced @concurrent attribute is a key part of this effort. In this article, Donny Wals provides a detailed explanation of the background and use cases of @concurrent. Simply put, it allows developers to explicitly mark functions as concurrent under the NonIsolatedNonSendingByDefault mode, signaling that they should run on the global executor — making it easier to offload work from the actor (like the main thread) without blocking it.
Some may view this as yet another keyword patch, but it reflects a broader trend in Swift: as concurrency matures, many older keywords are being replaced by better defaults or made obsolete entirely.
Swift 6.2 Java interoperability in Practice
Swift–Java interoperability isn’t new, but past approaches were often complex and error-prone. Swift 6.2 introduces a game-changer — the swift-java package, the first officially supported, toolchain-integrated, and developer-friendly solution for bridging Swift and Java. Artur Gruchała walks through a complete demo project showing how to call Java methods from Swift and build a CLI app combining both languages. He also highlights crucial pitfalls to avoid in real-world development — particularly classpath configuration, which may seem trivial but is vital for success.
Migrating to Swift 6 Tutorial
Swift 6 introduces stricter concurrency rules and a more structured programming paradigm. Understanding isolation domains, Sendable types, default behaviors, and @concurrent usage is essential when migrating. Audrey Tam presents a complete migration tutorial using a SwiftUI example project (with source code), covering everything from Xcode configuration to concurrency semantics and isolation strategies — an extremely practical guide for teams transitioning to Swift 6.2.
Modern Concurrency - Swift 6.2 Suite of Examples
How do you implement Combine-like throttle with async/await? How do you continuously observe changes to @Observable properties? How do you build a multicast-compatible async stream? In this open-source project, Lucas van Dongen provides a comprehensive set of practical examples demonstrating how to gradually migrate away from Combine and adopt Swift 6.2’s modern, type-safe concurrency patterns in real projects.
Considerations for New iOS Versions
Apple’s Liquid Glass, introduced at WWDC 25, is visually stunning — but supporting both the new and legacy design paradigms is a major strain on development resources. This raises the question: should you drop support for older iOS versions? David Smith suggests two key considerations: impact on existing users and loss of potential new users. Using real data from his app Widgetsmith, he notes that about 9% of new users still use older systems — meaning raising the minimum iOS version today would immediately exclude them. His advice: wait until the older OS usage drops into the low single digits before making such a move. Simplifying your tech stack shouldn’t come at the cost of significant business impact.