Skip tackles a persistent challenge in mobile development: building truly native iOS and Android apps from the same SwiftUI codebase without sacrificing performance or UI fidelity. It does this with a dual-mode architecture that either compiles Swift natively for Android or transpiles Swift source code to Kotlin, mapping SwiftUI declarative UI directly to Jetpack Compose. This approach avoids web views or custom rendering engines, producing genuinely native UI on both platforms.
what skip does and how it’s built
Skip is an open-source toolchain written in Swift that enables developers to write a single SwiftUI codebase targeting both iOS and Android. It provides two main modes:
- Skip Fuse compiles Swift code natively for Android using the official Swift SDK for Android. This leverages the Swift compiler and toolchain to produce real Swift binaries running on Android devices.
- Skip Lite transpiles Swift source code to Kotlin, enabling use of the native Android toolchain and runtime.
Central to Skip’s architecture is a Swift Package Manager (SwiftPM) build plugin integrated with Xcode. This plugin is powered by a binary called skipstone which orchestrates the build process for both platforms. Skip also includes a compatibility framework called SkipUI which maps SwiftUI APIs to Jetpack Compose equivalents, ensuring that declarative UI code written in SwiftUI renders as native Compose UI on Android.
Supporting this cross-platform bridge is a set of framework libraries — including skip-foundation, skip-model, skip-ui, and skip-bridge — that reimplement core Apple frameworks for Android. These enable over 2,200 existing Swift packages to build for Android without modification, as tracked by the Swift Package Index.
Bidirectional interoperability between Swift and Kotlin is a key feature. This allows the native Android side and Swift code to communicate seamlessly, giving developers flexibility to integrate platform-specific code when needed.
The entire project is licensed under the MPL 2.0 license, making it permissive for open source and commercial use.
why skip’s dual-mode architecture matters and what sets it apart
The standout feature of Skip is its dual-mode approach to cross-platform SwiftUI development, offering two fundamentally different ways to run Swift on Android:
Native compilation with Skip Fuse: This is the most direct approach — it uses the official Swift Android SDK to compile Swift code into native Android binaries. This means your Swift code runs as-is on Android devices, using the Swift runtime and native Swift libraries. Under the hood, this offers the most Swift-compatible and potentially highest-performance execution environment on Android.
Source-to-source transpilation with Skip Lite: Here, Swift source code is converted to Kotlin, the primary Android language. This approach taps into the mature Kotlin runtime and ecosystem, avoiding the overhead of bundling Swift runtimes on Android.
Both modes share the same SkipUI compatibility layer which maps SwiftUI APIs to Jetpack Compose. The key architectural decision is to avoid any kind of web view or custom rendering engine like React Native or Flutter. Instead, they produce true native UI components on both platforms — SwiftUI views become Compose views directly.
This approach has clear tradeoffs:
Performance and fidelity: Native compilation (Skip Fuse) offers the best fidelity to Swift semantics and performance but requires managing the Swift runtime on Android, which adds complexity.
Tooling and ecosystem: Transpilation (Skip Lite) fits better with the Android ecosystem and tooling, but the translation layer can introduce mismatches or limitations.
Code compatibility: Skip aims to support a massive library ecosystem by reimplementing Apple frameworks for Android, but some edge cases or platform-specific APIs may not be fully covered.
Developer experience: The integration with Xcode and SwiftPM means iOS developers can stay in familiar tools, but Android developers may need to understand the interplay with Kotlin and Compose.
The code quality in the repository is solid, with clear modular separation between build tooling (skipstone), compatibility frameworks, and SwiftPM plugins. The use of SwiftPM build plugins integrates well with existing Swift development workflows. The project has gathered over 3,000 stars on GitHub, indicating strong community interest.
quick start with skip
Getting started with Skip is straightforward if you have Homebrew and Xcode installed. The project provides a command-line tool skip which you install via Homebrew:
brew tap skiptools/skip
brew install skip
skip checkup
skip create
This sequence installs Skip, verifies your environment, and creates a new project that opens in Xcode. Running it on an iPhone simulator will simultaneously build and launch the Android version on a running emulator.
For native Android compilation using Skip Fuse, you need to install the Swift Android SDK:
skip android sdk install
Then create a native app project with:
skip init --native-app --appid=com.example.myapp my-app MyApp
The documentation provides detailed instructions for working with Fuse mode and understanding the Kotlin bridging.
verdict: who should consider skip and what to watch for
Skip offers a compelling path for Swift developers who want to maintain a single SwiftUI codebase for both iOS and Android with truly native UI output. Its dual-mode architecture gives flexibility depending on your priorities — whether you want the closest Swift experience on Android or better integration with Kotlin and Android tooling.
That said, the project is ambitious and has inherent tradeoffs. Managing the Swift runtime on Android adds complexity and potential limitations. Transpilation may not cover all Swift language features perfectly. Also, while the compatibility layers are extensive, some Apple APIs or third-party Swift packages might not work seamlessly on Android.
For teams invested heavily in Swift and SwiftUI, Skip is worth exploring as it solves a real problem of cross-platform consistency without resorting to hybrid or web-based UI approaches. If you have a mixed team or primarily Android developers, the transpilation path offers a bridge but expect some learning curve.
In practice, Skip is suitable for greenfield projects or gradual migration where you want to share UI and business logic code. It’s less suited for legacy projects with heavy native Android code.
Overall, Skip is a technically interesting and practically useful toolchain that pushes the boundaries of cross-platform Swift development. Its architecture and tooling reflect solid engineering choices with some unavoidable tradeoffs. Worth understanding even if you don’t adopt it fully.
→ GitHub Repo: skiptools/skip ⭐ 3,013 · Swift