Perbandingan Native #

Setelah memahami arsitektur Flutter secara mendalam, pertanyaan yang wajar muncul: seberapa dekat Flutter dengan native yang sesungguhnya? Dan kapan sebaiknya memilih Flutter, native murni, atau React Native? Artikel ini menjawab dengan data, bukan opini.

Tiga Pendekatan Mobile Development #

Sebelum membandingkan, penting untuk memahami perbedaan fundamental arsitektur ketiga pendekatan:

NATIVE (Android/iOS):
  Kotlin/Swift --> Kompiler native --> ARM machine code
  UI: Komponen OS langsung (View, UIKit)
  Rendering: GPU via OS graphics stack

FLUTTER:
  Dart (AOT) --> ARM machine code
  UI: Engine sendiri (Impeller/Skia) -- tidak pakai komponen OS
  Rendering: GPU langsung via Metal/Vulkan

REACT NATIVE:
  JavaScript --> JSI (New Architecture) --> Native components
  UI: Komponen OS (melalui bridging)
  Rendering: GPU via OS graphics stack (seperti native)

Perbedaan paling signifikan: Flutter tidak menggunakan komponen UI dari OS sama sekali — ia menggambar semuanya sendiri. Native dan React Native keduanya menggunakan komponen OS, hanya cara mengaksesnya yang berbeda.

Performa: Data Benchmark 2024-2025 #

Startup Time (Cold Start) #

Dalam benchmark 2025 menggunakan aplikasi Flashcard Generator yang identik di ketiga framework, semua berhasil merender frame pertama dalam waktu di bawah 50ms — Flutter yang tercepat, React Native paling konsisten, sementara iOS Native menunjukkan outlier lambat sesekali.

Cold Start (first frame render):

  Flutter         |████████████████████| ~30-45ms  (tercepat rata-rata)
  Android Native  |████████████████████| ~35-50ms  (sangat dekat)
  iOS Native      |████████████████████| ~30-80ms  (kadang outlier)
  React Native    |████████████████████| ~40-55ms  (paling konsisten)

Frame Rate dan Smoothness #

Flutter meninggalkan waktu spare terbanyak di 60Hz dan 120Hz dibanding framework lain. Android Native menjadi runner-up terdekat di platform Android. React Native smooth di kondisi stabil tapi membutuhkan tuning iOS untuk menghindari missed frame dan memory growth.

Frame budget utilization (lower = lebih banyak headroom):

  Flutter        [====----------] ~40% budget terpakai
  Android Native [=====----------] ~45% budget terpakai
  iOS Native     [=====----------] ~45% budget terpakai
  React Native   [=========------] ~65% budget terpakai

Memory Usage #

Native menggunakan memori paling sedikit di kedua platform. Flutter berada di tengah dengan penggunaan yang stabil dan konsisten. React Native menggunakan lebih banyak memori, terutama di iOS.

Memory (kondisi runtime normal):

  Native         [====] ~50-70 MB   (paling efisien)
  Flutter        [======] ~70-90 MB (stabil, tidak banyak bertumbuh)
  React Native   [=========] ~100-130 MB (cenderung bertumbuh)

Ukuran Aplikasi #

Ukuran APK/IPA adalah pertimbangan nyata, terutama untuk pasar dengan koneksi lambat:

Ukuran minimal app "Hello World":

  Native Android  ~1.5 MB   (hanya kode app, tidak ada runtime)
  Native iOS      ~2.0 MB   (hanya kode app)
  Flutter Android ~7-10 MB  (+ Flutter engine ~4MB)
  Flutter iOS     ~15-20 MB (+ Flutter engine)
  React Native    ~20-30 MB (Hermes engine + JS bundle)

Flutter lebih besar dari native karena menyertakan engine-nya sendiri. Namun selisih ini menjadi relatif kecil seiring aplikasi tumbuh — untuk aplikasi berukuran sedang (10+ MB), overhead engine Flutter tidak lagi signifikan secara proporsi.

Optimasi ukuran Flutter: Flutter mendukung beberapa teknik untuk mengurangi ukuran build: flutter build apk --split-per-abi memisahkan APK per arsitektur CPU (arm64, x86_64), sehingga pengguna hanya mengunduh versi yang relevan untuk perangkat mereka.

