AOT vs JIT #

Salah satu alasan Flutter bisa memberikan developer experience yang luar biasa sekaligus performa produksi yang tinggi adalah karena Dart mendukung dua strategi kompilasi yang berbeda: JIT (Just-In-Time) dan AOT (Ahead-Of-Time). Flutter menggunakan keduanya — di waktu yang tepat, untuk tujuan yang tepat.

Apa itu Kompilasi? #

Sebelum membahas JIT dan AOT, kita perlu memahami apa itu kompilasi. Kode yang kamu tulis dalam Dart adalah bahasa tingkat tinggi yang mudah dibaca manusia. Komputer tidak memahami Dart secara langsung — ia hanya mengerti machine code (kode mesin), yaitu instruksi biner yang spesifik untuk setiap arsitektur prosesor.

Kompiler adalah program yang menerjemahkan kode Dart menjadi machine code. Pertanyaannya adalah: kapan penerjemahan itu terjadi?

Kode Dart (kamu tulis)
        |
        v
   [ Kompiler ]
        |
        v
  Machine Code (dijalankan CPU)

Di sinilah JIT dan AOT berbeda secara fundamental.

JIT — Just-In-Time Compilation #

JIT menerjemahkan kode menjadi machine code pada saat program sedang berjalan — bukan sebelumnya. Penerjemahan terjadi “tepat waktu” saat kode dibutuhkan.

Cara Kerja JIT #

Source Code Dart
       |
       v
  Dart VM (Virtual Machine)
       |
       v
  JIT Compiler <-- mengamati kode yang sering dijalankan
       |
       v
  Machine Code (dihasilkan saat runtime)
       |
       v
  Dieksekusi CPU

Saat kamu menjalankan aplikasi Flutter dalam mode debug, Dart VM menerima kode Dart dan mengkompilasinya secara bertahap. JIT juga mengamati hotspot — bagian kode yang paling sering dieksekusi — lalu mengoptimalkannya secara dinamis.

Keunggulan JIT #

Hot Reload memungkinkan: Karena kode dikompilasi saat runtime, JIT bisa menyuntikkan perubahan kode langsung ke aplikasi yang sedang berjalan tanpa perlu build ulang dari awal. Inilah fondasi teknis dari fitur Hot Reload Flutter.

Iterasi super cepat: Ubah warna, perbaiki layout, tambah widget — simpan file, dan perubahan langsung terlihat dalam hitungan milidetik.

Debugging yang kaya: JIT mempertahankan informasi debug (nama variabel, stack trace, breakpoint) yang sangat berguna saat mengidentifikasi bug.

Kelemahan JIT #

Startup lebih lambat — kompilasi terjadi saat app dijalankan, sehingga ada overhead di awal
Performa tidak konsisten — kode dioptimalkan secara bertahap, bukan sekaligus
Ukuran lebih besar — Dart VM dan JIT compiler ikut dibundel ke dalam app

Analogi JIT
Bayangkan kamu sedang rapat dan ada penerjemah yang menerjemahkan ucapan pembicara secara real-time, kalimat per kalimat, sambil belajar pola bicara pembicara agar makin lama makin cepat menerjemahkan.

AOT — Ahead-Of-Time Compilation #

AOT menerjemahkan seluruh kode Dart menjadi machine code sebelum aplikasi dijalankan — yaitu pada saat proses build. Ketika pengguna membuka aplikasimu, kode sudah dalam bentuk machine code yang siap dieksekusi langsung.

Cara Kerja AOT #

Source Code Dart
       |
       v
  AOT Compiler (saat flutter build)
       |   |-- Type Flow Analysis (TFA)
       |   |-- Dead Code Elimination
       |   |-- Inlining & Optimization
       v
  Native Machine Code (.so / .dylib)
       |
       v
  Dieksekusi CPU langsung (tanpa VM overhead)

AOT compiler melakukan analisis menyeluruh terhadap seluruh kode — termasuk Type Flow Analysis (TFA) untuk menentukan kode mana yang benar-benar digunakan, lalu membuang kode yang tidak terpakai (dead code elimination).

Keunggulan AOT #

Startup sangat cepat: Tidak ada overhead kompilasi saat app dibuka. Machine code langsung dieksekusi.

Performa konsisten: Karena semua optimasi sudah dilakukan saat build, tidak ada variasi performa saat runtime.

Ukuran lebih efisien: Dart VM dan JIT compiler tidak perlu ikut dibundel. Dead code juga dihapus secara otomatis.

Lebih aman: Banyak error bisa ditangkap saat compile time, bukan saat runtime di tangan pengguna.

Kelemahan AOT #

Tidak ada Hot Reload — setiap perubahan kode membutuhkan build ulang
Build lebih lama — proses kompilasi AOT lebih berat dari JIT
Kurang fleksibel — optimasi dilakukan berdasarkan analisis statis, bukan perilaku runtime aktual

Analogi AOT
Bayangkan buku yang sudah diterjemahkan sepenuhnya ke bahasa lain sebelum diterbitkan. Pembaca langsung membaca terjemahan final — tidak perlu menunggu penerjemah.

