Use single skiko-awt-runtime dependency on Desktop

buildSrc/private/src/main/kotlin/org/jetbrains/androidx/build/JetBrainsAndroidXImplPlugin.kt

@@ -149,6 +149,7 @@ class JetBrainsAndroidXImplPlugin @Inject constructor(
         project.changeMavenCoordinatesToJetBrains()
         project.configureMavenArtifactUpload(componentFactory)
         project.configureDependencyVerification()
+        project.configureSkikoAwtRuntimeConstraints()
         project.plugins.all { plugin ->
             if (plugin is KotlinMultiplatformPluginWrapper) {
                 onKotlinMultiplatformPluginApplied(project)

buildSrc/private/src/main/kotlin/org/jetbrains/androidx/build/JetBrainsConfigureSkikoAwtRuntimeConstraints.kt

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.androidx.build
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.DependencySubstitution
+import org.gradle.api.artifacts.component.ModuleComponentSelector
+import org.gradle.nativeplatform.MachineArchitecture
+import org.gradle.nativeplatform.OperatingSystemFamily
+import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
+
+fun Project.configureSkikoAwtRuntimeConstraints() {
+    val currentOs = DefaultNativePlatform.getCurrentOperatingSystem()
+    val currentArch = DefaultNativePlatform.getCurrentArchitecture()
+
+    val platformSuffix = when {
+        currentOs.isMacOsX && currentArch.isArm64 -> "macos-arm64"
+        currentOs.isMacOsX && currentArch.isAmd64 -> "macos-x64"
+        currentOs.isLinux && currentArch.isArm64 -> "linux-arm64"
+        currentOs.isLinux && currentArch.isAmd64 -> "linux-x64"
+        currentOs.isWindows && currentArch.isArm64 -> "windows-arm64"
+        currentOs.isWindows && currentArch.isAmd64 -> "windows-x64"
+        else -> error("Unsupported platform: OS=${currentOs.name}, Arch=${currentArch.name}")
+    }
+
+    // Use dependency substitution to replace the universal dependency with platform-specific one
+    // during resolution, without affecting what gets published
+    project.configurations.configureEach { configuration ->
+        if (configuration.isCanBeResolved) {
+            configuration.resolutionStrategy.dependencySubstitution {
+                it.all { substitution ->
+                    val requested = substitution.requested
+                    if (requested is ModuleComponentSelector &&
+                        requested.group == "org.jetbrains.skiko" &&
+                        requested.module == "skiko-awt-runtime") {
+                        // Keep the same version, just change the module name to platform-specific
+                        substitution.useTarget(
+                            "${requested.group}:skiko-awt-runtime-${platformSuffix}:${requested.version}",
+                            "Platform-specific variant selection based on current machine"
+                        )
+                    }
+                }
+            }
+        }
+    }
+}

compose/desktop/desktop/build.gradle

@@ -14,8 +14,11 @@
  * limitations under the License.
  */
 
+
 import androidx.build.AndroidXConfig
 import androidx.build.SoftwareType
+import org.gradle.api.internal.component.SoftwareComponentInternal
+import org.gradle.api.internal.component.UsageContext
 
 plugins {
     id("AndroidXPlugin")
@@ -30,22 +33,21 @@ androidXMultiplatform {
         commonMain.dependencies {
             implementation(project(":compose:ui:ui-util"))
             api(project(":compose:foundation:foundation"))
-            api(project(":compose:material:material"))
             api(project(":compose:runtime:runtime"))
             api(project(":compose:ui:ui"))
             api(project(":compose:ui:ui-tooling-preview"))
         }
 
         jvmMain.dependencies {
             implementation(libs.kotlinCoroutinesCore)
+            implementation(libs.skikoAwtRuntime)
         }
 
         jvmTest {
             resources.srcDirs += new File(AndroidXConfig.getExternalProjectPath(project), "noto-fonts/other/")
             resources.srcDirs += "src/jvmTest/res"
             dependencies {
                 implementation(libs.kotlinCoroutinesTest)
-                implementation(libs.skikoCurrentOs)
                 implementation(project(":compose:ui:ui-test-junit4"))
                 implementation(libs.junit)
                 implementation(libs.truth)
@@ -75,29 +77,62 @@ androidx {
 }
 
 def jvmOs(container, name, skikoDep) {
+    def projectGroup = project.group
+    def projectName = project.name
+    def composeVersion = project.version
+    def skikoModule = skikoDep.module
+    def skikoVersion = skikoDep.versionConstraint.requiredVersion
+
+    def desktopDep = dependencies.create("${projectGroup}:${projectName}:${composeVersion}") {
+        exclude group: 'org.jetbrains.skiko', module: 'skiko-awt-runtime'
+    }
+    def skikoRuntimeDep = dependencies.create("${skikoModule.group}:${skikoModule.name}:${skikoVersion}")
+
+    def apiElements = configurations.create("jvm${name}ApiElements") {
+        canBeResolved = false
+        canBeConsumed = true
+        attributes {
+            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_API))
+        }
+        outgoing.capability("${project.group}:${project.name}-jvm-${name}:${project.version}")
+    }
+    def runtimeElements = configurations.create("jvm${name}RuntimeElements") {
+        canBeResolved = false
+        canBeConsumed = true
+        attributes {
+            attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage, Usage.JAVA_RUNTIME))
+        }
+        outgoing.capability("${project.group}:${project.name}-jvm-${name}:${project.version}")
+    }
+
+    def apiUsage = [
+        getName:                  { -> apiElements.name },
+        getArtifacts:             { -> [] as Set },
+        getAttributes:            { -> apiElements.attributes },
+        getCapabilities:          { -> [] as Set },
+        getDependencies:          { -> [desktopDep] as Set },
+        getDependencyConstraints: { -> [] as Set },
+        getGlobalExcludes:        { -> [] as Set },
+    ] as UsageContext
+
+    def runtimeUsage = [
+        getName:                  { -> runtimeElements.name },
+        getArtifacts:             { -> [] as Set },
+        getAttributes:            { -> runtimeElements.attributes },
+        getCapabilities:          { -> [] as Set },
+        getDependencies:          { -> [desktopDep, skikoRuntimeDep] as Set },
+        getDependencyConstraints: { -> [] as Set },
+        getGlobalExcludes:        { -> [] as Set },
+    ] as UsageContext
+
+    def component = [
+        getName:   { -> "jvm${name}" },
+        getUsages: { -> [apiUsage, runtimeUsage] as Set },
+    ] as SoftwareComponentInternal
+
     container.create("jvm$name", MavenPublication) {
         artifactId = "${project.name}-jvm-$name"
-        def projectGroup = project.group
-        def projectName = project.name
-        def composeVersion = project.version
-        def skikoModule = skikoDep.module
-        def skikoVersion = skikoDep.versionConstraint.requiredVersion
-        pom {
-            withXml {
-                def dependenciesNode = asNode().appendNode("dependencies")
-                def desktopDependency = dependenciesNode.appendNode("dependency")
-                desktopDependency.appendNode("groupId", projectGroup)
-                desktopDependency.appendNode("artifactId", projectName)
-                desktopDependency.appendNode("version", composeVersion)
-                desktopDependency.appendNode("scope", "compile")
-
-                def skikoDependency = dependenciesNode.appendNode("dependency")
-                skikoDependency.appendNode("groupId", skikoModule.group)
-                skikoDependency.appendNode("artifactId", skikoModule.name)
-                skikoDependency.appendNode("version", skikoVersion)
-                skikoDependency.appendNode("scope", "runtime")
-            }
-        }
+        from(component)
     }
 }
 

compose/desktop/desktop/samples-material3/build.gradle

@@ -30,7 +30,7 @@ kotlin {
         }
 
         jvmMain.dependencies {
-            implementation(libs.skikoCurrentOs)
+            implementation(libs.skikoAwtRuntime)
             implementation(project(":compose:material3:material3"))
             implementation(project(":compose:desktop:desktop"))
         }

compose/desktop/desktop/samples/build.gradle

@@ -33,10 +33,9 @@ kotlin {
             resources.srcDirs += "src/jvmMain/res"
 
             dependencies {
-                implementation(libs.skikoCurrentOs)
-            implementation(project(":collection:collection"))
+                implementation(project(":collection:collection"))
                 implementation(project(":compose:desktop:desktop"))
-
+                implementation(project(":compose:material:material"))
                 implementation("org.jetbrains.compose.material:material-icons-core:1.7.3") {
                     // exclude dependencies, because they override local projects when we build 0.0.0-* version
                     // (see https://repo1.maven.org/maven2/org/jetbrains/compose/material/material-icons-core-desktop/1.6.11/material-icons-core-desktop-1.6.11.module)

compose/foundation/foundation/build.gradle

@@ -150,7 +150,7 @@ androidXMultiplatform {
                 implementation(project(":compose:ui:ui-test-junit4"))
                 implementation(libs.truth)
                 implementation(libs.junit)
-                implementation(libs.skikoCurrentOs)
+                implementation(libs.skikoAwtRuntime)
                 implementation(libs.kotlinCoroutinesSwing)
                 implementation(libs.mockitoCore4)
                 implementation(libs.mockitoKotlin4)

compose/material/material/build.gradle

@@ -128,7 +128,7 @@ androidXMultiplatform {
                 implementation(project(":compose:ui:ui-test-junit4"))
                 implementation(libs.truth)
                 implementation(libs.junit)
-                implementation(libs.skikoCurrentOs)
+                implementation(libs.skikoAwtRuntime)
             }
         }
 

compose/material3/material3/build.gradle

@@ -136,7 +136,7 @@ androidXMultiplatform {
                 implementation(project(":compose:ui:ui-test-junit4"))
                 implementation(libs.truth)
                 implementation(libs.junit)
-                implementation(libs.skikoCurrentOs)
+                implementation(libs.skikoAwtRuntime)
             }
         }
 

compose/mpp/demo/build.gradle.kts

@@ -164,7 +164,7 @@ kotlin {
             dependsOn(skikoMain)
             dependencies {
                 implementation(libs.kotlinCoroutinesSwing)
-                implementation(libs.skikoCurrentOs)
+                implementation(libs.skikoAwtRuntime)
             }
         }