
At Areeb Technology, we’ve always prided ourselves on staying at the forefront of innovation and continuously exploring cutting-edge tools to streamline our development pipeline. One of our most impactful recent endeavors has been the transition of one of our client applications to Compose Multiplatform (CMP)—a bold move that has reshaped our approach to building cross-platform user interfaces. This journey not only allowed us to tap into the power of shared codebases and modular design, but also challenged us to refine our existing processes and experiment with new best practices. In this blog post, we’ll share the highs and lows of this migration experience, discuss the key takeaways that influenced our decision-making, and outline the lessons we learned along the way.
Even though we had already integrated Jetpack Compose into our workflow, migrating to Compose Multiplatform (CMP) presented a new layer of complexity. We needed to rethink several aspects of our development process, including:
✅ Removing Activities and adopting a Single Activity approach.
✅ Migrating from Retrofit to Ktor for networking.
✅ Switching from Hilt to Koin for dependency injection.
✅ Refactoring dependencies from buildSrc to Version Catalogs.
Committing to this migration was no easy choice, but we knew that Areeb Technology’s environment was the ideal proving ground for tough decisions. Our culture thrives on pushing boundaries, embracing experimentation, and learning through hands-on execution. this allow the team to learn, experiment, and execute the transition. It has been both a challenging and rewarding journey.
Challenge #1: Rethinking Development for Kotlin-First
The first challenge we faced was shifting our mindset from traditional Android-native development to a fully Kotlin-first approach.
CMP is not just an Android framework—it’s designed for Android, iOS, and more. This meant we had to:
✅ Replace Java-based dependencies with pure Kotlin alternatives.
✅ Adjust our architecture to avoid Android-specific APIs.
✅ Think in terms of shared logic rather than platform-specific solutions.
This shift required us to reevaluate every tool and library to ensure full Kotlin Multiplatform (KMP) compatibility.
Key Migration Steps and Challenges
1️⃣ Removing Activities & Adopting a Single Activity Model
CMP doesn’t rely on Activities or Fragments. Instead, we adopted a Single Activity architecture with Compose Navigation, which improved UI state management.
2️⃣ Migrating from Retrofit to Ktor
Since Retrofit is Java-based and Android-specific, we transitioned to Ktor, a Kotlin-first networking library that works seamlessly across platforms. This change improved maintainability and future scalability.
3️⃣ Switching from Hilt to Koin
Hilt, which depends on Dagger, is deeply tied to Android. To enable cross-platform DI, we migrated to Koin, which is more lightweight and fully Kotlin-based.
4️⃣ Moving from buildSrc to Version Catalogs
To simplify dependency management, we replaced buildSrc with Gradle Version Catalogs, allowing better control over shared and platform-specific dependencies.
5️⃣ Handling Platform-Specific Code
While most of our code is shared, some platform-specific implementations were still needed, particularly for:✅ Native APIs (e.g., Camera, File Storage, Notifications).✅ iOS-specific UI optimizations due to Skia rendering performance issues.
6️⃣ Addressing iOS Stability Concerns
CMP for iOS is still in beta, and some performance challenges remain. Since JetBrains plans to stabilize CMP for iOS in 2025, we decided to:
✅ Make Android fully CMP now
✅ Keep iOS native until CMP iOS is more stable
Our Future Plans: Step-by-Step
🟢 Step 1: Make Android Fully CMP, Keep iOS Native
We are dropping Android native code and migrating fully to CMP, while keeping iOS native until stability improves.
🟢 Step 2: Set Up CI/CD for CMP
We will build CI/CD pipelines for CMP, aligning with Areeb’s automation and code quality guidelines.
🟢 Step 3: Monitor iOS Stability & Performance
Since CMP for iOS is still evolving, we will closely observe performance improvements throughout 2025.
🟢 Step 4: Explore Web as a Target Platform
Once our Android CMP version is fully stable, we will start experimenting with Web support, expanding our product reach.
🟢 Step 5: Fully Adopt CMP for iOS Once Stable
Once CMP for iOS is production-ready, we will drop the native iOS codebase and transition to a single Kotlin-first codebase.
Advice: If You're Starting with a Native App
If you’re starting with a native Android application, we highly recommend using Kotlin-first tools from day one. This will make migrating to CMP much smoother in the future, allowing you to easily switch to a cross-platform approach without major rewrites.
Recommended Tools for Native Development
✅ Use Jetpack Compose for UI – Compose is a modern UI toolkit that simplifies UI creation in Android. It is Kotlin-based, declarative, and has great potential for cross-platform migration, making it an essential part of your architecture.
✅ Use Ktor for Networking – Instead of Retrofit, adopt Ktor, which is multiplatform-ready from the start. This allows seamless integration with cross-platform targets.
✅ Use Koin for Dependency Injection – Instead of Hilt, use Koin, a lightweight DI framework that works across Android, iOS, and more.
✅ Use Version Catalogs for Dependency Management – Instead of buildSrc, use Gradle Version Catalogs for better control over dependencies.
✅ Use Coil for Image Loading – Coil is a Kotlin-first image loading library that works across platforms, making it ideal for your future CMP migration.
✅ Use Kotlin Serialization for Data Serialization – Kotlin Serialization is multiplatform-compatible and provides an efficient way to serialize and deserialize data, making it perfect for shared data formats across platforms.
✅ Use Room for Local Databases – Room can be used for local database storage, with the ability to later abstract database layers for cross-platform usage.
✅ Use DataStore for Preferences – DataStore is a great choice for storing key-value pairs and small data in a consistent way, and it’s easy to migrate to the multiplatform version if needed.
✅ Minimize Android-Specific Code – Avoid using Android-exclusive APIs when possible. Opt for pure Kotlin libraries that can later be shared across platforms.
By following these best practices, you’ll set up your native app in a way that allows for seamless migration to CMP in the future. This flexibility will be a huge advantage if your clients later decide to expand to iOS or Web. While you may need to fix some platform-specific issues, your core architecture will already be ready for a smooth transition.
Performance: Native vs. CMP vs. KMP
While Compose Multiplatform (CMP) provides an excellent balance between development speed and shared UI, it’s important to acknowledge that native development remains the best option for high-performance applications.
📌 Key Performance Takeaways
✅ Native apps deliver the best startup times, UI performance, and memory efficiency.
✅ CMP simplifies cross-platform UI, but it introduces some overhead due to shared rendering (Skia).
✅ KMP (without CMP) allows shared business logic while keeping native UI for maximum performance.
✅ JetBrains is actively improving CMP for iOS, and by 2025, performance should be much closer to native.
For now, CMP is the best choice for teams wanting to share UI across platforms while keeping acceptable performance. However, for high-performance apps, a native approach might still be preferable.
Final Thoughts
Migrating our client’s app to Compose Multiplatform has truly been a transformative journey for the team at Areeb Technology. Throughout this process, we embraced a Kotlin-first architecture, streamlined our approach by removing Activities, adopted Ktor, and reorganized our codebase to unify UI and business logic. These changes weren’t just technical upgrades—they reshaped how our team collaborates, experiments, and evolves together. Each challenge we tackled offered an opportunity to refine our strategies and strengthen our expertise.
Looking ahead, we’re eager to build on these insights and continue exploring new possibilities in cross-platform development. If you’re ready to transform your own applications or need a trusted partner to help navigate the complexities of Compose Multiplatform, we’re here to support you every step of the way.
Reach out to Areeb Technology today, and let’s create the next generation of seamless, efficient, and engaging digital experiences—together.
🔗 References & Further Reading: