Is it possible to consume a pure kotlin dependency in a multiplatform module?

val commonMain by getting {
    dependencies {
        api(project(":some-pure-kotlin-stuff"))
    }
}

gives me odd errors at sync time

:shared:iosArm64Main: Could not resolve project :some-pure-kotlin-stuff
Required by:
    project :shared

Possible solution:
 - Declare repository providing the artifact, see the documentation at <https://docs.gradle.org/current/userguide/declaring_repositories.html>

Is this not supported? Can KMP modules only depend on KMP modules?

The dependency must support the targets which you have enabled in your module. From the looks of your error, the "pure kotlin" dependency does not support the

iosArm64

target and cannot provide the

.klib

for it.

I don't follow, the pure kotlin dependency is just a

plugins {
    id "kotlin"
}

and nothing extra. Should that not just work?

use

kotlin("multiplatform")

is that the only way? to make the pure kotlin multiplatform aware? I thought if there is no jvm/android dependency anywhere, it can be consumed directly

👀 I'm not sure of that... Would be nice.

At the moment there's no such thing as a "pure Kotlin" module the way you seem to be expecting. Multiplatform modules must declare their targets, and can only depend on modules that include the same targets. Using

id "kotlin"

isn't pure Kotlin, it's actually JVM. You need to use the multiplatform gradle plugin for multiplatform.

I see, so

id "kotlin"

is essentially equivalent to

plugins {
    id "org.jetbrains.kotlin.multiplatform"
}

kotlin {
    jvm()
}

?

no it's an alias for

org.jetbrains.kotlin.jvm

I see, I somehow thought the final app can dictate the target platform, but yea that's nonsense, "id kotlin" is jvm, invokes kotlinc, which produces jvm bytecode etc

What you are referring to is IR-only dependencies which are still a long way away. This will allow you to ship target-agnostic Kotlin which is lowered to the specific platforms you are targeting as part of your compilation step. It's also not 100% bulletproof, as a new target may be incompatible with the APIs you reference.

is that dependant on the K2 coming online?

It depends on a stable, serializable IR format. I don't think that's strictly tied to K2, but they certainly will do K2 before doing this.

I see, that would be sweet, although, gradle folks recommend the convention plugins anways, so hiding the setup shouldn't be that hard

https://youtrack.jetbrains.com/issue/KT-52666 if you want to follow progress

so in a "pure" kotlin module (lets just say some business logic, no platform dependencies, just kotlin sdtlib)

plugins {
    id "org.jetbrains.kotlin.multiplatform"
}

kotlin {
    jvm()
    ios()
}

is the minimum config needed to get android and ios apps going?

ios()

does not include the arm simulator, but otherwise yes. also you may want

android()

and not

jvm()

depending on whether you use Android APIs or not.

when setting up our project some time ago, I was peripherally aware of kotlin multiplatform, hoping it would mature, and came up with internal rule to have pure jvm kotlin modules whenever practical, which is turns out most of the app, and naively I think this makes built times faster 😄

it absolutely does

okay so the MO should be jvm+ios(+simulator), and we can sort of pretend it's a IR-only dependency in

/commonMain

well, until you decide you want to add browser support 🙂

as in JS?

yeah, or wasm eventually

we have a monorepo, adding it should be trivial, given the internal convention plugin