To distribute a lightweight, highly usable, well-engineered app for different platforms, ideally, you'll have to rewrite the same app using platform-specific development toolkits. This approach isn't practical for surviving in the modern competitive software development market, so development teams use cross-platform frameworks that help build cross-platform apps using a single codebase.

Cross-platform development frameworks use various strategies to run the same UI and business logic written in a specific language on different platforms. Some frameworks, like Neutralinojs and Capacitor, use webviews and let developers render web apps as native-like, lightweight apps. Meanwhile, some frameworks draw native graphics on a cross-platform canvas surface without using web technologies.

The Compose Multiplatform (CMP) project renders apps on a cross-platform canvas surface through Kotlin Multiplatform (KMP), similar to Flutter and Dart, and offers a productive cross-platform development approach for modern development teams. In this article, we'll take a closer look at KMP/CMP and compare its cross-platform development solution with Flutter's approach.

What are KMP and CMP?

The complete cross-platform development solution, the combination of KMP and CMP, lets developers build native Android, iOS, GNU/Linux, Windows, macOS, and Web apps with Kotlin. This Kotlin-based cross-platform app development solution has two primary framework components: KMP and CMP, as described follows:

Kotlin Multiplatform (KMP)

The KMP component helps run Kotlin code on all popular platforms by compiling Kotlin into the platform-specific native machine code format to run Kotlin without a VM. For example, KMP translates Kotlin code into compiled Objective-C frameworks for iOS apps with ARM machine code via LLVM. For the web target, KMP generates WebAssembly code.

KMP isn't a new project — it's a Kotlin compiler feature that makes Kotlin a truly cross-platform, compiled VM-less language, and you can browse its implementation from the Kotlin codebase:

Compose Multiplatform (CMP)

The CMP component helps build native UIs using a pre-developed Kotlin-based UI components set and run UIs on all popular platforms through KMP. A UI component built using CMP components will look and feel the same on all supported platforms since CMP doesn't render built-in platform-specific UI elements as React Native does.

CMP isn't a new project — it's a cross-platform port of the Jetpack Compose UI library, which Google recommends for building native Android apps. CMP makes the Jetpack Compose project cross-platform by rendering UI widgets through Skkio, a project that renders Jetpack Compose widgets on different platforms via Kotlin Skia bindings:

There isn't a single cross-platform framework called Kotlin Compose Multiplatform yet — we have KMP and CMP components to use based on our cross-platform development requirements. KMP alone can create shared Kotlin modules that you can use in native Java/Kotlin Android or Objective-C/Swift projects:

CMP, along with KMP, offers an approach to creating cross-platform apps using 100% Kotlin code, like Flutter lets you build cross-platform apps with Dart:

Similarities with Flutter and other frameworks

Both CMP and Flutter use the same fundamental cross-platform widget-based app development solution to let developers run the same app on different platforms. Both frameworks render widgets on a rendering surface using a cross-platform graphic rendering library.

Here is the summary of similarities between CMP and Flutter:

• Renders cross-platform widgets on a rendering surface, similar to how a computer game draws its UI elements on the screen. CMP renders Jetpack Compose components via Skkio, and Flutter renders Flutter widgets via Skia/Impeller (which generates shaders using platform-specific rendering engine instructions at compile time, unlike Skia)
• Offers a cross-platform, developer-friendly language for development. CMP uses Kotlin, and Flutter uses Dart.
• Compiles cross-platform UI and app logic into platform-specific libraries by generating CPU-specific machine code. KMP turns Kotlin into machine code by generating shared libraries, and Flutter does the same for Dart code
• Expects cross-platform libraries/plugins from the open-source development community. KMP lists available Kotlin community packages via klibs.io and Dart lists packages via pub.dev
• Overall, let developers create cross-platform apps faster using a single language and community libraries. These cross-platform apps are native (not hybrid) since they draw graphics without webviews and run app code without an embedded VM, but don't adhere to platform-specific UI/UX fundamentals well since the widgets don't map to native platform-specific SDK UI elements, unlike React Native

The idea of rendering cross-platform UI by drawing on a canvas wasn't invented by CMP or Flutter — old libraries like SDL offer drawing APIs for creating cross-platform UIs. Moreover, Go Mobile and Kivy projects also use the concept of producing native CPU-specific libraries to include app logic written in a cross-platform language within the app package.

For example, Go Mobile offers the following command to generate native Android libraries from a Go module:

gomobile bind -o lib.aar -target=android go/lib

Why will KMP/CMP become so competitive?

The KMP/CMP solution started its journey using a Flutter-like fundamental architecture, but KMP/CMP shows hints of becoming so competitive with Flutter, with the following points:

• Flutter desktop solely depends on community packages, but CMP desktop lets developers use stable, mature AWT and Swing packages and doesn't require third-party library installation:

• Flutter uses a binary messaging channel implementation called method channels to call native SDKs from Dart, but KMP lets developers directly call native SDKs from Kotlin source code as a Kotlin compiler feature by mapping Kotlin and native function calls, offering better performance
• Flutter innovated a new widget system, so if you decide to turn your Flutter mobile app into a native one, you'll have to rewrite the entire UI. But, a particular CMP app is still a native Android app if you don't wish to use CMP someday, since CMP uses Jetpack Compose, which is the recommended library to build native Android apps
• Turning your native Android app into an iOS app with KMP/CMP resolves to an effective marketing strategy than building a new cross-platform app with Flutter

Why will Flutter still be so popular?

The architecture, UI design approach, developer-productivity, and overall feasibility of the KMP/CMP cross-platform development can compete with Flutter and make CMP a true alternative for Flutter, but the following points make Flutter stronger and more popular:

• Flutter has a more developer-friendly, productive, comprehensive widget system, especially designed for multi-device cross-platform design purposes, compared to Jetpack Compose, which is originally designed for Android devices based on Android-specific UI/UX design considerations
• Flutter is in the process of completely replacing Skia with Impeller, so CMP will have to deal with the same rendering performance issues that the Flutter team faced until they move away from Skkio
• The Dart team is working on implementing a direct native SDK interop with Dart FFI as a high-performance alternative for the current method channel implementation, so Dart Native becomes truly native as KMP in the future:

• KMP and CMP projects are backed by JetBrains, and Google supports the Flutter project. Flutter usage in Google products and the popularity of Google Open Source will become a major reason that motivates most cross-platform app development teams to choose Flutter compared to JetBrains' open-source ecosystem and KMP/CMP usage in their own products

The following story highlights why Flutter became more popular than React Native for building large-scale apps:

Conclusion

KMP/CMP and Flutter both offer a productive cross-platform development solution for developers to build cross-platform apps with a single codebase using a single language and widget system. KMP/CMP and Flutter internally use a similar foundational architecture to achieve cross-platform rendering, and both come with various pros and cons. Notably, KMP/CMP stays ahead of Flutter from native platform-specific SDK/language interop, desktop app development support, and native UI/UX on Android. On the other hand, Flutter stays ahead of KMP/CMP from rendering performance, plugin ecosystem, extensive cross-platform-targeted widgets system, and popularity.

The common canvas-based rendering architecture and native compilation strategy can make KMP/CMP and Flutter exactly the same from the architectural level, and the developer's choice will mostly be based on the framework popularity and the primary language's preference (Dart vs. Kotlin).

Thanks so much for reading.