Kotlin Multiplatform untuk Pemula - Bagikan Kode Android dan iOS dengan Satu Codebase

Pernah nggak sih kamu ngerasa frustrasi karena harus nulis logic aplikasi dua kali? Satu versi buat Android pakai Kotlin, satu versi lagi buat iOS pakai Swift. Saya ngalamin sendiri waktu bikin aplikasi catatan sederhana: validasi form, parsing JSON, sampe hitung-hitungan tanggal, semua harus diimplementasi dua kali di dua codebase berbeda. Belum lagi kalau ada bug, harus fix dobel. Sampai akhirnya saya nemu Kotlin Multiplatform, dan cara kerja saya berubah total.

Kotlin Multiplatform (sering disingkat KMP) adalah teknologi dari JetBrains yang memungkinkan kamu menulis business logic satu kali dalam Kotlin, lalu dipakai bareng antara aplikasi Android dan iOS. UI-nya tetap native: pakai Jetpack Compose di Android dan SwiftUI di iOS. Tapi semua logic yang nggak nyentuh layar bisa di-share sampai 80-90 persen. Di artikel ini saya bahas lengkap: apa itu KMP, gimana cara kerjanya, cara setup project pertama, plus contoh kode nyata yang bisa langsung kamu praktekin.

Apa itu Kotlin Multiplatform?

Kotlin Multiplatform adalah fitur dari bahasa Kotlin yang dikembangkan JetBrains. Intinya: kamu nulis kode sekali dalam Kotlin, dan kode itu bisa jalan di banyak platform: Android, iOS, desktop JVM, JavaScript, sampai native. Untuk kasus mobile, pola yang paling umum disebut shared module: satu modul Kotlin berisi business logic, lalu dua aplikasi native tinggal consume modul itu.

Yang sering bikin bingung: KMP itu BUKAN framework UI kayak Flutter atau React Native. Flutter dan React Native mengganti layer UI dengan widget mereka sendiri. KMP justru mempertahankan UI native. Kamu tetap pakai Jetpack Compose atau XML di Android, dan SwiftUI di iOS. Yang di-share cuma lapisan logic: model data, repository, networking, validasi, dan sejenisnya. Ini beda filosofi yang penting banget buat dipahami sebelum kamu mulai.

Kenapa KMP menarik buat developer?

Satu logic, dua platform: tulis sekali, jalan di Android dan iOS. Pengurangan effort bisa 40-60 persen untuk fitur yang dominan logic.
UI tetap native: nggak ada trade-off soal look and feel. Aplikasi tetap terasa 100 persen asli di tiap platform.
Adopsi bertahap: kamu nggak perlu rewrite aplikasi dari nol. Bisa mulai dari satu modul kecil (misalnya modul networking), terus diperluas pelan-pelan.
Ekosistem JetBrains: didukung penuh oleh pembuat Kotlin, plus library resmi kayak Ktor (networking), kotlinx.serialization (JSON), dan SQLDelight (database).
Backing perusahaan besar: dipakai production oleh Netflix, Reddit, dan banyak startup. Artinya teknologinya matang, bukan eksperimen belaka.

Bagaimana KMP bekerja di balik layar?

KMP pakai konsep source sets. Kode yang bisa dipakai semua platform ditaruh di commonMain. Kode spesifik platform ditaruh di androidMain dan iosMain. Compiler Kotlin lalu menghasilkan artifact yang berbeda: bytecode JVM buat Android, dan kode native via Kotlin/Native buat iOS.

Untuk fungsi yang emang beda implementasinya per platform, KMP punya mekanisme expect/actual. Kamu deklarasikan fungsi di commonMain dengan keyword expect, lalu implementasikan di tiap platform dengan actual.


// Di commonMain
expect fun getPlatformName(): String

// Di androidMain
actual fun getPlatformName(): String =
    "Android ${android.os.Build.VERSION.SDK_INT}"

// Di iosMain
actual fun getPlatformName(): String =
    "iOS ${UIDevice.currentDevice.systemVersion}"

Mekanisme ini yang bikin KMP fleksibel: 90 persen kode kamu bisa generic, dan 10 persen sisanya yang emang butuh akses API platform tertentu diisolasi di source set masing-masing. Yang penting diingat, expect/actual bukan buat semua hal - banyak library resmi yang udah nyediain implementasi common, jadi kamu jarang banget perlu nulis actual sendiri.

Setup project KMP pertama

Cara paling gampang mulai adalah pakai KMP wizard resmi di kmp.jetbrains.com. Pilih template "Android + iOS", kasih nama project, download, terus buka di Android Studio versi terbaru. Sebelum itu, pastikan environment kamu siap:


