Kotlin Multiplatform plus Compose Multiplatform (CMP) hit stable earlier this year and adoption jumped from around 7 percent in 2024 to roughly 23 percent in 2025 among new cross-platform projects. That rise has pushed every indie dev to ask the same question: should I switch from Flutter to CMP, or double down on Flutter? This post is the honest 2026 answer from someone who has shipped production apps on both.
Short version: for solo indie developers shipping consumer mobile apps, Flutter still wins in 2026. The ecosystem is deeper, the hiring pool is larger, and the cost of ownership is lower. CMP wins when you have an existing Kotlin codebase, a team that is already Android-first, or a requirement for native Compose UI on desktop where Flutter's desktop story is less mature. Details, decision matrix, and real TCO numbers below.
Why this debate is suddenly hot in 2026
Three things changed in the last 12 months:
- CMP shipped stable. Compose Multiplatform 1.6 dropped the beta tag in late 2025. iOS support is finally production-grade. Before that, Flutter had no real competitor for cross-platform UI from a single codebase.
- Kotlin 2.2 shipped K2 compiler with significant improvements. Build times dropped 40 percent compared to the old K1 compiler. Kotlin apps feel snappier to develop.
- Flutter had a stable 2025 but no revolutionary changes. Impeller stabilized on Android, Dart macros were paused, and the Cupertino redesign is still pending. No big story to match CMP's stable release.
The result is a legitimate second option for the first time in years. That is why every cross-platform comparison article is getting linked on Hacker News and r/FlutterDev in 2026.
The three approaches in one sentence each
- Flutter: Dart language, single codebase, Skia or Impeller rendering engine, same UI on every platform. Google-backed, mature ecosystem.
- Kotlin Multiplatform (KMP): Kotlin language, shared business logic, native UI (SwiftUI on iOS, Jetpack Compose on Android). Maximum native feel, more code.
- Compose Multiplatform (CMP): Kotlin plus Compose UI, shared code for both logic AND UI, rendered via Skiko (Kotlin wrapper around Skia). Closer to Flutter in spirit.
This post focuses on Flutter vs CMP since those are the two that share a UI. If you want logic shared with native UI, KMP is the fit, and that's a different decision.
UI rendering: Impeller versus Skiko
Both frameworks skip native platform UIs and render their own widget trees.
| Dimension | Flutter Impeller | CMP Skiko |
|---|---|---|
| Underlying graphics | Metal (iOS), Vulkan/OpenGL (Android) | Skia via Skiko |
| Binary size impact | 4-6 MB | 6-10 MB |
| Frame time on mid-tier Android | 8-11 ms | 10-14 ms |
| First-frame time | ~100 ms | ~130 ms |
| iOS native feel | Cupertino widgets (improving) | Compose widgets (look Material) |
| Custom shaders | Fragment Program API | AGSL shaders on Android, Metal on iOS |
Flutter is faster by a small margin. CMP is younger but closing the gap. For most apps neither performance difference is noticeable.
Ecosystem and packages
The ecosystem gap is the biggest real difference between the two frameworks.
| Category | Flutter (pub.dev) | CMP (Maven / KMP) |
|---|---|---|
| Total packages | 50,000+ | ~3,000 multiplatform-ready |
| Package quality signal | pub.dev scoring, popularity, pubpoints | Klibs.io (Kotlin multiplatform search) |
| Firebase support | Official, all products | Official KMP SDK, subset of products |
| RevenueCat | First-class Flutter SDK | Community KMP bindings |
| AI SDKs | openai_dart, firebase_ai, genkit_dart, anthropic_sdk_dart, google_generative_ai | Kotlin OpenAI SDK, experimental Anthropic bindings, no first-class Gemini for CMP |
| Navigation | go_router (mature) | Voyager or Navigation Compose (newer) |
| State management | BLoC, Riverpod, Signals, Provider | ViewModel, KMM-ViewModel, MVI libraries |
Flutter's ecosystem is roughly 10x larger for cross-platform-ready packages. Every boring integration (Stripe, Mixpanel, PostHog, Branch, Adapty, Superwall, Intercom) has a maintained Flutter package. CMP frequently forces you to use platform-specific bindings and write the Kotlin glue yourself.
AI integration
This is the biggest Flutter advantage in 2026 and the gap is widening. Flutter has first-party AI support via the GenUI SDK, Flutter AI Toolkit, Firebase AI Logic, and Genkit Dart. CMP has manual integration with whatever Kotlin SDK you find.
| AI capability | Flutter | CMP |
|---|---|---|
| Gemini client SDK | firebase_ai (official) | Use Gemini REST or Android-only SDK |
| OpenAI client SDK | openai_dart (mature) | Kotlin OpenAI SDK (server-focused) |
| Claude client SDK | anthropic_sdk_dart | Experimental Kotlin bindings |
| Streaming chat UI | AI Toolkit ships one | DIY |
| Structured output UI | GenUI SDK | No equivalent |
| Multi-provider abstraction | Several community packages | DIY |
If your 2026 app has a meaningful AI component, Flutter saves weeks of integration work.
Cost of ownership for a solo indie
Real TCO numbers for a solo indie shipping a consumer mobile app over 12 months.
| Line item | Flutter | CMP |
|---|---|---|
| Learning curve (hours to first shipped app) | 60-80 | 100-140 |
| Tooling cost | Free (VS Code + Android Studio) | Free (IntelliJ / Android Studio) |
| Apple Developer Program | $99 | $99 |
| Google Play Console | $25 | $25 |
| Expected hours to ship v1 | 280-400 | 380-500 |
| Expected hours for AI feature | 8-24 | 40-80 |
| Boilerplate market | Mature (Flutter Kit, ApparenceKit, FlutFast, ShipFlutter) | Minimal (mostly templates not full kits) |
| Stack Overflow answers | ~180,000 Flutter tags | ~12,000 multiplatform tags |
| Community size (r/FlutterDev vs r/Kotlin) | ~220,000 subs | ~95,000 subs (Kotlin total, CMP subset smaller) |
For solo indies, Flutter ships ~30 percent faster in 2026 because the ecosystem is mature and the boilerplate market already solved the plumbing. CMP closes this gap each year but is not there yet for a solo builder.
Hiring and freelancer availability
If you ever need to bring in a second pair of hands, the talent pool matters.
- Flutter contractors (2026): 95,000+ on Upwork, 40,000+ on Toptal. Rates $35 to $120 per hour depending on seniority and region.
- CMP contractors: 8,000-12,000 on Upwork (growing fast). Rates $50 to $150 per hour. Fewer juniors, more seniors who were already Android experts.
- Boilerplate market: 5+ paid Flutter boilerplates with active maintenance. For CMP, essentially zero equivalent commercial kits as of April 2026.
Hot reload and dev loop
Both frameworks have a hot-reload story but the dev loop quality differs.
- Flutter hot reload: ~0.5 to 1.5 seconds. State preserved. Mature, works 98 percent of the time.
- CMP hot reload: ~1.5 to 3 seconds via Compose Hot Reload (Kotlin 2.2+). State preserved but less robust. Still bails to full restart more often than Flutter.
Flutter's edge here is real and noticeable after a full day of coding.
When CMP actually wins
Three scenarios where CMP is the better pick:
- You already have a Kotlin codebase. If your app started as native Android and you want to add iOS, CMP lets you reuse existing business logic and data models directly. Flutter would require a full rewrite.
- Your team is Android-native. If everyone on the team is a Kotlin specialist and nobody knows Dart, CMP is the low-friction path.
- You ship desktop as a primary target. JetBrains apps (IntelliJ family) are Compose-based. CMP has better desktop tooling than Flutter's desktop targets, which are still labeled stable but feel less polished.
When Flutter wins (clearly)
The seven Flutter wins in 2026:
- You are a solo indie with no existing codebase.
- Your app has AI features (see AI gap above).
- You need a deep ecosystem of third-party integrations.
- You hire freelancers and want a large talent pool.
- You value hot reload speed (full-day effect).
- You want to start from a paid boilerplate.
- Your app prioritizes iOS and Android over desktop.
The hybrid pattern some teams use
A growing pattern: Kotlin Multiplatform for shared business logic, Flutter for the iOS/Android UI. The KMP library compiles to both a Kotlin JAR (for an Android separate app if needed) and, via kotlin-native, to an Apple framework. Flutter consumes both via platform channels.
This works for apps with heavy shared domain logic (offline sync, conflict resolution, complex business rules) and a team that wants Flutter's UI speed. It's more complex than pure Flutter, so only do it if you have a real reason.
Decision matrix
| If your situation is... | Pick |
|---|---|
| Solo indie, no existing code, consumer app | Flutter |
| Two-person team, consumer app, needs AI | Flutter |
| Existing Kotlin Android app, adding iOS | KMP (logic) + CMP (UI) or KMP + SwiftUI |
| Desktop-first product (IDE, pro tool) | CMP |
| Mobile-first, desktop as nice-to-have | Flutter |
| Enterprise team already on Kotlin | CMP or KMP+SwiftUI |
| Freelance agency shipping many apps | Flutter |
| Games / rich custom graphics | Flutter (Flame engine) or native |
What the next 12 months will probably change
- CMP iOS parity improves. More packages ship iOS-ready, CMP Resources API stabilizes, Cupertino-style widget libraries emerge.
- Flutter ships the Cupertino redesign. The standalone package:cupertino lands, closing the "Flutter looks dated on iOS 26" argument.
- AI integrations converge. Kotlin Gemini SDK likely ships multiplatform support. The AI gap narrows.
- CMP freelance pool doubles. Kotlin devs pick it up faster than the other direction.
- Flutter stays dominant for solo indies. The ecosystem moat compounds.
What The Flutter Kit ships
The Flutter Kit exists because Flutter is still the best cross-platform choice for indie developers in 2026. The kit ships with the entire Flutter-specific stack wired: Firebase, RevenueCat, OpenAI, Gemini, go_router, BLoC or Riverpod, Material 3, and a release-ready build config for both stores. If you pick Flutter based on this comparison, this is the fastest path from "decided" to "shipped."
$69 one-time, unlimited commercial projects. See every integration on the features page or jump to checkout.
Final recommendation
In April 2026, pick Flutter if you are a solo indie, if your app has AI, or if you hire freelancers. Pick CMP if you have an existing Kotlin codebase, if your team is Android-native, or if desktop is a primary surface.
The CMP rise is real and the trend is against Flutter's dominance over the next 24 months. But for the indie-developer use case right now, today, the ecosystem and AI gap make Flutter the lower-risk choice. Revisit in 12 months.