Menu

Skip Introduction

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.

What Is Skip?

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 app. 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 Android API 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.

Skip Advantages

Screenshot

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.

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’s tools bridge your Swift and SwiftUI to Kotlin and Compose, and your tests to 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 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 don’t just “look native”, they are native: SwiftUI on iOS and Jetpack Compose on Android. You know the difference, and so do your users. 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.
  • Totally Transparent. When you use Skip, no part of your app is hidden from your view… or from your debugger. Skip’s libraries are open source, and there is no complex runtime to debug.
  • Featherweight. With SkipZero, your iOS app has no dependencies on any Skip frameworks. And the resulting Android app only requires a few Skip open source libraries.
  • Memory Efficient. With no additional managed runtime, Skip apps are as efficient as they can possibly be on both platforms.
  • Idyllic IDE. Skip’s IDE is Xcode, the premier development environment for Swift. For serious Android customization, incorporate Kotlin written directly in Android Studio.
  • Platform Perfect. Skip bridges seamlessly with Kotlin and Compose, so integrating with Android libraries is painless.
  • Foundationally open. Swift-on-Android is only half the story. Skip’s app development frameworks are all free and open-source.
  • CI friendly. Skip has cross-platform unit tests too! Ensure that your logic performs identically across platforms. Run your tests either locally or remotely, making acceptance testing a breeze.
  • Ejectable. Your code is your own – both the Swift inputs and Android outputs – so you aren’t locked into an ongoing dependency on the Skip tools.

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