Shortly after the Swift community released the official Android SDK preview, Skip announced that its Skip Fuse edition is now free for eligible indie developers to build Android apps.
Compared with Skip Lite, which has been free to use for independent developers for over a year, Skip Fuse represents a substantial technical leap. While Skip Lite transpiles Swift code into Kotlin, Skip Fuse directly leverages the official Swift SDK for Android to cross-compile Swift source code into native ARM binaries that run on Android. This means developers are no longer restricted to “Skip-aware” dependencies — they can now use any Swift package that compiles for Android.
According to Swift Everywhere, more than 2,000 Swift packages already support the Android platform, including popular libraries such as Alamofire, SwiftSoup, and swift-sqlcipher. In other words, Fuse mode allows developers to take full advantage of the standard SwiftPM ecosystem. This significantly broadens the range of usable dependencies while reducing the complexity of project migration and maintenance.
Architecturally, Skip Fuse adopts a hybrid approach: the business logic layer is compiled and executed as native Swift, while the SwiftUI DSL is translated at build time by the Skip Fuse UI module into Jetpack Compose code — providing a fully native user experience on Android. This approach preserves SwiftUI’s declarative syntax while adhering to Android’s design conventions.
This policy change may encourage many indie developers and small teams to favor solutions with cross-platform potential. Even developers focused primarily on Apple’s ecosystem might now consider introducing abstraction layers. This prepares their projects for future multi-platform expansion — even if they currently rely on some of Apple’s private frameworks.
Naturally, Skip’s definition of an “indie developer” comes with clear conditions: it applies only to individuals or teams of up to two people, with annual revenue below US $30,000, and it permits the release of one closed-source commercial app (open-source projects are unlimited). Even so, this policy opens the door for Swift developers to enter the Android market at virtually no cost — offering new opportunities for experimentation, growth, and revenue on a massive platform.
While more cross-platform Swift solutions are likely to appear in the future, Skip has already provided a clear and practical path for bringing Swift to the Android ecosystem. The community now looks forward to seeing similar, mature approaches extended to Linux, Windows, and even embedded platforms — laying a stronger foundation for Swift’s truly multi-platform future.
Recent Recommendations
The Art of SwiftData in 2025: From Scattered Pieces to a Masterpiece
With the removal of parent-child context concept, implementing “cancelable edits” in SwiftData has become increasingly challenging. In this comprehensive article, Mathis Gaignet demonstrates how to build a “cancelable, reusable, low-boilerplate” upsert architecture by constructing a dedicated ModelContext for editing state, replacing scattered form states and fragile rollback solutions.
Rather than presenting a “standard answer,” the author showcases the complete thought process from problem discovery to solution evolution. The article deeply explores the underlying mechanisms of @Model and @Query macros, reveals the traps of PersistentIdentifier’s temporary and permanent states, and uncovers hidden bugs caused by context synchronization delays. This exploratory writing style helps readers understand not just “how to do it,” but “why it’s done this way.”
Back Market x Tuist - Part I: Why We Moved Our iOS Project To Tuist
In Swift projects, SPM handles both code modularization and project structure management. However, as projects scale, limitations emerge: frequent dependency resolution, lack of build settings and custom phases, inability to run scripts, xcodeproj file conflicts, difficulty unifying inter-module rules, and limited SPM plugin capabilities.
In this article, Alberto Salas explains how his team migrated project structure management from SPM packages to Tuist targets, systematically outlining the underlying issues, exploration process, and key decisions. In Part II, he further share how the migration was completed without disrupting daily development — and how it led to measurable improvements in build performance.
This isn’t about abandoning SPM entirely—project structure and generation are handed to Tuist while dependency management remains with SPM. The article compares SPM, Bazel, and Tuist trade-offs. The author notes that while Bazel is more powerful, they chose Tuist because it better matched their team’s capabilities and project characteristics. This reminds us that the key to tool selection isn’t “the strongest” but “the most suitable”—especially for small to medium teams, solutions that are self-manageable and maintainable often provide more long-term value.
Making Apps More Personal with Language Discovery
The traditional “select primary language” (Locale.preferredLanguages) model assumes users have a single language preference, but in reality, people often use multiple languages in different contexts—English at work, French socially, and Spanish for media consumption. Apple introduced Language Discovery in iOS 26, using on-device machine learning to automatically infer users’ language habits based on input patterns, content consumption, communication languages, and app preferences, all while ensuring privacy. Letizia Granata explains this intelligent system for recognizing user language preferences.
Through Language Discovery, apps can more accurately respond to users’ linguistic and cultural backgrounds, achieving personalization at the localization level. This feature marks an important shift in Apple’s multilingual support: from passive configuration to active understanding, from single language to multilingual coexistence, providing developers with a new foundation for building more inclusive and authentic app experiences.
Xcode 26.1 CPU Usage Issue: Warning and Temporary Workarounds
iOS developer Artem Mirzabekian reports that Xcode 26.1 experiences abnormal CPU usage when running the iOS 26.1 simulator. The issue stems from the wallpaper-rendering-related MercuryPosterExtension process repeatedly crashing and restarting in the iOS 26.1 simulator, causing excessive CPU consumption. Xcode 26.2 (beta) is also affected.
Temporary workarounds: Use the iOS 26.0 simulator, or change the wallpaper in the iOS 26.1 simulator and delete the default all-black wallpaper.
Swift 6 Concurrency Model: Technical Challenges and Community Debate
Michael Tsai compiled two important discussions about Swift 6 concurrency. The first focuses on Swift 6.2’s “Approachable Concurrency” improvements; the second addresses specific technical issues like the practical usage and limitations of MainActor.assumeIsolated and @preconcurrency.
Community opinions are clearly divided. Supporters believe that default main-thread isolation effectively prevents the common “accidentally running on background thread” problem, lowering the barrier for beginners and UI-intensive projects, with some teams successfully completing major app migrations. Critics point out that full UIKit apps still struggle to fully adopt Swift 6 mode, with frequent integration issues with Core Data and third-party frameworks, cryptic error messages, and ongoing language evolution causing code decay. More radical voices even argue the current concurrency model has become an “inoperable patchwork system” requiring a “complete reset.”
The overall consensus: Swift 6 concurrency benefits highly depend on a project’s concurrency complexity—it significantly helps single-threaded or UI-driven applications, but for concurrency-intensive or tightly system-coupled projects, migration remains challenging.
Deep Dive into Animation on visionOS
Spatial computing not only transforms user experience but also raises the bar for developers—many techniques effective in flat interfaces no longer apply in three-dimensional space. Starting from “spatial interaction perceptibility and comfort,” Cristian Díaz proposes an animation decision framework: who authors the animation (designer-crafted vs. runtime-generated), what needs animation (SwiftUI windows vs. RealityKit entities), and what complexity level (micro-interactions vs. choreographed performances). Building on this framework, he systematically outlines visionOS’s five rendering paths and ten animation mechanisms, clearly listing suitable scenarios, situations to avoid, and implementation essentials for each approach.
Even if you’re not a visionOS developer, you can benefit from this article. Cristian’s “deriving technical choices from perceptual needs” approach to animation design thinking applies equally to dynamic design on other platforms and interfaces.
Find the SwiftUI Views that Update the Most Using Instruments
Xcode 26 adds a SwiftUI-specific analysis tool to Instruments that tracks view update counts and duration, using All Updates Summary and Cause & Effect Graph to identify which views “update too frequently” and their specific trigger chains. Mark Szymczyk demonstrates through practical examples how to create SwiftUI Profiling sessions, sort views by update count/duration, and trace update sources using cause-and-effect graphs.
Beyond diagnosing symptoms, understanding SwiftUI’s refresh principles is essential for reducing unnecessary redraws at the source. In my article Understanding SwiftUI’s View Update Mechanism: Starting from a TimelineView Update Issue, I systematically explain view declarations, response mechanisms, and recursive update decision logic through a TimelineView case study. Only by understanding “why views update” and “how the system decides whether to recalculate view declaration values” can optimization avoid becoming patchwork fixes.
Tools
imessage-kit: Messaging Integration for AI Agents
imessage-kit is a powerful open-source iMessage SDK developed by Photon, ideal for integrating iMessage into AI agents or automation workflows. Key features include:
- Modern API: Provides elegant chaining (Fluent API) for easily implementing “receive message A, reply B” logic
- Comprehensive Functionality: Supports not only text sending/receiving but also images, various file types, and real-time message monitoring
- Type-safe and Cross-runtime: Written entirely in TypeScript with excellent type support, compatible with both Node.js and Bun
- AI Integration Friendly: Officially positioned to provide messaging integration capabilities for AI Agents, an interesting attempt at connecting the physical world with AI
It works by directly reading the iMessage database (chat.db) and combining AppleScript for automation, thus limited to macOS and requiring “Full Disk Access” permissions.
The library uses the SSPL-1.0 license, prohibiting use in creating competing products (like other messaging SDKs/APIs), but allowing use for internal business, personal projects, and educational purposes. Notably, Photon also offers an advanced version supporting threaded replies, message retraction/editing, live typing indicators, and enterprise-grade hosting services. More information available on their website.
SwiftUI-DetectGestureUtil: Bind Multiple Custom Gestures to a Single SwiftUI View
In SwiftUI, having a single view simultaneously recognize multiple gestures has always been challenging. Developed by Saw-000, SwiftUI-DetectGestureUtil introduces an independent “detection phase,” allowing developers to confirm only one among multiple custom gestures, bypassing constraints from default system combination methods (simultaneous, sequenced, exclusive) for more natural multi-gesture interactions.
It cleanly splits the gesture recognition workflow into two phases:
- Detection Phase (
detectGesture): Continuously updates state throughout the gesture lifecycle until a custom rule matches and returns a gesture type - Handling Phase (
handleGesture): After detection, continuously tracks gesture progress, using.yetand.finishedto explicitly control the lifecycle
This model offers new approaches for building complex interactions (like “double-tap + drag,” “circle drawing,” “custom stroke detection”). With DetectGestureState, developers can access all touch points, timing, and geometric information within a single gesture cycle, achieving expressiveness and precision far exceeding SwiftUI’s native Gesture API.