Shadow is not working with Kotlin Multiplatform plugin

[Danilo-Araujo-Silva]

Please check the User Guide before submitting "how do I do 'x'?" questions!

Shadow Version

5.0.0

Gradle Version

5.3.1

Expected Behavior

The shadowJar task should appear and work.

Actual Behavior

Only the knows task appears and the shadow task don't appear and don't work.

Gradle Build Script(s)

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
...
plugins {
    kotlin("multiplatform")

    id("com.github.johnrengelman.shadow") version "5.0.0"
}
...
tasks.withType<ShadowJar> {
    baseName = "app"
    classifier = ""
    version = ""
}

//// This works but do not really creat the fatJar, java -jar myFatJar.jar doesn't run and inside of this jar we have just a MANIFEST.MF with a single line of information.
//tasks.create("shadowJar", ShadowJar::class.java) {
//	baseName = "my_project"
//	classifier = ""
//	version = ""
//}

Content of Shadow JAR (jar tf <jar file> - post link to GIST if too long)

None.

[Danilo-Araujo-Silva]

I was able to have something working with:

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
...
plugins {
	kotlin("multiplatform")

	id("com.github.johnrengelman.shadow") version "5.0.0"
	id("java")
}
...
tasks.withType<ShadowJar> {
    manifest {
        attributes.put("Main-Class", "com.example.ExampleKt")
    }

    val target = kotlin.targets.jvm("myTarget")
    from(target.compilations["main"].output)
    val runtimeClasspath = target.compilations["main"].compileDependencyFiles as Configuration
    configurations = mutableListOf(runtimeClasspath)
}

But I need to be checking the other options available.

[Ingwersaft]

Your workaround didn't work for me, I had to modify it a little bit, maybe it helps someone :)

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar

plugins {
    kotlin("multiplatform") version "1.3.50"
    id("com.github.johnrengelman.shadow") version "5.1.0"
}
val ktor_version: String by project
val kotlin_version: String by project
val logback_version: String by project

repositories {
    mavenCentral()
    mavenLocal()
    jcenter()
    maven { url = uri("https://kotlin.bintray.com/ktor") }
}

group = "<group>"

kotlin {
    jvm {
        compilations["main"].defaultSourceSet {
            dependencies {
                implementation(kotlin("stdlib-jdk8"))
                implementation("io.ktor:ktor-server-netty:$ktor_version")
                implementation("ch.qos.logback:logback-classic:$logback_version")
                implementation("io.ktor:ktor-server-core:$ktor_version")
                implementation("io.ktor:ktor-server-host-common:$ktor_version")
                implementation("io.ktor:ktor-metrics:$ktor_version")
                implementation("io.ktor:ktor-auth:$ktor_version")
                implementation("com.pi4j:pi4j-core:1.2")
            }
        }
        compilations["test"].defaultSourceSet {
            dependencies {
                implementation("io.ktor:ktor-server-tests:$ktor_version")
            }
        }
    }
    js().compilations["main"].defaultSourceSet {
        dependencies {
            implementation(kotlin("stdlib-js"))
        }
    }
}
tasks {
    val shadowCreate by creating(ShadowJar::class) {
        manifest {
            attributes["Main-Class"] = "<mainfullyqualified>"
        }
        archiveClassifier.set("all")
        from(kotlin.jvm().compilations.getByName("main").output)
        configurations =
            mutableListOf(kotlin.jvm().compilations.getByName("main").compileDependencyFiles as Configuration)
    }
    val build by existing {
        dependsOn(shadowCreate)
    }
}

[avan1235]

You actually need also runtime dependencies imo, so the valid full configuration (with Kotlin idiomatic syntax) would contain

tasks.withType<ShadowJar> {
  manifest {
    attributes("Main-Class" to "main.fully.qualified.Class")
  }
  archiveClassifier.set("all")
  val main by kotlin.jvm().compilations
  from(main.output)
  configurations += main.compileDependencyFiles as Configuration
  configurations += main.runtimeDependencyFiles as Configuration
}

