Update Kotlin to 2.3.20

blueprints/starter/app/build.gradle.kts

@@ -10,7 +10,6 @@ plugins {
   alias(libs.plugins.appPlatform)
   alias(libs.plugins.androidApplication)
   alias(libs.plugins.kotlinMultiplatform)
-  alias(libs.plugins.composeHotReload)
   alias(libs.plugins.composeMultiplatform)
   alias(libs.plugins.composeCompiler)
 }

blueprints/starter/build.gradle.kts

@@ -2,7 +2,6 @@ plugins {
   alias(libs.plugins.androidApplication) apply false
   alias(libs.plugins.androidKmpLibrary) apply false
   alias(libs.plugins.kotlinMultiplatform) apply false
-  alias(libs.plugins.composeHotReload) apply false
   alias(libs.plugins.composeMultiplatform) apply false
   alias(libs.plugins.composeCompiler) apply false
   alias(libs.plugins.appPlatform)

blueprints/starter/gradle/libs.versions.toml

@@ -1,24 +1,23 @@
 [versions]
 assertk = "0.28.1"
-app-platfrom = "0.0.6"
-agp = "8.12.2"
+app-platfrom = "0.0.8"
+agp = "8.13.2"
 android-compileSdk = "36"
-android-minSdk = "21"
+android-minSdk = "23"
 android-targetSdk = "36"
 androidx-activity-compose = "1.10.1"
 androidx-lifecycle = "2.9.3"
-compose = "1.8.2"
-compose-hot-reload = "1.0.0-beta06"
-compose-multiplatform = "1.8.2"
+compose-material3 = "1.10.0-alpha05"
+compose-multiplatform = "1.10.2"
 coroutines = "1.10.2"
-kotlin = "2.2.10"
+kotlin = "2.3.20"
 material = "1.7.3"
 
 [libraries]
 androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "androidx-activity-compose" }
 androidx-lifecycle-viewmodel = { group = "org.jetbrains.androidx.lifecycle", name = "lifecycle-viewmodel", version.ref = "androidx-lifecycle" }
 assertk = { module = "com.willowtreeapps.assertk:assertk", version.ref = "assertk" }
-compose-material = { module = "org.jetbrains.compose.material3:material3", version.ref = "compose" }
+compose-material = { module = "org.jetbrains.compose.material3:material3", version.ref = "compose-material3" }
 compose-material-icons = { module = "org.jetbrains.compose.material:material-icons-extended", version.ref = "material" }
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
 coroutines-swing = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-swing", version.ref = "coroutines" }
@@ -29,6 +28,5 @@ androidApplication = { id = "com.android.application", version.ref = "agp" }
 androidKmpLibrary = { id = "com.android.kotlin.multiplatform.library", version.ref = "agp" }
 appPlatform = { id = "software.amazon.app.platform", version.ref = "app-platfrom" }
 kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
-composeHotReload = { id = "org.jetbrains.compose.hot-reload", version.ref = "compose-hot-reload" }
 composeMultiplatform = { id = "org.jetbrains.compose", version.ref = "compose-multiplatform" }
 composeCompiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }

buildSrc/src/main/kotlin/software/amazon/app/platform/gradle/buildsrc/KmpPlugin.kt

@@ -14,7 +14,6 @@ import org.gradle.api.artifacts.dsl.DependencyHandler
 import org.gradle.api.plugins.ExtensionAware
 import org.gradle.api.tasks.SourceTask
 import org.jetbrains.compose.ComposeExtension
-import org.jetbrains.compose.ComposePlugin
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 import software.amazon.app.platform.gradle.buildsrc.AppPlatformExtension.Companion.appPlatformBuildSrc
 import software.amazon.app.platform.gradle.buildsrc.Platform.Companion.allPlatforms
