Cross-platform development in mobile applications: what it is, which frameworks and how it works

Cross-platform development: Flutter Platform Channel and Method Channel

Flutter is Google's framework for creating native applications from a single Dart codebase. To interact with platform code (Kotlin, Swift), Flutter uses Platform Channel. It is a bridge through which Dart code calls native functions and gets the result. Cross-platform mobile app development with Flutter is the fastest growing segment of mobile development in 2025–2026.

Platform Channel (Method Channel)

Method Channel is the main Flutter <-> Native communication channel. On the Dart side: MethodChannel('com.example/channel').invokeMethod('getBatteryLevel'). The message is encoded in StandardMethodCodec (binary). On the native side, a MethodChannel is registered and handles the call. MethodChannel is asynchronous — the result is returned via Future. Alternative: EventChannel for event streams.

BasicMessageChannel is a lower-level channel for sending strings/bytes without a "method-args" structure. Used for custom protocols. All Platform Channel API goes through Flutter Engine, which serializes/deserializes messages.

FFI, Skia and Impeller

dart:ffi (Foreign Function Interface) — direct call of C functions from Dart without platform channels. FFI is faster than Method Channel (0 serialization overhead). Used for performance-intensive operations: audio processing, cryptography, graphics engines. Skia is Flutter's render engine (2D graphics). Impeller is Flutter's new render engine replacing Skia. Impeller compiles shaders ahead-of-time, eliminating jank (frame stuttering) on first launches. At IT Sectr we switched to Impeller in 2025 — the difference in animation smoothness is immediately noticeable.

Cross-platform development with React Native: Bridge, Fabric, Hermes, JSI

React Native is Meta's framework for cross-platform mobile app development in JavaScript/TypeScript. React Native renders components into native UI elements. The architecture has evolved: old Bridge → new Fabric with JSI.

Fabric vs Bridge

Bridge is the old React Native architecture. The JS thread serializes messages to JSON and sends them through an async queue to the native thread. This creates delays (bridge round-trip ~1 ms). Fabric is the new architecture where JS and native UI threads communicate synchronously through JSI (JavaScript Interface). Fabric injects native views directly, without a bridge. Fabric is a key milestone in cross-platform development, accelerating rendering up to 2x.

JSI (JavaScript Interface) is a C++ API that allows JavaScript to directly call native functions and share memory. JSI replaced Bridge's JSON serialization. The new JSI-based architecture is a crucial achievement in cross-platform development, defining mobile app performance. Turbo Module is a new way of writing native modules for React Native. Unlike old Native Modules, Turbo Module is loaded lazily and uses JSI.

Hermes and Codegen

Hermes is a JavaScript engine from Meta, optimized for React Native. Hermes compiles JS code to bytecode at build time, speeding up mobile app startup and reducing memory consumption in cross-platform development. Codegen is a native code generator based on TypeScript types. Codegen automatically creates native modules and JSI bindings, reducing manual work.

Flutter renders everything itself via Skia/Impeller — this gives a unified UI on both platforms. React Native uses native UI components — it looks like a native app. KMP does not handle UI — it only shares business logic, UI remains native. The choice depends on the priority: unified UI (Flutter) or maximum nativity (React Native/KMP).

Cross-platform development with Kotlin Multiplatform: expect/actual, Kotlin/Native

Kotlin Multiplatform (KMP) is JetBrains technology for shared code between Android and iOS. Unlike Flutter and React Native, KMP is an alternative approach to cross-platform development: it does not replace UI, but shares business logic, network requests, data models and repositories. UI remains native: Jetpack Compose for Android, SwiftUI for iOS.

expect/actual

expect — declaration of a function or class in the common module (commonMain) that has a platform implementation. Cross-platform development with KMP uses expect/actual: actual is the concrete implementation for each platform (androidMain, iosMain). Example: expect fun getDeviceId(): String — actual on Android uses Settings.Secure, on iOS — UIDevice.current.identifierForVendor.

Kotlin/Native

Kotlin/Native — a Kotlin compiler into a native binary (iOS framework). It allows running Kotlin code on iOS without JVM. Kotlin/Native uses LLVM for compilation, providing performance close to Swift. Kotlin/JS — compilation of Kotlin to JavaScript for web and React Native projects.

Build tools: Gradle KTS, CocoaPods Plugin, XCFramework

Build tools of cross-platform mobile app development — the bridge between code and final binary. Gradle KTS manages the Android part, CocoaPods Plugin manages KMP iOS dependencies, XCFramework manages native library distribution.

Gradle KTS

Gradle KTS — Gradle configuration using Kotlin DSL instead of Groovy. KTS supports autocomplete in Android Studio, type checking and refactoring safety. Example: plugins { id("com.android.application") } instead of apply plugin: 'com.android.application'. Recommended for all new projects.

CocoaPods Plugin and XCFramework

CocoaPods Plugin — a Gradle plugin for KMP that publishes the shared module as a CocoaPods pod. An iOS developer adds it via Podfile. XCFramework — Apple's binary library distribution format. XCFramework contains binaries for multiple architectures (arm64, x86_64) and platforms (iOS, macOS, watchOS). In KMP the shared module is exported as XCFramework for iOS.