Skip: Bridging iOS and Android Development - A Real-World Test with EV Charge Stations Map

As mobile developers, we're constantly seeking tools to streamline cross-platform development. Skip, a new tool promising to convert SwiftUI iOS apps to Kotlin Jetpack Compose, recently caught my attention. The idea of writing once in Swift and deploying natively on both platforms is enticing, but how well does it actually work? I decided to put Skip to the test with one of my existing SwiftUI projects, EV Charge Stations Map (opens in a new tab), and the results were eye-opening.

Before diving into the Skip experience, let me tell you which features that my native iOS - SwiftUI app has. It's a comprehensive electric vehicle (EV) Chargers Finder app with features including:

• iOS 17+ support
• MapKit
• Core Location
• Core Data
• SwiftUI
• Cluster Map (opens in a new tab)

"Photo by Patrick Langwallner on Unsplash

Skip (opens in a new tab) aims to allow developers to use Swift and Xcode to build native apps for both iOS and Android. For an app like EV Charge Stations Map (opens in a new tab), this could potentially save significant development time and ensure feature parity across platforms.

After running EV Charge Stations Map (opens in a new tab) through Skip, I was confronted with a staggering 2,191 errors in the generated Kotlin codebase. Here's a breakdown of the main issues:

EV Charge Stations Map (opens in a new tab)'s core functionality of predicting energy use and processing route data involves complex calculations. Skip struggled to translate these Swift algorithms into equivalent Kotlin code, resulting in numerous errors.

The app heavily relies on map functionality for displaying charging stations. The transition from iOS map frameworks to Android equivalents proved problematic for Skip, leading to unresolved references and compatibility issues.

EV Charge Stations Map (opens in a new tab) integrates with various navigation apps and charging networks. Skip had difficulty translating these integrations, particularly where iOS-specific APIs were used. Cluster Map (opens in a new tab) is very crucial for my app. It's a SwiftUI library that provides a map view with clustering support. Skip couldn't handle this library and generated errors.

The complex UI of EV Charge Stations Map (opens in a new tab), including custom filters and detailed station information displays, didn't translate smoothly from SwiftUI to Jetpack Compose.

Features like Vision Pro support are iOS-specific and have no direct Android equivalent, causing Skip to generate errors or omit functionality entirely.

The app's comprehensive support for various EV models and charging standards involves complex data models. Skip struggled to accurately convert these models to Kotlin.

While Skip shows promise, it's clear that for a complex, feature-rich app like EV Charge Stations Map (opens in a new tab), it's not yet a viable solution for effortless cross-platform development. The sheer number of errors suggests that extensive manual intervention would be needed to get the converted app running on Android. That said, it's important to remember that Skip (opens in a new tab) is a new tool tackling a complex problem. The challenges it faces with an app like EV Charge Stations Map (opens in a new tab) are not trivial, and the team behind Skip is likely working hard on improvements.

As Skip matures, we can hope to see improvements in its handling of complex apps like EV Charge Stations Map (opens in a new tab). For now, it might be most useful for simpler apps with minimal platform-specific code or as a starting point for developers looking to port their iOS apps to Android. For teams considering Skip, especially those with complex apps, my advice would be to approach it with realistic expectations. It's not (yet) a one-click solution, but rather a tool that might help jumpstart your Android development if you're coming from an iOS background. The experience with EV Charge Stations Map (opens in a new tab) serves as a reminder of the complexities involved in cross-platform development, especially for apps with advanced features and integrations. While tools like Skip are pushing the boundaries, there's still a way to go before we can truly write once and deploy everywhere without significant additional work.

Complete self thoughts about general native multiplatform technologies like Kotlin Multiplatform, Skip, Play etc. has very loooong way. Because, some native SwiftUI features don't work properly even in the Apple's system frameworks, which is tragicomic 🤦🏼

Have you tried Skip or similar tools with your complex iOS apps? I'd love to hear about your experiences!

You can make some logic by checking out on this sources on your own like me:

• https://kotlinlang.org/docs/native-objc-interop.html (opens in a new tab)
• https://github.com/kotlin-hands-on/kotlin-swift-interopedia (opens in a new tab)