Konsistensi UI Antar Platform #

Ini adalah area di mana Flutter dan native memiliki filosofi yang berlawanan:

FLUTTER — "Pixel-perfect consistency":
  Android  ──┐
  iOS      ──┼──> UI IDENTIK di semua platform
  Web      ──┤    (dirender oleh Flutter sendiri)
  Desktop  ──┘

NATIVE — "Platform-appropriate":
  Android  ──> UI mengikuti Material Design
  iOS      ──> UI mengikuti Human Interface Guidelines
  (tampilan berbeda di setiap platform -- by design)

REACT NATIVE — "Platform-native feel":
  Android  ──> komponen OS Android
  iOS      ──> komponen OS iOS
  (berusaha native, tapi sering ada inkonsistensi kecil)

Mana yang lebih baik? Tergantung tujuan:

Akses ke Fitur Platform #

Ini adalah area di mana native masih memiliki keunggulan yang nyata:

Akses API platform:

  NATIVE:
    Kamera, GPS, Bluetooth, NFC  ──> Langsung, hari pertama
    Fitur OS baru (beta)         ──> Langsung tersedia
    Deep system integration      ──> Penuh tanpa batas

  FLUTTER:
    Fitur umum (kamera, GPS)     ──> Plugin tersedia, matang
    Fitur baru platform          ──> Tunggu plugin ~1-6 bulan
    Custom hardware              ──> Bisa, tapi butuh Platform Channel

  REACT NATIVE:
    Fitur umum                   ──> Library JS tersedia
    Fitur baru                   ──> Tergantung komunitas
    Native modules               ──> Bisa, lewat JSI (New Architecture)

Native development menawarkan native integration dan early access ke platform-specific functionality jika aplikasi sangat bergantung pada native API seperti kamera, GPS, Bluetooth, biometrik, atau sensor. Flutter memberikan akses ke fitur perangkat melalui plugin yang ekosistemnya terus berkembang, namun untuk fitur baru atau sangat khusus, mungkin ada jeda atau perlu menulis custom platform-specific code.

Developer Experience #

Kecepatan Iterasi #

Waktu dari "ubah kode" hingga "lihat hasilnya":

  Flutter (Hot Reload)  < 1 detik   -- injeksi perubahan langsung
  React Native (Fast Refresh) ~1-3 detik -- refresh component
  Android native (Instant Run) ~5-30 detik -- partial rebuild
  iOS native            ~10-60 detik -- selalu full rebuild

Hot Reload Flutter adalah keunggulan developer experience yang nyata dan terasa setiap hari.

Tooling #

Kurva Belajar #

Estimasi waktu hingga produktif untuk developer berpengalaman:

  Flutter/Dart     2-4 minggu  (Dart familiar, widget system perlu adaptasi)
  React Native     1-2 minggu  (jika sudah React/JS, sangat cepat)
  Android Native   1-3 bulan   (Kotlin + Android SDK + Jetpack)
  iOS Native       1-3 bulan   (Swift + UIKit/SwiftUI + Apple guidelines)
  Keduanya native  6-12 bulan  (untuk benar-benar mahir di dua platform)

Biaya Pengembangan: Perbandingan Realistis #

Native app lebih mahal, lebih sulit dikembangkan, dan membutuhkan waktu lebih lama. Biasanya membutuhkan tim yang lebih besar, biaya rata-rata dua kali lebih tinggi, dan jauh lebih lambat ke market. Biaya maintenance juga dua kali lipat dibanding cross-platform.

Proyek skala menengah (estimasi kasar):

  NATIVE (Android + iOS):
    Tim: 3 Android dev + 3 iOS dev + 1 QA each = ~8 orang
    Timeline: 12-18 bulan
    Biaya relatif: 2x

  FLUTTER:
    Tim: 3-4 Flutter dev + 1 QA = ~5 orang
    Timeline: 8-12 bulan
    Biaya relatif: 1x

  REACT NATIVE:
    Tim: 3-4 RN dev + 1 QA = ~5 orang
    Timeline: 8-14 bulan
    Biaya relatif: ~1.2x (sering butuh native module tambahan)

