Hi i created some module in my KMP app and i can't...

# compose

[Android75]

Hi i created some module in my KMP app and i can't use debugImplementation so i can't use @Preview.
debugImplementation is not resolved
this is module's gradle.

plugins {

    alias(libs.plugins.kotlin.multiplatform)
    alias(libs.plugins.android.kotlin.multiplatform.library)
    alias(libs.plugins.android.lint)
    alias(libs.plugins.composeCompiler)
    alias(libs.plugins.compose.multiplatform)
    alias(libs.plugins.kotlin.serialization)
}

kotlin {

    androidLibrary {
        experimentalProperties["android.experimental.kmp.enableAndroidResources"] = true
    }
    androidLibrary {
        namespace = "com.plcoding.core.designsystem"
        compileSdk = 36
        minSdk = 24

        withHostTestBuilder {
        }

        withDeviceTestBuilder {
            sourceSetTreeName = "test"
        }.configure {
            instrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        }
    }
    
    val xcfName = "core:designsystemKit"

    iosX64 {
        binaries.framework {
            baseName = xcfName
        }
    }

    iosArm64 {
        binaries.framework {
            baseName = xcfName
        }
    }

    iosSimulatorArm64 {
        binaries.framework {
            baseName = xcfName
        }
    }
    sourceSets {
        commonMain {
            dependencies {
                implementation(libs.kotlin.stdlib)

                implementation(projects.core.presentation)
                implementation(libs.jetbrains.compose.foundation)
                implementation(compose.components.resources)

                implementation(compose.components.uiToolingPreview)
                implementation(libs.material3.adaptive)
                implementation(libs.jetbrains.compose.ui)
                implementation(libs.jetbrains.compose.foundation)
                implementation(libs.jetbrains.compose.material3)
                implementation(libs.jetbrains.compose.material.icons.core)

            }
        }
        androidMain {
            dependencies {
               
                
          
            }
        }
        
        iosMain {
            dependencies {
            }
        }
    }
}

[Dequency Yates]

Hi @Android75,
In a Kotlin Multiplatform (KMP) module, debugImplementation (and releaseImplementation) are Android-specific Gradle configurations. They are not automatically available in the kotlin {} block of a KMP module unless you’re explicitly in the Android-specific android Gradle block. That’s why debugImplementation is “not resolved.”

[Android75]

So i have to add a android block?

[Dequency Yates]

Yes

[Android75]

mmm i can't

[Android75]

Screenshot 2025-10-02 alle 17.33.59.png

[Android75]

i put android {} inside module's gradle

[Dequency Yates]

You cannot put dependencies { debugImplementation(...) } inside the android { } block. The Android Gradle plugin expects dependencies { ... } at the module level, not inside android { }.

androidMain {
dependencies {
implementation(compose.components.uiToolingPreview) // @Preview works
}
}
This works for Compose previews without needing debugImplementation
No android { dependencies { ... } } required.

[Android75]

androidMain {
    dependencies {
        implementation(compose.components.uiToolingPreview) 
        implementation("androidx.compose.ui:ui-tooling-preview:1.9.0")
        
    }
}

[Android75]

it does't work

[Android75]

image.png

[Android75]

this si module's gradle

plugins {

    alias(libs.plugins.kotlin.multiplatform)
    alias(libs.plugins.android.kotlin.multiplatform.library)
    alias(libs.plugins.android.lint)
    alias(libs.plugins.composeCompiler)
    alias(libs.plugins.compose.multiplatform)
    alias(libs.plugins.kotlin.serialization)
}
kotlin {

    androidLibrary {
        experimentalProperties["android.experimental.kmp.enableAndroidResources"] = true
    }
    androidLibrary {
        namespace = "com.plcoding.core.designsystem"
        compileSdk = 36
        minSdk = 24

        withHostTestBuilder {
        }

        withDeviceTestBuilder {
            sourceSetTreeName = "test"
        }.configure {
            instrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        }
    }

    val xcfName = "core:designsystemKit"

    iosX64 {
        binaries.framework {
            baseName = xcfName
        }
    }

    iosArm64 {
        binaries.framework {
            baseName = xcfName
        }
    }

    iosSimulatorArm64 {
        binaries.framework {
            baseName = xcfName
        }
    }
    sourceSets {
        commonMain {
            dependencies {
                implementation(libs.kotlin.stdlib)
                implementation(projects.core.presentation)
                implementation(libs.jetbrains.compose.foundation)
                implementation(compose.components.resources)
                implementation(compose.components.uiToolingPreview)
                implementation(libs.material3.adaptive)
                implementation(libs.jetbrains.compose.ui)
                implementation(libs.jetbrains.compose.foundation)
                implementation(libs.jetbrains.compose.material3)
                implementation(libs.jetbrains.compose.material.icons.core)

            }
        }
        androidMain {
            dependencies {
                implementation(compose.components.uiToolingPreview)
                implementation("androidx.compose.ui:ui-tooling-preview:1.9.0")

            }
        }
        iosMain {
            dependencies {
            }
        }
    }
}