[NorbertSandor]

Is there a plan to support this feature? As I see, Kotlin is moving towards "multiplatform with single target" instead of the platform-specific Kotlin plugins (e.g. js will be deprecated, or it is already).

[alexstyl]

The previous mentioned tasks wouldn't compile on my end. Fixed it by doing:

tasks.withType<ShadowJar> {
    manifest {
        attributes.put("Main-Class", "MainKt") // "MainKt" or w/e your main class is
    }

    val target = kotlin.targets.named("desktop").get() //"desktop" or w/e name your jvm target is
    from(target.compilations["main"].output)
    val runtimeClasspath = target.compilations["main"].compileDependencyFiles
    configurations = mutableListOf(runtimeClasspath)
}

EDIT: The above works on a sample project but doesnt work on my main project. The shadowJar task is not in the tasks. Trying to figure this out.

EDIT 2: Figured it out. Needed to add id("java") in the plugins. Without it, the shadowJar task doesnt appear in tasks. Not sure how this will work as my multiplatform project is targeting Android too, and Android complains that you can't use java with libs.plugins.androidApplication but I'll figure it out.

[Ynnck123]

@alexstyl did you manage to come up with a solution for the Android target?

[sureshg]

Kotlin 2.1.20-RC prevents the java/application plugin from working with Kotlin Multiplatform, which means shadowJar task won't be created automatically. Here is the custom task to build an uber JAR for Multiplatform JVM projects, and it working with Kotlin 2.1.20-RC and Shadow 9.0.0-beta9.

pluginManager.withPlugin("com.gradleup.shadow") {
    // Register a shadowJar task for the default jvm target
    val shadowJvmJar by
        registering(ShadowJar::class) {
          val main by kotlin.jvm().compilations
          // allOutputs == classes + resources
          from(main.output.allOutputs)
          val runtimeDepConfig =
              project.configurations.getByName(main.runtimeDependencyConfigurationName)
          configurations = listOf(runtimeDepConfig)
          archiveClassifier = "all"
          mergeServiceFiles()
          manifest {
            attributes[Attributes.Name.MAIN_CLASS.toString()] = "MainKt"
          }
          duplicatesStrategy = DuplicatesStrategy.INCLUDE
        }
    build { finalizedBy(shadowJvmJar) }
  }

[AngeloFilaseta]

I had the same problem after updating to Kotlin 2.1.20. I created a custom task as suggested and I moved my previously working configuration inside. Everything works now, thank you so much!

BTW, are there any plans to integrate this change in the shadow plugin?
Should a dedicated issue be opened? The new Kotlin DSL syntax for JVM executable configuration looks like this:

val coreMainClass = "MainKt"

kotlin {
    jvm {
        @OptIn(ExperimentalKotlinGradlePluginApi::class)
        binaries {
            // Configures a JavaExec task named "runJvm" and a Gradle distribution for the "main" compilation in this target
            executable {
                mainClass.set(coreMainClass)
            }
        }
    }
}

The presence of the application plugin result in these errors at build time:

e: ❌ 'java' Plugin Incompatible with 'org.jetbrains.kotlin.multiplatform' Plugin
'java' Gradle plugin is not compatible with 'org.jetbrains.kotlin.multiplatform' plugin.
Consider adding a new subproject with 'java' plugin where the KMP project is added as a dependency.


e: ❌ 'application' Plugin Incompatible with 'org.jetbrains.kotlin.multiplatform' Plugin
'application' (also applies 'java' plugin) Gradle plugin is not compatible with 'org.jetbrains.kotlin.multiplatform' plugin.
Consider the new KMP/JVM binaries DSL as a replacement: https://kotl.in/jvm-binaries-dsl

[Goooler]

I tried to support binaries stuffs in #1333, but it can't be obtained lazily, need the help from Kotlin side.