Gradle KTS — apa itu, Kotlin DSL untuk Gradle dan sintaksis

Apa itu Gradle KTS?

Gradle KTS — adalah Kotlin DSL (Domain Specific Language), yang menyediakan alternatif untuk Groovy dalam menulis file konfigurasi Gradle. Alih-alih sintaksis Groovy, pengembang menggunakan Kotlin — bahasa yang diketik secara ketat yang memeriksa kebenaran konfigurasi pada tahap kompilasi. KTS pertama kali diperkenalkan di Gradle 5.0 pada tahun 2018 sebagai fitur eksperimental dan mencapai stabilitas di Gradle 6.0.

Tujuan utama KTS adalah menghilangkan kekurangan Groovy dalam skrip build. Groovy — bahasa dengan pengetikan dinamis, di mana kesalahan konfigurasi hanya muncul saat runtime selama eksekusi tugas. KTS memungkinkan deteksi kesalahan yang sama pada tahap pengeditan kode berkat pengetikan statis Kotlin. Selain itu, KTS menyediakan akses ke API Gradle dengan dokumentasi tipe yang lengkap, yang secara signifikan memudahkan pembelajaran dan penggunaan blok konfigurasi yang kompleks.

Ekosistem KTS didukung oleh semua alat utama: Android Studio, IntelliJ IDEA, VS Code dengan plugin Kotlin dan Gradle Build Tool. Semua plugin modern (Android Gradle Plugin, Kotlin Multiplatform, Protobuf, Compose) menyediakan API yang ramah Kotlin dengan tipe eksplisit, menjadikan KTS pilihan utama untuk proyek baru.

Cara kerja Gradle KTS

Gradle KTS menggunakan kompiler Kotlin untuk memproses file .gradle.kts. Gradle mengenali ekstensi dan meneruskan skrip ke mesin skrip Kotlin, yang mengompilasinya menjadi kelas. Kelas-kelas ini kemudian dieksekusi oleh Gradle untuk membangun model proyek. Perbedaan utama dari Groovy: skrip KTS dikompilasi terlebih dahulu, bukan ditafsirkan secara dinamis, memungkinkan deteksi kesalahan sebelum eksekusi tugas dimulai.

Arsitektur KTS didasarkan pada kotlin-scripting. Setiap file .gradle.kts adalah skrip Kotlin dengan impor implisit dari API Gradle. Pengembang dapat menggunakan konstruksi Kotlin apa pun: fungsi ekstensi, lambda, kelas data, dan bahkan mendeklarasikan fungsi pembantu di dalam skrip build. Gradle menyediakan serangkaian fungsi ekstensi untuk konfigurasi blok yang diketik: dependencies, android, kotlin, dan lainnya.

plugins {
    id("com.android.application") version "8.4.0"
    kotlin("android") version "2.0.21"
}

android {
    namespace = "com.itsectr.app"
    compileSdk = 34

    defaultConfig {
        applicationId = "com.itsectr.app"
        minSdk = 26
        targetSdk = 34
        versionCode = 1
        versionName = "1.0.0"
    }
}

dependencies {
    implementation(platform("androidx.compose:compose-bom:2024.06.00"))
    implementation("androidx.compose.ui:ui")
    implementation("androidx.core:core-ktx:1.13.1")
}

Konversi tipe di KTS

Salah satu perbedaan utama antara KTS dan Groovy adalah bekerja dengan tipe. Di Groovy, semua konfigurasi menerima Object, di KTS — tipe Kotlin yang konkret. Misalnya, compileSdk menerima Int, bukan string. Ini menghilangkan kesalahan yang terkait dengan tipe yang salah: di Groovy compileSdk 34 dan compileSdk “34” bekerja sama, di KTS hanya varian pertama. Ketelitian semacam itu membuat konfigurasi lebih dapat diprediksi dan terdokumentasi.

Gradle KTS vs Groovy: perbandingan

Groovy adalah DSL asli untuk Gradle dan tetap didukung sepenuhnya. Namun, KTS menawarkan sejumlah keuntungan yang membuatnya direkomendasikan untuk proyek baru. Pengetikan statis, kinerja pengeditan yang lebih baik di IDE, dan sintaksis yang lebih ketat — alasan utama beralih ke KTS. Pada saat yang sama, Groovy mempertahankan keunggulan dalam keringkasan untuk konfigurasi sederhana.

Kinerja build pada KTS dan Groovy hampir identik setelah kompilasi skrip. Skrip KTS membutuhkan waktu kompilasi lebih lama pada saat pertama kali dijalankan atau setelah membersihkan cache, tetapi build berikutnya berjalan dengan kecepatan yang sama dengan skrip Groovy. Gradle menyimpan cache skrip KTS yang telah dikompilasi di direktori build, sehingga kompilasi ulang hanya terjadi saat skrip berubah.

Pilihan antara KTS dan Groovy di tahun 2026 sudah jelas: untuk proyek baru — KTS. Google, JetBrains, dan Gradle merekomendasikan KTS untuk semua proyek baru. Groovy tetap relevan untuk mendukung proyek lama di mana migrasi tidak praktis karena volume konfigurasi atau plugin spesifik yang tidak kompatibel dengan KTS.

Contoh kode: skrip build di KTS

Mari kita lihat blok konfigurasi tipikal di KTS untuk Android, Kotlin Multiplatform, dan Compose Multiplatform. Proyek Android dengan KTS memerlukan penentuan tipe secara eksplisit dalam konfigurasi buildTypes dan productFlavors. Contoh di bawah menunjukkan konfigurasi aplikasi dengan dua flavour.