# Cek environment KMP - kdoctor ngecek JDK, Android SDK, Xcode, dll
kdoctor

# Kalau belum punya kdoctor:
brew install kdoctor

Struktur project KMP standar kurang lebih begini:


my-kmp-app/
|-- composeApp/
|   |-- src/
|   |   |-- commonMain/kotlin/   # logic shared Android + iOS
|   |   |-- androidMain/kotlin/  # implementasi spesifik Android
|   |   `-- iosMain/kotlin/      # implementasi spesifik iOS
|-- iosApp/
|   |-- iosApp/
|   `-- iosApp.xcodeproj
|-- gradle/
|-- build.gradle.kts
`-- settings.gradle.kts

Kalau kamu pilih template dengan Compose Multiplatform, folder composeApp juga berisi UI Compose yang bisa jalan di kedua platform. Tapi buat artikel ini saya fokus ke shared logic aja, karena itu inti KMP. UI native tetap ditulis terpisah di masing-masing platform.

Contoh nyata: networking dengan Ktor Client

Networking adalah kandidat paling umum buat di-share. Di aplikasi biasa, kamu pasti butuh GET data dari API, parse JSON, dan handle error. Dengan KMP, semua itu cukup ditulis sekali di commonMain. Ini contoh client API sederhana pakai Ktor:


// Di commonMain - cukup tulis SEKALI!
import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.request.*
import io.ktor.serialization.kotlinx.json.*
import kotlinx.serialization.json.Json
import kotlinx.serialization.Serializable

@Serializable
data class Post(
    val id: Int,
    val title: String,
    val body: String
)

class ApiClient {
    private val client = HttpClient {
        install(ContentNegotiation) {
            json(Json { ignoreUnknownKeys = true })
        }
    }

    suspend fun getPosts(): List<Post> =
        client.get("https://jsonplaceholder.typicode.com/posts").body()
}

Perhatikan: nggak ada import Android atau iOS sama sekali. Kode ini murni Kotlin. Di sisi Android kamu panggil dari ViewModel, di sisi iOS kamu panggil dari SwiftUI lewat interop yang di-generate otomatis. Ktor secara internal pilih engine yang cocok per platform: OkHttp di Android, Darwin di iOS. Kamu nggak perlu ngurusin itu.

Database lokal dengan SQLDelight

Kalau aplikasimu butuh penyimpanan lokal, SQLDelight adalah pilihan paling matang di ekosistem KMP. Kamu tulis query SQL di file .sq, dan SQLDelight generate tipe-safe code darinya. Di Android dia pakai SQLite native, di iOS pakai SQLite juga via native driver. Bedanya dari Room: Room cuma Android, SQLDelight jalan di semua platform.


-- File: Post.sq
CREATE TABLE post (
    id INTEGER NOT NULL PRIMARY KEY,
    title TEXT NOT NULL,
    body TEXT NOT NULL
);

selectAll:
SELECT * FROM post ORDER BY id DESC;

insertPost:
INSERT OR REPLACE INTO post(id, title, body) VALUES (?, ?, ?);

Setelah file .sq dibuat, tinggal panggil query yang di-generate:


// commonMain - database shared!
val db = AppDatabase(
    driver = DatabaseDriverFactory().createDriver()
)
val posts: List<Post> = db.postQueries.selectAll().executeAsList()

DatabaseDriverFactory di kode di atas adalah satu-satunya bagian yang perlu implementasi actual per platform, karena cara buka file database beda di Android dan iOS. Sisanya, semua query dan model reusable.

Kapan pakai KMP, kapan nggak?

KMP bukan jawaban untuk semua project. Ini pertimbangan jujur dari pengalaman saya:

Pakai KMP kalau: aplikasimu dominan business logic, punya tim kecil yang mau efisien, atau produknya butuh konsistensi fitur antar platform. Cocok banget buat aplikasi internal, MVP, dan produk SaaS.
Jangan pake KMP kalau: aplikasimu cuma target satu platform, UI-nya super kompleks dan beda banget antar platform, atau timmu belum familiar dengan Kotlin sama sekali. Kalau tim cuma bisa Swift, belajar Kotlin + KMP itu investasi yang nggak kecil.
Alternatif yang perlu dipertimbangkan: Flutter dan React Native tetap valid kalau prioritasmu UI yang benar-benar di-share dan tim kecil pengen gercep. KMP menang kalau kamu nggak mau korbanin native experience.

Tips production dari pengalaman saya

Mulai dari modul networking dulu. Jangan langsung migrate semua logic. Pisahin satu fitur, bandingin hasilnya, baru lanjut.
Gunakan version catalog (libs.versions.toml) dari awal. Manage dependency KMP yang banyak bisa cepat jadi mimpi buruk kalau versi nggak terpusat.
Pastikan CI build dua platform. Kalau cuma build Android, error di iOS baru ketahuan pas mau rilis. GitHub Actions punya template KMP yang bisa langsung dipakai.
Hati-hati sama library yang nggak support KMP. Sebelum pilih library, cek dulu di kotlinlang.org/docs/multiplatform.html atau repo resminya apakah ada varian common.
Keep commonMain bersih. Jangan sekali-kali nulis kode Android di commonMain pakai workaround. Itu bikin technical debt yang sakit banget dibayar belakangan.
Manfaatkan expect/actual dengan bijak. Tulis actual cuma untuk hal yang emang platform-specific, kayak akses file, hardware, atau API sistem. Untuk sisanya, prefer library yang udah nyediain implementasi common.

KMP vs Flutter vs React Native: perbandingan jujur

Pertanyaan yang paling sering muncul di grup developer: "Kalau gitu mending KMP, Flutter, atau React Native?" Jawaban jujurnya: tergantung prioritas kamu. Ini perbandingan yang saya rangkum dari pengalaman pakai ketiganya:

UI sharing: Flutter dan React Native share UI sampai 100 persen. KMP nol, karena UI tetap ditulis native per platform. Kalau prioritasmu UI yang seragam, Flutter menang telak.
Business logic sharing: KMP share logic sampai 80-90 persen dengan type safety penuh. Flutter share logic lewat package Dart, React Native lewat JavaScript atau TypeScript. KMP paling rapi untuk logic yang kompleks.
Performance: KMP paling dekat dengan native karena compile ke kode native. Flutter juga cepat dengan rendering engine sendiri. React Native butuh bridge, biasanya paling lambat di kasus berat.
Learning curve: kalau kamu udah bisa Kotlin, KMP paling landai. Kalau dari JavaScript, React Native paling gampang. Kalau dari Dart, ya Flutter.
Ekosistem library: Flutter dan React Native punya package ecosystem yang jauh lebih besar. KMP masih muda, tapi library inti kayak Ktor, SQLDelight, dan coroutines udah solid.

Kesimpulan saya: buat aplikasi yang UI-nya harus khas tiap platform, misalnya aplikasi finance atau social, KMP juara. Buat aplikasi internal yang pengen gercep dengan satu tim kecil, Flutter masih susah dikalahin.

Masalah umum yang sering saya temui

KMP nggak selalu mulus. Ini beberapa masalah yang paling sering saya temui dan cara ngatasinnya:

Xcode version mismatch: error aneh pas build iOS biasanya karena Xcode ke-tua atau ke-muda dari yang didukung Kotlin/Native. Solusinya: cek compatibility table di dokumentasi resmi, atau upgrade Xcode lewat App Store.
Kotlin/Native butuh RAM gede: build iOS pertama bisa makan 8-10 GB RAM. Kalau laptop kamu nge-hang pas build, tambahin kotlin.native.cacheKind=none di gradle.properties buat ngurangin beban, walaupun build jadi lebih lambat.
Library Android dipanggil dari commonMain: ini error klasik. Pastikan import library Android cuma ada di androidMain, dan pakai expect/actual kalau butuh akses dari common.
CocoaPods vs Swift Package Manager: project KMP lama umumnya pakai CocoaPods. Project baru default ke SPM. Kalau integrasi ke Xcode bermasalah, cek dulu framework mana yang dipakai project kamu.
Cold start iOS simulator lambat: itu normal. Build KMP ke simulator memang lebih lambat daripada Android. Biasakan incremental build dan jangan matiin simulator.

Sebagian besar masalah ini muncul sekali di awal, dan hilang setelah project kamu jalan. Yang penting jangan nyerah di minggu pertama.

Kesimpulan

Kotlin Multiplatform itu bukan hype kosong. Buat developer yang pengen efisiensi tanpa mengorbankan kualitas native, KMP menawarkan jalan tengah yang jarang dimiliki teknologi lain: shared logic 80-90 persen, UI native 100 persen. Mulainya juga nggak harus revolusioner - cukup satu modul kecil, pelan-pelan, dan ukur hasilnya.

Menurut saya, kombinasi KMP + Compose Multiplatform bakal makin populer beberapa tahun ke depan, apalagi dengan dukungan JetBrains dan adopsi dari perusahaan besar. Kalau kamu masih ragu, coba aja bikin project hello world di kmp.jetbrains.com malam ini. Lima belas menit, dan kamu bakal langsung paham kenapa KMP seru.

Kamu sendiri gimana? Udah pernah coba Kotlin Multiplatform, atau masih setia sama Flutter atau React Native? Cerita pengalamanmu di kolom komentar ya, siapa tau bisa jadi bahan diskusi seru buat developer lain.