Cross-Platform App: cos'è, confronto tra Flutter, React Native e KMP

Cos'è una Cross-Platform App?

Cross-Platform App (applicazione multipiattaforma) è un software sviluppato per funzionare su più sistemi operativi mobili da un'unica base di codice. A differenza dello sviluppo nativo, dove vengono mantenuti due progetti separati per iOS (Swift) e Android (Kotlin), lo sviluppo multipiattaforma combina logica di business, interfaccia utente e livello dati in un unico progetto.

Il concetto di sviluppo multipiattaforma è emerso nel 2009 con PhoneGap (poi Apache Cordova), che impacchettava un'applicazione web in un WebView nativo. I framework moderni hanno fatto molta strada: Flutter compila in codice ARM nativo tramite Dart, React Native utilizza un motore JavaScript con ponte nativo, e Kotlin Multiplatform compila il codice condiviso in binari specifici della piattaforma. Entro il 2026, oltre il 40% delle nuove app mobili utilizza almeno una tecnologia multipiattaforma.

Metriche chiave di adozione: time-to-market più veloce del 30–50%, riduzione dei costi del 30–40% rispetto a due team nativi, supporto di un set di funzionalità unificato su entrambe le piattaforme. Tuttavia, le app multipiattaforma devono ancora affrontare sfide — sfumature UI specifiche della piattaforma, accesso alle API hardware e funzionalità critiche per le prestazioni come animazioni e giochi.

Flutter: Architettura e Prestazioni

Flutter è un framework UI open-source di Google con linguaggio Dart e motore di rendering proprietario Skia (Impeller nella versione 4.x). A differenza dei framework che utilizzano componenti nativi della piattaforma, Flutter renderizza ogni pixel da sé, dando il controllo completo sull'interfaccia. Questo approccio elimina le differenze tra piattaforme ma aumenta la dimensione dell'app di 5–15 MB.

// Flutter — contatore semplice
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('Contatore multipiattaforma')),
      body: Center(
        child: Column(
          children: [
            const Text('Hai premuto il bottone questo numero di volte:'),
            Text('$_count',
              style: const TextStyle(fontSize: 48)),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () { setState(() { _count++; }); },
        child: const Icon(Icons.add),
      ),
    );
  }
}

Al centro di Flutter c'è un'architettura a widget: tutto — dal padding e allineamento ai vincoli di layout — è un widget. Questo modello dichiarativo, ereditato da React, rende l'UI prevedibile. Grazie alla compilazione AOT di Dart, le app Flutter si avviano in meno di 2 secondi e mantengono 60 FPS anche su dispositivi di fascia media. Impeller, il nuovo motore di rendering, ha eliminato i rallentamenti durante la compilazione degli shader, che era il problema principale di Skia.

React Native: Ponte JavaScript ed Ecosistema

React Native è un framework multipiattaforma di Meta per creare app mobili con JavaScript/TypeScript e React. A differenza di Flutter, React Native utilizza i componenti UI nativi della piattaforma (UIView su iOS, View su Android) tramite un ponte JavaScript. La logica di business viene eseguita in un motore JavaScript (Hermes o JSC), interagendo in modo asincrono con i moduli nativi.

// React Native — componente con codice piattaforma
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: 'Ciao da iOS',
    android: 'Ciao da Android',
    default: 'Ciao',
  });

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

Il più grande vantaggio di React Native è il suo ecosistema. npm ospita oltre 2 milioni di pacchetti e librerie come React Navigation, Expo e Reanimated offrono soluzioni pronte per navigazione, gesture e animazioni. Expo, un flusso di lavoro gestito, semplifica la compilazione e la pubblicazione con aggiornamenti OTA e oltre 50 moduli nativi integrati. Instagram, Shopify e Discord funzionano su React Native con un pubblico combinato di oltre 500 milioni di utenti mensili.

Kotlin Multiplatform: Logica Condivisa con UI Nativa

Kotlin Multiplatform (KMP) è una tecnologia JetBrains che compila il codice Kotlin condiviso in binari specifici della piattaforma. A differenza di Flutter e React Native, KMP non fornisce un framework UI — il suo scopo è riutilizzare la logica di business, il livello dati, le richieste di rete e la convalida, mantenendo l'interfaccia completamente nativa. Netflix, McDonald's e VMware utilizzano KMP in produzione.

// Kotlin Multiplatform — repository condiviso 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 — formattazione data per la piattaforma
expect fun formatDate(timestamp: Long): String

Il pattern chiave di KMP è il meccanismo expect/actual. Nel modulo condiviso (commonMain) viene dichiarata una funzione o classe expect, e in ogni set di sorgenti specifico della piattaforma (androidMain, iosMain) viene fornita l'implementazione actual. Ciò consente di utilizzare le API native — SharedPreferences, NSUserDefaults, fotocamera, biometria — mantenendo un'interfaccia pubblica unificata nel codice condiviso. Compose Multiplatform, il livello UI per KMP, ha raggiunto la stabilità per Android e Desktop nel 2025, con la versione iOS ancora in beta.

Confronto dei Framework Multipiattaforma

Prestazioni variano significativamente a seconda dello scenario. Il rendering proprietario di Flutter garantisce 60 FPS stabili per animazioni e transizioni. L'architettura a ponte di React Native aggiunge 2–5 ms di latenza per ogni chiamata nativa, sebbene il nuovo layer JSI (JavaScript Interface) riduca questo divario. KMP ha overhead zero per il codice condiviso poiché compila direttamente in binari di piattaforma. Per le app ad alta intensità di UI con animazioni complesse, la scelta è tra Flutter e lo sviluppo nativo.

Come Scegliere il Framework Giusto

La scelta tra Flutter, React Native e KMP dipende dalle priorità del progetto. Se hai bisogno di un UI pixel-perfect e del controllo completo delle animazioni — Flutter offre l'esperienza multipiattaforma più coerente. Se il team conosce JavaScript/React e apprezza il più vasto ecosistema di librerie di terze parti — React Native è la scelta pragmatica. Se le app native esistono già e devi condividere la logica di business — KMP consente di introdurre codice condiviso modulo per modulo senza compromettere l'UI.

Per MVP e startup, Flutter o React Native offrono il percorso più breve verso il mercato con l'80–100% di codice condiviso. Per applicazioni enterprise con una base nativa esistente, KMP consente una migrazione graduale dei moduli. Giochi e applicazioni multimediali con rendering personalizzato beneficiano di Flutter o di un approccio completamente nativo. Ogni framework ha dimostrato la sua maturità — Instagram (React Native), Google Pay (Flutter) e Netflix (KMP) funzionano su tecnologie multipiattaforma.

Tendenze: Flutter si espande su desktop e web con una base di codice unificata. React Native con la sua nuova architettura (Fabric + TurboModules) elimina completamente il ponte. KMP con Compose Multiplatform punta a un livello UI unificato mantenendo le prestazioni native. Entro il 2027, il confine tra sviluppo multipiattaforma e nativo sarà completamente sfumato — i framework stanno migrando verso percorsi di compilazione nativi.