android {
    buildTypes {
        val release = getByName("release") {
            isMinifyEnabled = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
        getByName("debug") {
            applicationIdSuffix = ".debug"
        }
    }

    flavorDimensions += "version"
    productFlavors {
        register("demo") {
            dimension = "version"
            versionNameSuffix = "-demo"
        }
        register("full") {
            dimension = "version"
        }
    }
}

Untuk Kotlin Multiplatform, KTS wajib — Groovy tidak mendukung konfigurasi modul multi-platform dengan benar. Konfigurasi modul KMM mencakup pengaturan platform target dan source set. Contoh di bawah menunjukkan konfigurasi modul shared dengan iOS dan Android.

kotlin {
    androidTarget {
        compilations.all {
            kotlinOptions {
                jvmTarget = "17"
            }
        }
    }

    listOf(
        iosX64(),
        iosArm64(),
        iosSimulatorArm64()
    ).forEach { iosTarget ->
        iosTarget.binaries.framework {
            baseName = "Shared"
            isStatic = true
        }
    }

    sourceSets {
        commonMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
        }
        androidMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
        }
    }
}

Fungsi pembantu dan tugas kustom

KTS memungkinkan deklarasi fungsi pembantu Kotlin di dalam skrip build. Ini sangat berguna untuk konfigurasi berulang seperti signing configs atau manajemen versi. Berkat pengetikan statis, fungsi semacam itu dapat dipanggil dengan pemeriksaan parameter pada tahap kompilasi, yang menghilangkan kesalahan dalam konfigurasi signing sebelum publikasi ke Google Play.

fun Project.configureSigning() {
    android {
        signingConfigs {
            register("release") {
                storeFile = file("release.keystore")
                storePassword = System.getenv("KEYSTORE_PASSWORD")
                keyAlias = System.getenv("KEY_ALIAS")
                keyPassword = System.getenv("KEY_PASSWORD")
            }
        }
    }
}

// Penggunaan di build.gradle.kts
configureSigning()

Migrasi dari Groovy ke KTS

Migrasi dari Groovy ke KTS — proses yang dapat dilakukan secara bertahap. Gradle mendukung proyek campuran di mana sebagian modul menggunakan Groovy (build.gradle) dan sebagian lagi menggunakan KTS (build.gradle.kts). settings.gradle dan root build.gradle dapat dialihkan terlebih dahulu karena tidak bergantung pada plugin modul. Google merekomendasikan memulai migrasi dengan settings.gradle.kts, kemudian root build.gradle.kts, dan baru setelah itu modul-modul.

Langkah-langkah utama migrasi meliputi: mengganti sintaksis closure dengan lambda, menambahkan tanda = untuk penetapan, mengganti kunci string dengan konstanta yang diketik, dan pengetikan variabel secara eksplisit. Android Studio menyediakan konversi otomatis Groovy → KTS untuk blok sederhana, tetapi konfigurasi kompleks dengan closure bersarang memerlukan penulisan ulang manual.

Masalah umum saat migrasi termasuk panggilan implisit metode Groovy yang tidak memiliki padanan Kotlin dan plugin yang tidak menyediakan API ramah Kotlin. Untuk mengatasi masalah pertama, Gradle menyediakan kompatibilitas melalui withGroovyBuilder — mekanisme yang memungkinkan pemanggilan metode Groovy dari KTS. Untuk masalah kedua — tunggu pembaruan plugin atau gunakan di modul Groovy hingga migrasi selesai.

Gradle KTS untuk Kotlin Multiplatform

Kotlin Multiplatform — proyek utama di mana KTS merupakan persyaratan wajib. Plugin kotlin multiplatform menyediakan ekstensi untuk konfigurasi platform target, source set, dan biner framework yang hanya tersedia melalui Kotlin DSL. Groovy tidak mendukung konfigurasi multi-platform dengan benar, oleh karena itu proyek KMM menggunakan KTS secara eksklusif.

Konfigurasi KMM di KTS mencakup blok non-standar: kotlin.target untuk menentukan platform, kotlin.sourceSets untuk mengatur kode bersama dan platform-spesifik, kotlin.cocoapods untuk integrasi dengan CocoaPods, dan kotlin.jvmToolchain untuk pemilihan JDK. Setiap blok memiliki API yang diketik secara ketat dengan pelengkapan otomatis di Android Studio, yang sangat berharga untuk konfigurasi proyek KMM yang kompleks dengan banyak platform.

kotlin {
    iosArm64()
    iosSimulatorArm64()
    iosX64()

    cocoapods {
        summary = "Shared Kotlin module"
        homepage = "https://itsectr.com"
        framework {
            baseName = "Shared"
            isStatic = false
        }
        pod("Alamofire") {
            version = "5.9"
        }
    }
}

Berkat pengetikan statis KTS, pengembang KMM mendapatkan pelengkapan otomatis untuk source set dan dependensi, pemeriksaan tipe konfigurasi framework, dan kemungkinan refaktorisasi nama platform. KTS juga menyederhanakan debugging: kesalahan dalam konfigurasi KMM ditampilkan sebagai kesalahan kompilasi Kotlin dengan pesan yang dapat dimengerti, tidak seperti Groovy di mana kesalahan bisa tersembunyi hingga eksekusi tugas Gradle.