Flutter Menggunakan Keduanya: Sistem Dual Compiler #

Inilah yang membuat Dart dan Flutter benar-benar istimewa: Flutter tidak memilih salah satu — ia menggunakan JIT dan AOT di fase yang berbeda, sesuai dengan kebutuhan.

FASE DEVELOPMENT                    FASE PRODUCTION
      |                                    |
      v                                    v
 flutter run                        flutter build
      |                                    |
      v                                    v
  Mode Debug                          Mode Release
      |                                    |
      v                                    v
 JIT Compiler                        AOT Compiler
      |                                    |
      v                                    v
 Hot Reload aktif               Machine code native
 Debugging lengkap              Startup cepat
 Iterasi cepat                  Performa maksimal

Tiga Build Mode Flutter #

Mode	Compiler	Tujuan	Hot Reload
Debug	JIT	Development & testing	✅ Ya
Profile	AOT	Profiling performa	❌ Tidak
Release	AOT	Produksi & distribusi	❌ Tidak

Mode Debug menggunakan JIT sehingga Hot Reload bisa bekerja. Semua tool debugging aktif.

Mode Profile menggunakan AOT tapi tetap menyertakan informasi performa. Digunakan untuk menganalisis performa real app dengan Flutter DevTools.

Mode Release menggunakan AOT dengan optimasi maksimal. Ini yang dikompilasi saat kamu submit ke App Store atau Play Store.

Cara Menjalankan Masing-Masing Mode #

# Debug mode (default saat development)
flutter run

# Profile mode
flutter run --profile

# Release mode
flutter run --release

# Build release untuk distribusi
flutter build apk --release        # Android
flutter build ios --release        # iOS
flutter build web --release        # Web

Perbandingan Lengkap JIT vs AOT #

Aspek	JIT	AOT
Waktu kompilasi	Saat runtime	Saat build
Kecepatan startup	Lebih lambat	Sangat cepat
Performa runtime	Meningkat bertahap	Konsisten dari awal
Hot Reload	✅ Didukung	❌ Tidak didukung
Ukuran binary	Lebih besar	Lebih kecil
Debugging	Lengkap	Terbatas
Fase penggunaan	Development	Production
Deteksi error	Saat runtime	Saat compile time

Kompilasi Flutter untuk Web #

Untuk platform web, Flutter menggunakan strategi yang sedikit berbeda:

Development Web:
  Dart  -->  dartdevc (dev compiler)  -->  JavaScript (modular)
                                            Hot Reload aktif

Production Web:
  Dart  -->  dart2js  -->  JavaScript (optimized, minified)
  Dart  -->  dart2wasm  -->  WebAssembly (lebih cepat, masa depan)

dartdevc — compiler untuk development web, menghasilkan JavaScript modular yang mendukung Hot Reload
dart2js — compiler untuk produksi web, menghasilkan JavaScript yang dioptimalkan dan di-minify
dart2wasm — compiler eksperimental ke WebAssembly, menawarkan performa jauh lebih tinggi di browser modern

WebAssembly adalah Masa Depan Flutter Web
Flutter Web yang dikompilasi ke WebAssembly (Wasm) menjalankan kode jauh lebih cepat dibanding JavaScript biasa. Dukungan Wasm di Flutter sudah tersedia di Flutter 3.22+ dan terus disempurnakan sebagai prioritas utama tim Flutter.

Mengapa Dua Compiler Lebih Baik dari Satu? #

Pertanyaan yang wajar: mengapa tidak pakai AOT saja untuk segalanya, atau JIT saja?

Jika hanya AOT: setiap perubahan kode sekecil apapun — menggeser padding 4 pixel, mengubah warna teks — membutuhkan build ulang penuh yang bisa memakan waktu 30 detik hingga beberapa menit. Produktivitas developer akan anjlok drastis.

Jika hanya JIT: aplikasi produksi akan startup lebih lambat, menggunakan lebih banyak memori, dan performanya tidak konsisten. Pengalaman pengguna akhir akan menurun.

Dengan dual compiler system, Flutter memberikan yang terbaik dari keduanya:

Developer mendapat iterasi super cepat saat membangun
Pengguna mendapat aplikasi yang cepat, efisien, dan stabil

Ringkasan #

JIT mengkompilasi kode saat runtime — memungkinkan Hot Reload dan debugging, digunakan di mode Debug.
AOT mengkompilasi kode sebelum app dijalankan — menghasilkan performa tinggi dan startup cepat, digunakan di mode Release.
Flutter menggunakan keduanya secara cerdas: JIT untuk development, AOT untuk produksi.
Ada tiga build mode Flutter: Debug (JIT), Profile (AOT + profiling), dan Release (AOT penuh).
Untuk web, Flutter menggunakan dartdevc saat development dan dart2js atau dart2wasm untuk produksi.
Dual compiler system inilah yang membuat Flutter bisa unggul di dua sisi sekaligus: DX dan performa.

← Sebelumnya: Posisi Flutter di Industri Berikutnya: UI Framework →