Cross-Platform App: What It Is, Comparing Flutter, React Native and KMP

What is a Cross-Platform App?

Cross-Platform App (cross-platform application) is software developed to run on multiple mobile operating systems from a single codebase. Unlike native development, where two separate projects are maintained for iOS (Swift) and Android (Kotlin), cross-platform development combines business logic, user interface and data layer in one project.

The concept of cross-platform development emerged in 2009 with PhoneGap (later Apache Cordova), which packaged a web application into a native WebView. Modern frameworks have come a long way: Flutter compiles to native ARM code via Dart, React Native uses a JavaScript engine with a native bridge, and Kotlin Multiplatform compiles shared code into platform-specific binaries. By 2026, over 40% of new mobile apps use at least one cross-platform technology.

Key metrics of adoption: 30–50% faster time to market, 30–40% cost reduction compared to two native teams, support for a unified feature set on both platforms. However, cross-platform apps still face challenges — platform-specific UI nuances, hardware API access, and performance-critical functionality such as animations and games.

Flutter: Architecture and Performance

Flutter is an open-source UI framework from Google using the Dart language with its own Skia rendering engine (Impeller in version 4.x). Unlike frameworks that use native platform components, Flutter renders every pixel itself, giving full control over the interface. This approach eliminates platform differences but increases app size by 5–15 MB.

// Flutter — simple counter
import 'package:flutter/material.dart';

void main() { runApp(const CounterApp()); }

class CounterApp extends StatelessWidget {
  const CounterApp({super.key});

  Widget build(BuildContext context) {
    return const MaterialApp(home: CounterScreen());
  }
}

class CounterScreen extends StatefulWidget {
  /* ... */
}

class _CounterScreenState extends State<CounterScreen> {
  int _count = 0;

  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Cross-platform counter')),
      body: Center(
        child: Column(
          children: [
            const Text('You have pressed the button this many times:'),
            Text('$_count',
              style: const TextStyle(fontSize: 48)),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () { setState(() { _count++; }); },
        child: const Icon(Icons.add),
      ),
    );
  }
}

At the core of Flutter lies a widget architecture: everything — from padding and alignment to layout constraints — is a widget. This declarative model, inherited from React, makes the UI predictable. Thanks to Dart's AOT compilation, Flutter apps start in under 2 seconds and maintain 60 FPS even on mid-range devices. Impeller, the new rendering engine, eliminated the jitter during shader compilation that was Skia's main issue.

React Native: JavaScript Bridge and Ecosystem

React Native is a cross-platform framework from Meta for building mobile apps with JavaScript/TypeScript and React. Unlike Flutter, React Native uses native UI components of the platform (UIView on iOS, View on Android) through a JavaScript bridge. Business logic runs in a JavaScript engine (Hermes or JSC), asynchronously interacting with native modules.

// React Native — component with platform-specific code
import React, { useState } from 'react';
import {
  View, Text, TouchableOpacity, Platform
} from 'react-native';

const App = () => {
  const [count, setCount] = useState(0);

  const greeting = Platform.select({
    ios: 'Hello from iOS',
    android: 'Hello from Android',
    default: 'Hello',
  });

  return (
    <View>
      <Text>{greeting}</Text>
      <Text>{count}</Text>
      <TouchableOpacity
        onPress={() => setCount(c => c + 1)}>
        <Text>+1</Text>
      </TouchableOpacity>
    </View>
  );
};

React Native's biggest advantage is its ecosystem. npm hosts over 2 million packages, and libraries like React Navigation, Expo and Reanimated provide ready-made solutions for navigation, gestures and animations. Expo, a managed workflow, simplifies building and publishing with OTA updates and 50+ built-in native modules. Instagram, Shopify and Discord run on React Native with a combined audience of over 500 million monthly users.

Kotlin Multiplatform: Shared Logic with Native UI

Kotlin Multiplatform (KMP) is a JetBrains technology that compiles shared Kotlin code into platform-specific binaries. Unlike Flutter and React Native, KMP does not provide a UI framework — its purpose is to reuse business logic, data layer, network requests and validation, while keeping the interface fully native. Netflix, McDonald's and VMware use KMP in production.

// Kotlin Multiplatform — shared repository in commonMain
class UserRepository(
    private val api: KtorClient,
    private val db: Database
) {
    suspend fun getUsers(): Result<List<User>> {
        return try {
            val users = api.fetch<List<UserDto>>("/users")
            db.save(users.map { it.toDomain() })
            Result.success(db.getAll())
        } catch (e: Exception) {
            Result.failure(e)
        }
    }
}

// expect/actual — date formatting for the platform
expect fun formatDate(timestamp: Long): String

The key pattern of KMP is the expect/actual mechanism. In the shared module (commonMain), an expect function or class is declared, and in each platform-specific source set (androidMain, iosMain) the actual implementation is provided. This allows using platform APIs — SharedPreferences, NSUserDefaults, camera, biometrics — while maintaining a unified public interface in the shared code. Compose Multiplatform, the UI layer for KMP, reached stability for Android and Desktop in 2025, with the iOS version still in beta testing.

Comparison of Cross-Platform Frameworks

Performance varies significantly depending on the scenario. Flutter's custom rendering ensures stable 60 FPS for animations and transitions. React Native's bridge architecture adds 2–5 ms latency per native call, although the new JSI (JavaScript Interface) layer reduces this gap. KMP has zero overhead for shared code since it compiles directly into platform binaries. For UI-intensive apps with complex animations, the choice is between Flutter and native development.

How to Choose the Right Framework

The choice between Flutter, React Native and KMP depends on project priorities. If you need pixel-perfect UI and full animation control — Flutter provides the most consistent cross-platform experience. If the team knows JavaScript/React and values the largest third-party library ecosystem — React Native is the pragmatic choice. If native apps already exist and you need to share business logic — KMP allows introducing shared code module by module without UI compromises.

For MVPs and startups, Flutter or React Native offer the shortest path to market with 80–100% shared code. For enterprise applications with an existing native base, KMP allows gradual module migration. Games and media applications with custom rendering benefit from Flutter or a fully native approach. Each framework has proven its maturity — Instagram (React Native), Google Pay (Flutter) and Netflix (KMP) run on cross-platform technologies.

Trends: Flutter is expanding to desktop and web with a unified codebase. React Native with its new architecture (Fabric + TurboModules) completely eliminates the bridge. KMP with Compose Multiplatform aims for a unified UI layer while maintaining native performance. By 2027, the boundary between cross-platform and native development will be fully blurred — frameworks are transitioning to platform compilation paths.