[Android75]

i tryed other dependencies and nothing.. i don't see preview

[Dequency Yates]

You need to add ui-tooling as a debug dependency. In your module's dependencies {} (top-level, not in sourceSets):

dependencies {
    debugImplementation("androidx.compose.ui:ui-tooling:1.9.0")
}

ui-tooling must not be in implementation, because it will bloat your APK. That’s why debugImplementation is the right scope.
Keep your actual @Preview functions in androidMain (not commonMain), otherwise Studio won’t find them.

kotlin {
    androidLibrary()
    iosX64()
    iosArm64()
    iosSimulatorArm64()

    sourceSets {
        commonMain {
            dependencies {
                implementation(libs.kotlin.stdlib)
                implementation(projects.core.presentation)
                implementation(libs.jetbrains.compose.foundation)
                implementation(compose.components.resources)
                implementation(compose.components.uiToolingPreview) // preview annotation available everywhere
                implementation(libs.material3.adaptive)
                implementation(libs.jetbrains.compose.ui)
                implementation(libs.jetbrains.compose.foundation)
                implementation(libs.jetbrains.compose.material3)
                implementation(libs.jetbrains.compose.material.icons.core)
            }
        }
        androidMain {
            dependencies {
                implementation(compose.components.uiToolingPreview) // needed in Android
                implementation("androidx.compose.ui:ui-tooling-preview:1.9.0")
            }
        }
    }
}

dependencies {
    // Needed so Studio can actually render the previews
    debugImplementation("androidx.compose.ui:ui-tooling:1.9.0")
}

[Android75]

In

[Android75]

ok but i repeat... i put debugImplementation in top module's gradle... and it does't work

[Android75]

