Cross-Platform App : qu'est-ce que c'est, comparaison de Flutter, React Native et KMP

Qu'est-ce qu'une Cross-Platform App ?

Cross-Platform App (application multiplateforme) est un logiciel développé pour fonctionner sur plusieurs systèmes d'exploitation mobiles à partir d'une seule base de code. Contrairement au développement natif, où deux projets distincts sont maintenus pour iOS (Swift) et Android (Kotlin), le développement multiplateforme combine la logique métier, l'interface utilisateur et la couche de données dans un seul projet.

Le concept de développement multiplateforme est apparu en 2009 avec PhoneGap (plus tard Apache Cordova), qui encapsulait une application web dans un WebView natif. Les frameworks modernes ont fait beaucoup de chemin : Flutter compile en code ARM natif via Dart, React Native utilise un moteur JavaScript avec pont natif, et Kotlin Multiplatform compile le code partagé en binaires spécifiques à la plateforme. D'ici 2026, plus de 40 % des nouvelles applications mobiles utilisent au moins une technologie multiplateforme.

Indicateurs clés d'adoption : mise sur le marché 30 à 50 % plus rapide, réduction des coûts de 30 à 40 % par rapport à deux équipes natives, prise en charge d'un ensemble unifié de fonctionnalités sur les deux plateformes. Cependant, les applications multiplateformes sont encore confrontées à des défis — les nuances d'UI spécifiques à la plateforme, l'accès aux API matérielles et les fonctionnalités critiques en termes de performances comme les animations et les jeux.

Flutter : Architecture et Performances

Flutter est un framework UI open-source de Google avec le langage Dart et son propre moteur de rendu Skia (Impeller dans la version 4.x). Contrairement aux frameworks qui utilisent des composants natifs de la plateforme, Flutter rend lui-même chaque pixel, donnant un contrôle total sur l'interface. Cette approche élimine les différences entre plateformes mais augmente la taille de l'application de 5 à 15 Mo.

// Flutter — compteur simple
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('Compteur multiplateforme')),
      body: Center(
        child: Column(
          children: [
            const Text('Vous avez appuyé sur le bouton ce nombre de fois :'),
            Text('$_count',
              style: const TextStyle(fontSize: 48)),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () { setState(() { _count++; }); },
        child: const Icon(Icons.add),
      ),
    );
  }
}

Au cœur de Flutter se trouve une architecture de widgets : tout — du padding et de l'alignement aux contraintes de mise en page — est un widget. Ce modèle déclaratif, hérité de React, rend l'UI prévisible. Grâce à la compilation AOT de Dart, les applications Flutter démarrent en moins de 2 secondes et maintiennent 60 FPS même sur les appareils de milieu de gamme. Impeller, le nouveau moteur de rendu, a éliminé les saccades lors de la compilation des shaders, qui étaient le principal problème de Skia.

React Native : Pont JavaScript et Écosystème

React Native est un framework multiplateforme de Meta pour créer des applications mobiles avec JavaScript/TypeScript et React. Contrairement à Flutter, React Native utilise les composants d'UI natifs de la plateforme (UIView sur iOS, View sur Android) via un pont JavaScript. La logique métier s'exécute dans un moteur JavaScript (Hermes ou JSC), interagissant de manière asynchrone avec les modules natifs.

// React Native — composant avec code plateforme
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: 'Bonjour d'iOS',
    android: 'Bonjour d'Android',
    default: 'Bonjour',
  });

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

Le plus grand avantage de React Native est son écosystème. npm héberge plus de 2 millions de packages, et des bibliothèques comme React Navigation, Expo et Reanimated fournissent des solutions prêtes à l'emploi pour la navigation, les gestes et les animations. Expo, un flux de travail géré, simplifie la compilation et la publication avec des mises à jour OTA et plus de 50 modules natifs intégrés. Instagram, Shopify et Discord fonctionnent sur React Native avec une audience combinée de plus de 500 millions d'utilisateurs mensuels.

Kotlin Multiplatform : Logique Partagée avec UI Native

Kotlin Multiplatform (KMP) est une technologie de JetBrains qui compile le code Kotlin partagé en binaires spécifiques à la plateforme. Contrairement à Flutter et React Native, KMP ne fournit pas de framework d'UI — son objectif est de réutiliser la logique métier, la couche de données, les requêtes réseau et la validation, tout en gardant l'interface entièrement native. Netflix, McDonald's et VMware utilisent KMP en production.

// Kotlin Multiplatform — dépôt partagé dans 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 — formatage de date pour la plateforme
expect fun formatDate(timestamp: Long): String

Le modèle clé de KMP est le mécanisme expect/actual. Dans le module partagé (commonMain), une fonction ou classe expect est déclarée, et dans chaque ensemble de sources spécifique à la plateforme (androidMain, iosMain), l'implémentation actual est fournie. Cela permet d'utiliser les API natives — SharedPreferences, NSUserDefaults, caméra, biométrie — tout en conservant une interface publique unifiée dans le code partagé. Compose Multiplatform, la couche d'UI pour KMP, a atteint la stabilité pour Android et Desktop en 2025, la version iOS étant encore en version bêta.

Comparaison des Frameworks Multiplateformes

Performances varient considérablement selon le scénario. Le rendu propre de Flutter garantit 60 FPS stables pour les animations et les transitions. L'architecture de pont de React Native ajoute 2 à 5 ms de latence par appel natif, bien que la nouvelle couche JSI (JavaScript Interface) réduise cet écart. KMP n'a aucun surcoût pour le code partagé car il compile directement en binaires de la plateforme. Pour les applications à UI intensive avec des animations complexes, le choix se situe entre Flutter et le développement natif.

Comment Choisir le Framework Adapté

Le choix entre Flutter, React Native et KMP dépend des priorités du projet. Si vous avez besoin d'une UI pixel-parfaite et d'un contrôle total des animations — Flutter offre l'expérience multiplateforme la plus cohérente. Si l'équipe maîtrise JavaScript/React et valorise le plus vaste écosystème de bibliothèques tierces — React Native est le choix pragmatique. Si des applications natives existent déjà et que vous devez partager la logique métier — KMP permet d'introduire du code partagé module par module sans compromettre l'UI.

Pour les MVP et startups, Flutter ou React Native offrent le chemin le plus court vers le marché avec 80 à 100 % de code partagé. Pour les applications d'entreprise avec une base native existante, KMP permet une migration progressive des modules. Les jeux et applications multimédia avec rendu personnalisé bénéficient de Flutter ou d'une approche entièrement native. Chaque framework a prouvé sa maturité — Instagram (React Native), Google Pay (Flutter) et Netflix (KMP) fonctionnent sur des technologies multiplateformes.

Tendances : Flutter s'étend au bureau et au web avec une base de code unifiée. React Native avec sa nouvelle architecture (Fabric + TurboModules) élimine complètement le pont. KMP avec Compose Multiplatform vise une couche d'UI unifiée tout en maintenant les performances natives. D'ici 2027, la frontière entre le développement multiplateforme et natif sera complètement floutée — les frameworks migrent vers des chemins de compilation natifs.