React Native New Architecture vs Flutter #

React Native telah melakukan redesign arsitektur besar yang disebut New Architecture (default di RN 0.74+). Ini signifikan karena menghilangkan JavaScript Bridge lama:

React Native (Old Architecture):
  JS Code <--Bridge--> Native Modules
  Async, serialisasi JSON, bottleneck

React Native (New Architecture / JSI):
  JS Code <--JSI--> Native Modules
  Sync calls tersedia, lebih cepat, tanpa serialisasi JSON

React Native New Architecture (Bridgeless Architecture, default di versi 0.74) menghilangkan JavaScript bridge dan memanfaatkan JavaScript Interface (JSI) untuk komunikasi lebih cepat antara JavaScript dan layer native. Improvement ini meningkatkan responsivitas app dan mengurangi latency, membuat React Native lebih kompetitif dalam benchmark performa.

Namun Flutter tetap memiliki keunggulan fundamental karena tidak ada layer JavaScript sama sekali:

Flutter: Dart (AOT) --> ARM machine code --> GPU
         Tidak ada scripting runtime, tidak ada bridge

React Native: JS (Hermes JIT) --> JSI --> Native --> GPU
              Ada runtime overhead meski New Architecture lebih baik

Matriks Keputusan: Kapan Memilih Apa? #

Berdasarkan semua data di atas, ini panduan keputusan yang realistis:

Pilih Flutter jika: #

• Butuh UI yang konsisten dan identik di Android dan iOS
• Aplikasi memiliki animasi kompleks atau grafis intensif
• Tim ingin satu codebase untuk mobile, web, dan desktop
• Butuh performa tinggi tanpa overhead scripting runtime
• Startup yang ingin cepat ke market dengan kualitas tinggi
• Budget terbatas tapi tidak mau mengorbankan UX

Pilih Native jika: #

• Aplikasi sangat bergantung pada fitur hardware spesifik yang baru
• Butuh akses beta API platform hari pertama rilis
• UI harus mengikuti konvensi platform secara ketat (misal: banking, OS system app)
• Tim sudah expert di native dan tidak ada urgensi cross-platform
• Performa absolut adalah prioritas nomor satu (game engine, AR/VR)

Pilih React Native jika: #

• Tim sudah sangat familiar dengan React dan JavaScript
• Ingin berbagi logic dengan aplikasi web yang sudah ada (React)
• Butuh tampilan yang terasa “native” di masing-masing platform
• Ekosistem npm yang besar adalah kebutuhan utama
• Migrasi bertahap dari web ke mobile

Untuk mayoritas aplikasi bisnis modern — fintech, e-commerce, healthcare, productivity, social — Flutter adalah pilihan paling efisien yang tidak mengorbankan kualitas. Native hanya sepadan untuk kasus-kasus di mana kebutuhan platform-specific sangat dominan.

Ringkasan #

• Flutter merender UI-nya sendiri tanpa menggunakan komponen OS — berbeda dengan native dan React Native yang keduanya menggunakan komponen platform.
• Dalam benchmark 2025, Flutter memimpin dalam smoothness dan startup time, native paling efisien dalam memory, React Native paling konsisten dalam cold start.
• Ukuran app Flutter lebih besar dari native (~4MB overhead engine) tapi lebih kecil dari React Native — selisih menjadi tidak signifikan seiring app berkembang.
• Hot Reload Flutter memberikan keunggulan developer experience yang nyata: perubahan terlihat dalam < 1 detik vs 10-60 detik di native iOS.
• React Native New Architecture (JSI) menutup gap performa dengan Flutter, tapi Flutter tetap unggul karena tidak ada layer JavaScript runtime sama sekali.
• Pilih Flutter untuk produktivitas tim, konsistensi UI, dan performa animasi. Pilih native untuk integrasi platform yang sangat dalam. Pilih React Native jika tim sudah kuat di JavaScript/React.

← Sebelumnya: Skia & Impeller   Berikutnya: Dart Overview →