@@ -95,8 +94,17 @@ public open class KmpPlugin : Plugin<Project> {
 
     testingSourceSets.forEach { sourceSetName ->
       kmpExtension.sourceSets.getByName(sourceSetName).dependencies {
-        api(libs.findLibrary("coroutines.test").get().get().toString())
-        api(libs.findLibrary("turbine").get().get().toString())
+        // Use api for main source sets (testing utility modules) so downstream modules
+        // get transitive access. Use implementation for test source sets since api is
+        // deprecated there in Kotlin 2.3.
+        val isTestSourceSet = sourceSetName.contains("Test", ignoreCase = true)
+        if (isTestSourceSet) {
+          implementation(libs.findLibrary("coroutines.test").get().get().toString())
+          implementation(libs.findLibrary("turbine").get().get().toString())
+        } else {
+          api(libs.findLibrary("coroutines.test").get().get().toString())
+          api(libs.findLibrary("turbine").get().get().toString())
+        }
       }
     }
 
@@ -106,8 +114,14 @@ public open class KmpPlugin : Plugin<Project> {
   private fun Project.configureTests() {
     testingSourceSets.forEach { sourceSetName ->
       kmpExtension.sourceSets.getByName(sourceSetName).dependencies {
-        api(kotlin("test"))
-        api(libs.findLibrary("assertk").get().get().toString())
+        val isTestSourceSet = sourceSetName.contains("Test", ignoreCase = true)
+        if (isTestSourceSet) {
+          implementation(kotlin("test"))
+          implementation(libs.findLibrary("assertk").get().get().toString())
+        } else {
+          api(kotlin("test"))
+          api(libs.findLibrary("assertk").get().get().toString())
+        }
       }
     }
 
@@ -158,19 +172,18 @@ public open class KmpPlugin : Plugin<Project> {
     val Project.kmpExtension: KotlinMultiplatformExtension
       get() = extensions.getByType(KotlinMultiplatformExtension::class.java)
 
-    val Project.composeDependencies: ComposePlugin.Dependencies
-      get() = ComposePlugin.Dependencies(this)
-
     val Project.composeMultiplatform: ComposeExtension
       get() = extensions.getByType(ComposeExtension::class.java)
 
     fun Project.enableCompose() {
       plugins.apply(Plugins.COMPOSE_COMPILER)
       plugins.apply(Plugins.COMPOSE_MULTIPLATFORM)
 
+      val composeVersion = libs.findVersion("compose.multiplatform").get().requiredVersion
+
       kmpExtension.sourceSets.getByName("commonMain").dependencies {
-        implementation(composeDependencies.runtime)
-        implementation(composeDependencies.foundation)
+        implementation("org.jetbrains.compose.runtime:runtime:$composeVersion")
+        implementation("org.jetbrains.compose.foundation:foundation:$composeVersion")
       }
 
       allPlatforms().forEach { platform -> platform.configureCompose() }

buildSrc/src/main/kotlin/software/amazon/app/platform/gradle/buildsrc/Platform.kt

@@ -5,7 +5,6 @@ import org.gradle.api.plugins.JavaPluginExtension
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import software.amazon.app.platform.gradle.buildsrc.AppPlugin.App.Companion.app
 import software.amazon.app.platform.gradle.buildsrc.AppPlugin.Companion.allExportedDependencies
-import software.amazon.app.platform.gradle.buildsrc.KmpPlugin.Companion.composeDependencies
 import software.amazon.app.platform.gradle.buildsrc.KmpPlugin.Companion.kmpExtension
 import software.amazon.app.platform.gradle.isAppModule
 
@@ -84,13 +83,31 @@ internal sealed interface Platform {
     }
 
     override fun configureCompose() {
+      val composeVersion = project.libs.findVersion("compose.multiplatform").get().requiredVersion
+
       project.kmpExtension.sourceSets.getByName("desktopMain").dependencies {
-        implementation(project.composeDependencies.desktop.currentOs)
+        implementation(
+          "org.jetbrains.compose.desktop:desktop-jvm-${currentOsTarget()}:$composeVersion"
+        )
       }
 
       project.kmpExtension.sourceSets.getByName("desktopTest").dependencies {
-        implementation(project.composeDependencies.desktop.uiTestJUnit4)
-        implementation(project.composeDependencies.desktop.currentOs)
+        implementation("org.jetbrains.compose.ui:ui-test-junit4:$composeVersion")
+        implementation(
+          "org.jetbrains.compose.desktop:desktop-jvm-${currentOsTarget()}:$composeVersion"
+        )
+      }
+    }
+
+    private fun currentOsTarget(): String {
+      val os = System.getProperty("os.name").lowercase()
+      val arch = System.getProperty("os.arch").lowercase()
+      return when {
+        os.contains("mac") || os.contains("darwin") ->
+          if (arch.contains("aarch64") || arch.contains("arm")) "macos-arm64" else "macos-x64"
+        os.contains("win") ->
+          if (arch.contains("aarch64") || arch.contains("arm")) "windows-arm64" else "windows-x64"
+        else -> if (arch.contains("aarch64") || arch.contains("arm")) "linux-arm64" else "linux-x64"
       }
     }
   }

gradle-plugin/build.gradle

@@ -40,6 +40,7 @@ buildConfig {
     buildConfigField(String, 'APP_PLATFORM_VERSION', property('VERSION_NAME'))
     buildConfigField(String, 'MOLECULE_VERSION', libs.versions.molecule.get())
     buildConfigField(String, 'ANDROID_COMPOSE_VERSION', libs.versions.android.compose.version.get())
+    buildConfigField(String, 'COMPOSE_MULTIPLATFORM_VERSION', libs.versions.compose.multiplatform.get())
 }
 
 dependencies {

gradle-plugin/src/main/kotlin/software/amazon/app/platform/gradle/AppPlatformExtension.kt

@@ -4,6 +4,7 @@ import com.google.devtools.ksp.gradle.KspExtension
 import gradle_plugin.BuildConfig.ANDROID_COMPOSE_VERSION
 import gradle_plugin.BuildConfig.APP_PLATFORM_GROUP
 import gradle_plugin.BuildConfig.APP_PLATFORM_VERSION
+import gradle_plugin.BuildConfig.COMPOSE_MULTIPLATFORM_VERSION
 import gradle_plugin.BuildConfig.KOTLIN_INJECT_ANVIL_VERSION
 import gradle_plugin.BuildConfig.KOTLIN_INJECT_VERSION
 import gradle_plugin.BuildConfig.MOLECULE_VERSION
@@ -308,8 +309,8 @@ private fun Project.enableComposeUi() {
     plugins.apply(PluginIds.COMPOSE_MULTIPLATFORM)
 
     kmpExtension.sourceSets.getByName("commonMain").dependencies {
-      implementation(composeDependencies.foundation)
-      implementation(composeDependencies.runtime)
+      implementation("org.jetbrains.compose.foundation:foundation:$COMPOSE_MULTIPLATFORM_VERSION")
+      implementation("org.jetbrains.compose.runtime:runtime:$COMPOSE_MULTIPLATFORM_VERSION")
 
       implementation(
         "$APP_PLATFORM_GROUP:renderer-compose-multiplatform-public:$APP_PLATFORM_VERSION"
@@ -366,14 +367,16 @@ private fun Project.addKspDependenciesWhenConfigExists(
     target.compilations.configureEach { compilation ->
       fun configExists(name: String): Boolean = configurations.any { it.name == name }
 
-      // The implementationConfigurationName name is
-      // 'iosSimulatorArm64CompilationImplementation', 'wasmJsTestCompileClasspath' or
-      // 'desktopCompileClasspath'.
-      //
-      // E.g. 'desktopCompileClasspath' with give use 'kspDesktop'
+      // Derive the KSP configuration name from the target name and compilation name.
+      // For main compilations: ksp<TargetName> (e.g. kspDesktop, kspIosSimulatorArm64)
+      // For test compilations: ksp<TargetName>Test (e.g. kspDesktopTest)
+      val targetName = target.name.capitalize()
       var configName =
-        "ksp" +
-          compilation.implementationConfigurationName.substringBefore("Compilation").capitalize()
+        if (compilation.name == "main") {
+          "ksp$targetName"
+        } else {
+          "ksp$targetName${compilation.name.capitalize()}"
+        }
 
       if (!configExists(configName) && target.platformType == KotlinPlatformType.androidJvm) {
         // Android has different naming for some reason.

gradle-plugin/src/main/kotlin/software/amazon/app/platform/gradle/GradleExtensions.kt

@@ -10,7 +10,6 @@ import org.gradle.api.UnknownTaskException
 import org.gradle.api.plugins.PluginContainer
 import org.gradle.api.project.IsolatedProject
 import org.gradle.api.tasks.TaskContainer
-import org.jetbrains.compose.ComposePlugin
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 
 internal fun PluginContainer.withIds(vararg pluginIds: String, action: (Plugin<*>) -> Unit) {
@@ -38,9 +37,6 @@ internal val Project.androidComponents: AndroidComponentsExtension<*, *, *>
 internal val Project.kmpExtension: KotlinMultiplatformExtension
   get() = extensions.getByType(KotlinMultiplatformExtension::class.java)
 
-internal val Project.composeDependencies: ComposePlugin.Dependencies
-  get() = ComposePlugin.Dependencies(this)
-
 internal fun TaskContainer.namedOptional(name: String, configurationAction: (Task) -> Unit) {
   try {
     named(name, configurationAction)

gradle.properties

@@ -13,8 +13,9 @@ kotlin.mpp.stability.nowarn=true
 kotlin.mpp.androidSourceSetLayoutVersion=2
 kotlin.mpp.enableCInteropCommonization=true
 kotlin.native.distribution.downloadFromMaven=true
-# There are sometimes build errors and the error suggests to enable this flag.
-kotlin.native.cacheKind.iosSimulatorArm64=none
+# https://youtrack.jetbrains.com/issue/KT-82395
+kotlin.incremental.js=false
+kotlin.incremental.js.klib=false
 
 org.jetbrains.compose.experimental.uikit.enabled=true
 

gradle/libs.versions.toml

@@ -3,11 +3,11 @@ agp = "8.13.2"
 android-compileSdk = "36"
 # https://developer.android.com/jetpack/androidx/releases/compose-ui
 # https://maven.google.com/web/index.html#androidx.compose.ui:ui
-android-compose-version = "1.9.2"
+android-compose-version = "1.10.4"
 android-minSdk = "23"
 android-targetSdk = "36"
 #noinspection GradleDependency
-androidx-activity = "1.8.2"
+androidx-activity = "1.13.0"
 androidx-annotations = "1.9.1"
 androidx-collection = "1.5.0"
 #noinspection GradleDependency
@@ -25,17 +25,16 @@ assertk = "0.28.1"
 auto-service = "1.1.1"
 auto-service-ksp = "1.2.0"
 build-config = "5.6.8"
-compose-hot-reload-plugin = "1.0.0-beta08"
 # https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-compatibility-and-versioning.html#kotlin-compatibility
 # https://mvnrepository.com/artifact/org.jetbrains.compose/compose-gradle-plugin
 # https://github.com/JetBrains/compose-multiplatform/releases
-compose-multiplatform = "1.9.3"
+compose-multiplatform = "1.10.2"
 coroutines = "1.10.2"
 detekt = "1.23.8"
 graphviz-java = "0.18.1"
 jvm-compatibility = "11"
 jvm-gradle = "17"
-kotlin = "2.2.21"
+kotlin = "2.3.20"
 kotlin-atomicfu = "0.31.0"
 kotlin-compile-testing = "0.12.1"
 kotlin-hierarchy = "1.1"
@@ -44,10 +43,11 @@ kotlin-inject-anvil = "0.1.7"
 kotlin-poet = "2.2.0"
 kotlinx-binaryCompatibilityValidator = "0.18.1"
 ktfmt-gradle = "0.24.0"
-ksp = "2.3.4"
+ksp = "2.3.6"
 maven-publish = "0.34.0"
-metro = "0.10.1"
+metro = "0.11.3"
 molecule = "2.2.0"
+navigation-event = "1.0.1"
 navigation3 = "1.0.0"
 #noinspection GradleDependency
 recyclerView = "1.2.1"
@@ -115,6 +115,7 @@ metro-compiler = { module = "dev.zacsweers.metro:compiler", version.ref = "metro
 metro-gradle-plugin = { module = "dev.zacsweers.metro:gradle-plugin", version.ref = "metro" }
 metro-runtime = { module = "dev.zacsweers.metro:runtime", version.ref = "metro" }
 molecule-runtime = { module = "app.cash.molecule:molecule-runtime", version.ref = "molecule" }
+navigation-event-compose = { module = "org.jetbrains.androidx.navigationevent:navigationevent-compose", version.ref = "navigation-event" }
 navigation3-runtime = { module = "androidx.navigation3:navigation3-runtime", version.ref = "navigation3" }
 navigation3-ui = { module = "androidx.navigation3:navigation3-ui", version.ref = "navigation3" }
 recyclerView = { module = "androidx.recyclerview:recyclerview", version.ref = "recyclerView" }
@@ -131,7 +132,6 @@ android-library = { id = "com.android.library", version.ref = "agp" }
 android-lint = { id = "com.android.lint", version.ref = "agp" }
 app-platform = { id = "software.amazon.app.platform" }
 build-config = { id = "com.github.gmazzo.buildconfig", version.ref = "build-config" }
-compose-hot-reload = { id = "org.jetbrains.compose.hot-reload", version.ref = "compose-hot-reload-plugin" }
 detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
 kotlin-hierarchy = { id = "io.github.terrakok.kmp-hierarchy", version.ref = "kotlin-hierarchy" }
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }

recipes/app/build.gradle

@@ -5,8 +5,6 @@ plugins {
     // It's used to manage certain configurations and dependencies for all
     // :recipes:* modules, otherwise we'd need to repeat them several times.
     id 'software.amazon.app.platform.app'
-
-    alias libs.plugins.compose.hot.reload
 }
 
 // This extension comes from our published plugin.

renderer-compose-multiplatform/public/build.gradle

@@ -14,7 +14,7 @@ dependencies {
     commonMainApi project(':scope:public')
 
     commonMainImplementation project(':presenter-molecule:public')
-    commonMainImplementation libs.compose.ui.back.handler
+    commonMainImplementation libs.navigation.event.compose
 
     androidMainApi project(':renderer-android-view:public')