Skip Documentation

What is Skip?

The mobile app market is divided between iOS and Android. iOS is popular in the West and leads in app revenue, while Android has more worldwide users.

Neglecting either platform means leaving behind a large percentage of potential users. In our experience, however, apps are generally made for iOS first. Clients ask for an iOS app, then expect a port to the Play Store. Large tech companies design for iOS first, then adapt their designs for Android.


Skip is a new technology for building native iOS and Android apps that is designed for the iOS-first app ecosystem.

With Skip, you develop a modern iOS app. You work in Xcode, coding in Swift and SwiftUI. Skip acts as your Android team, generating an equivalent Android app alongside your iOS one. Skip’s goal is to disappear into the background, giving you an uncompromising iOS development experience while using its Xcode integration to handle the Android version automatically.

This doesn’t mean, however, that you can’t differentiate your Android app, or that you can’t take advantage of Android-specific capabilities. On the contrary, Skip makes Android customization a snap, and it is the only dual-platform solution to deliver fully native apps for both platforms.

So while we believe most developers will rely on Skip to maintain the vast majority of their Android app, it is entirely up to you. A large team might choose, for example, to write their shared business logic in Swift and Xcode, while using Android Studio to code some or all of their Android UI directly in Kotlin and Compose. Skip allows your Swift and Kotlin objects as well as your SwiftUI and Compose views to integrate without significant overhead or complex bridging.

How Does It Work?

At Skip’s heart is its intelligent Swift to Kotlin language transpiler. The transpiler uses Apple’s own SwiftSyntax library - the same library used in Swift macros - to parse your Swift source. It then converts your code to nice, human-readable Kotlin, with even your comments intact. Thanks to the similarities between the languages, the output is often no different than Kotlin you’d write by hand. (One notable exception is our transpilation of SwiftUI into Compose. The fact that SwiftUI is object-based and Compose is function-based requires some inelegant source transformations.)

While it does not fully replicate the experience you’d get in Xcode, you can experiment with the Skip transpiler in our online playground.

Alongside the transpiler, Skip ships a Swift Package Manager (SPM) to Android Gradle project converter. Skip bundles these tools together into an Xcode build plugin. We refer to this Skip toolchain as SkipStone.

Translating your source code and SPM packages, however, isn’t enough. Your apps rely on building blocks like the Swift standard library, Foundation, and SwiftUI. The Skip open source libraries provide Android-specific reimplementations of portions of iOS’s Swift, Foundation, Observation, SwiftUI, and other frameworks, from model layer fundamentals like URLSession, and JSONDecoder to complex UI components like NavigationStack. Skip even translates and runs your XCTest unit tests as JUnit tests for automatic unit testing parity on Android! We call this suite of packages SkipStack.

SkipStone is proprietary and requires a license key, while SkipStack is free and open source. With the community’s help, we will expand SkipStack over time to build a robust ecosystem of dual-platform libraries.

Skip Advantages

Skip’s advantages over writing separate iOS and Android apps is clear. With Skip, you can deliver fully native apps for both platforms with one team, one language, and one codebase. Your development effort can literally be cut in half.

Here are some additional advantages Skip has over competing cross platform solutions:

  • Genuinely Native. Skip apps are truly platform-native: Swift and SwiftUI on iOS, and Kotlin and Compose on Android. Take full advantage of new platform features and get automatic integration with core functionality like accessibility, which is a requirement for compliance in many fields. Skip apps don’t just “look native”, they actually are native. You know the difference, and so do your users.
  • Totally Transparent. With Skip, no part of your app is hidden from your view… or from your debugger. Skip transpiles your Swift directly into Kotlin source code that you can inspect and customize. Skip bundles this source into standard Gradle projects for seamless integration with Android IDEs and debuggers. Skip has no hidden runtime, and Skip’s support libraries are fully open source. Skip bares it all.
  • Featherweight. The iOS side of a Skip app benefits from transparent adoption, with no dependencies on any Skip frameworks. Not only does this keep your iOS code blissfully unencumbered by any multi-platform considerations, it also keeps app install sizes tiny: as little as tens of kilobytes for iOS, with the Android side a relatively svelte 4.0M. Smaller apps are quicker to download and launch, and slower to be offloaded by the system.
  • Memory Efficient. With no additional managed runtime overhead or garbage collection to contend with, Skip apps are as efficient as they can possibly be on both platforms: bare metal on iOS and ART bytecode on Android. This leads to a smooth, hitch-free user experience with your app. And maintaining a low memory watermark means that your apps are faster to start and slower to evict on a user’s device.
  • Idyllic IDE. Skip’s IDE is Xcode, the premiere integrated app development environment for Swift. Xcode’s lightning fast code editor coupled with Skip plugin’s automatic transpilation means you can create and maintain the bulk of your app without ever leaving the comfort of Xcode. And when you are ready to customize the Android side of the project, you can use Android Studio to open Skip’s transpiled Gradle project and develop in tandem.
  • Platform Perfect. Skip generates standard Kotlin and Compose, so integrating with Android libraries is painless. Call other Kotlin and Java code directly, with no bridging required.
  • Foundationally open. Skip’s intelligent Swift to Kotlin language transpiler is only half the story. iOS code relies on many built in frameworks, which is where the free and open-source Skip libraries come in. These libraries provide Android-specific reimplementations of the fundamental building blocks of iOS apps, such as URLSession, JSONDecoder, Data, Date, Calendar, Logger, UserDefaults, etc.
  • CI friendly. Skip transpiles your Swift XCTest test cases into Kotlin JUnit tests. This means your unit tests run on both platforms, ensuring that your logic tests perform identically. With one keyboard shortcut from Xcode, you can run all your XCTest and JUnit tests side-by-side to compare their results and performance. And Skip is CI-friendly: Skip can transpile and run your tests headlessly using SPM and Gradle either locally or remotely, making acceptance testing across platforms a breeze.
  • Ejectable. Your code is your own – both the Swift inputs and Kotlin outputs – so you aren’t locked into an ongoing dependency on the Skip transpiler. You can stop using Skip at any time and maintain your Swift and Kotlin codebases yourself. Adopting Skip as an ancillary part of your iOS app means you can prioritize and ship an unencumbered iOS experience while continuing to develop your Android experience.