I put dependencies {debugImplementation(....
top and aftet below.. but i have same problem

[Android75]

this is gradle: core:desisnsystem module

plugins {

    alias(libs.plugins.kotlin.multiplatform)
    alias(libs.plugins.android.kotlin.multiplatform.library)
    alias(libs.plugins.compose.multiplatform)
    alias(libs.plugins.composeCompiler)
    alias(libs.plugins.kotlin.serialization)
}

kotlin {

    androidLibrary {
        experimentalProperties["android.experimental.kmp.enableAndroidResources"] = true

    }
    androidLibrary {

        namespace = "com.plcoding.core.designsystem"
        compileSdk = 36
        minSdk = 24

        withHostTestBuilder {
        }

        withDeviceTestBuilder {
            sourceSetTreeName = "test"
        }.configure {
            instrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        }
    }

    val xcfName = "core:designsystemKit"

    iosX64 {
        binaries.framework {
            baseName = xcfName
        }
    }

    iosArm64 {
        binaries.framework {
            baseName = xcfName
        }
    }

    iosSimulatorArm64 {
        binaries.framework {
            baseName = xcfName
        }
    }
    sourceSets {
        commonMain {
            dependencies {
                implementation(libs.kotlin.stdlib)
                implementation(projects.core.presentation)
                implementation(libs.jetbrains.compose.foundation)
                implementation(compose.components.resources)
                implementation(compose.components.uiToolingPreview)
                implementation(libs.material3.adaptive)
                implementation(libs.jetbrains.compose.ui)
                implementation(libs.jetbrains.compose.foundation)
                implementation(libs.jetbrains.compose.material3)
                implementation(libs.jetbrains.compose.material.icons.core)

            }
        }
        androidMain {
            dependencies {
                implementation(compose.components.uiToolingPreview) // needed in Android
                implementation("androidx.compose.ui:ui-tooling-preview:1.9.0")
            }
        }
        iosMain {
            dependencies {
            }
        }
    }
}
dependencies {
    // Needed so Studio can actually render the previews
    debugImplementation("androidx.compose.ui:ui-tooling:1.9.0")
}

[Dequency Yates]

Ah.. I see.
Keep ui-tooling-preview in androidMain
Move debugImplementation(ui-tooling) into `androidMain`’s dependencies block, not top-level.
Don’t try to put a dependencies { debugImplementation(...) } after the kotlin {} block in KMP.

sourceSets {
    androidMain {
        dependencies {
            implementation(compose.components.uiToolingPreview) // annotation
            implementation("androidx.compose.ui:ui-tooling-preview:1.9.0")
            debugImplementation("androidx.compose.ui:ui-tooling:1.9.0") // <- put here, not top-level
        }
    }
}

[Android75]

i can't use debugImplementation inside a module

[Android75]

i repeat... debugImplementation does't work... this is my gradle:

plugins {

    alias(libs.plugins.kotlin.multiplatform)
    alias(libs.plugins.android.kotlin.multiplatform.library)
    alias(libs.plugins.compose.multiplatform)
    alias(libs.plugins.composeCompiler)
    alias(libs.plugins.kotlin.serialization)
}

kotlin {

    androidLibrary {
        experimentalProperties["android.experimental.kmp.enableAndroidResources"] = true

    }
    androidLibrary {

        namespace = "com.plcoding.core.designsystem"
        compileSdk = 36
        minSdk = 24

        withHostTestBuilder {
        }

        withDeviceTestBuilder {
            sourceSetTreeName = "test"
        }.configure {
            instrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
        }
    }

    val xcfName = "core:designsystemKit"

    iosX64 {
        binaries.framework {
            baseName = xcfName
        }
    }

    iosArm64 {
        binaries.framework {
            baseName = xcfName
        }
    }

    iosSimulatorArm64 {
        binaries.framework {
            baseName = xcfName
        }
    }
    sourceSets {
        commonMain {
                dependencies {
                implementation(libs.kotlin.stdlib)
                implementation(projects.core.presentation)
                implementation(libs.jetbrains.compose.foundation)
                implementation(compose.components.resources)
                implementation(compose.components.uiToolingPreview)
                implementation(libs.material3.adaptive)
                implementation(libs.jetbrains.compose.ui)
                implementation(libs.jetbrains.compose.foundation)
                implementation(libs.jetbrains.compose.material3)
                implementation(libs.jetbrains.compose.material.icons.core)

            }
        }
        androidMain {
            dependencies {
                implementation(compose.components.uiToolingPreview) // annotation
                implementation("androidx.compose.ui:ui-tooling-preview:1.9.0")
                debugImplementation("androidx.compose.ui:ui-tooling:1.9.0") // <- put here, not top-level
            }
        }
        iosMain {
            dependencies {
            }
        }
    }
}

[Michael Krussel]

The directory to put files in is src/androidDebug

https://www.jetbrains.com/help/kotlin-multiplatform-dev/multiplatform-android-layout.html#move-the-androidmanifest-xml-file

So I would expected

kotlin {
    sourceSets { 
        androidDebug {
            implementation("...")
        }
    }
}

The IDE doesn't recognize it so I don't know if that is right.

[Konstantin Tskhovrebov]

androidLibrary

has problems with previews

[Konstantin Tskhovrebov]

https://issuetracker.google.com/issues/422373442?pli=1

[Android75]

i ddn't resolve 😞 i can't see preview

[Android75]

i created a project, a simple example and i can't see the Preview inside module
https://github.com/giuseppesorce/testmodulekmp

[Android75]

I resolved with this... very strange:

androidMain {
            dependencies {
                implementation(compose.uiTooling)
                implementation(compose.preview)
                implementation(libs.androidx.activity.compose)
                implementation("androidx.emoji2:emoji2:1.5.0")
                implementation("androidx.customview:customview-poolingcontainer:1.1.0")
            }
        }