Skip Introduction

• How Does It Work?
• Skip Advantages
  • vs. Writing Two Native Apps
  • vs. Other Cross-Platform Mobile Frameworks

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 work in Xcode, writing in Swift and SwiftUI. Skip acts as your Android team, generating the equivalent Android code. Skip’s goal is to disappear into the background, giving you an uncompromising iOS development experience while its Xcode plugin handles the Android version automatically.

Use Skip for bits of shared logic and UI, for your entire app, or anything in between. Skip makes integration between your Swift and Kotlin objects as well as your SwiftUI and Compose views a snap, without significant overhead or complex bridging. And it is the only dual-platform solution to deliver fully native apps for both platforms.

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. SwiftUI involves a fair bit of Swift compiler magic, and there’s no way to hide that in the Kotlin transpilation.)

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 (SwiftPM) 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 SwiftPM 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

vs. Writing Two Native Apps

On the surface, using a cross-platform solution for your mobile development needs is a no-brainer. After all, you can literally cut your development time and maintenance costs in half!

Many experienced developers believe, however, that cross-platform development requires too many compromises to make it worthwhile. In the end, they say, you’ll get better results with less hassle by writing separate iOS and Android apps using the native languages, frameworks, and tooling for each platform.

In fact, we were those developers, and we designed Skip with exactly their concerns in mind.

Imagine being on a dev team creating separate iOS and Android implementations of a mobile app. You write the iOS version in Swift and SwiftUI, and the Android version in Kotlin and Compose. You have complete freedom to craft two fully native mobile applications.

Very quickly, however, you’ll find that your team is writing a lot of code twice:

• The same model types. They’ll often have to communicate with the same network APIs, serialize to the same JSON format, and have the same persistence capabilities across platforms.
• The same logic to enforce your business rules.
• The same unit tests to ensure that your model and business logic are working.
• The same onboarding screens, settings screens, forms, lists, and other “standard” UI. Parts of your app might need careful tailoring for each mobile OS, but much of the experience may be identical across iOS and Android.

You tell yourselves that the massive duplication of effort and all the extra overhead to coordinate models, data formats, logic, and tests across platforms are worth it. After all, you don’t want to compromise the app by introducing non-native cross-platform code. That has traditionally come with its own very real costs, for example:

• Training or hiring for a new programming language (JavaScript, Dart, etc.) and set of application frameworks.
• Bloating the app with an added runtime and/or garbage collector.
• Degrading the user experience with non-native UI.
• Making debugging fiendishly difficult.

But what if you could share common code and tests without these costs? What if you could:

• Develop with a programming language and set of frameworks you’re already using.
• Avoid the overhead of adding another runtime or garbage collector to either platform.
• Produce entirely native user interfaces - SwiftUI on iOS and Compose on Android - from common UI code.
• Debug with the native tools on each platform.
• Call native API from your shared code whenever you need to, right inline.

That is Skip. With Skip, you write your shared code in Swift, using standard iOS frameworks like Foundation, SwiftUI, and XCTest. On iOS, your code is used as-is. On Android, Skip translates your code into Kotlin and Compose, and your tests into JUnit. The result is fully native code on both platforms, complete with equivalent unit tests. And because the resulting code is native, it means:

1. Your Swift code integrates perfectly with the parts of your app you choose to develop separately on iOS and Android.
2. You are never limited by what Skip does or does not support. You can always implement and trivially call out to platform-specific solutions, just as you would when developing separate iOS and Android apps.

Skip can save you enormous amounts of time and effort, without requiring you to compromise your app.

vs. Other Cross-Platform Mobile Frameworks

Skip has many advantages 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 can benefit 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 shared code IDE is Xcode, the premiere integrated app development environment for Swift and SwiftUI. 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 SwiftPM 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.

Check out our comparison matrix to see how Skip compares to several popular cross-platform solutions across various technical axes.