A modern programming language that makes developers happier.

kotlinlang

Perhaps like this?

```
presets.withType&lt;KotlinNativeTargetPreset&gt;().forEach { preset -&gt;
    targetFromPreset(preset)  {
        val main by compilations.getting {
            dependencies {
                api("org.jetbrains.kotlinx:kotlinx-coroutines-core-native:1.2.2")
            }
        }
    }
}
```

Im glad you added this because it clears up the question and I was going to give you completely the wrong answer. :joy:

Since you are dynamically defining targets for the native platform, are there any targets/source sets that will be used that wont be working on this dependency?

I don’t believe so. _All_ the sources are in `commonMain`. I just want to allow it to be consumed by anything.

The build script, for reference: <https://github.com/oolong-kt/oolong/blob/master/oolong/build.gradle.kts>

I hobbled this together with all the limited MPP information I could gather ^

Oh!
```
allprojects {
  dependencies {
  
  }
}
```

Oh, I’m not trying to apply it to all subprojects, sorry. What I meant to say is that I would like this library to work for any MPP target.

All the code is in `commonMain` which means it’s not restricted to any particular target. As such, I would like to allow library consumers to add this library as a dependency to any target they wish.

I could explicitly declare every target as it is currently set up. Or I could iterate through all presets.

Ok so …. where you are saying

```
    js {
        compilations.forEach {
            it.kotlinOptions {
                moduleKind = "umd"
                sourceMap = true
            }
        }
    }
    jvm()
    iosX64("ios") {
        binaries {
            framework("Oolong")
        }
    }
    linuxX64("linux")
    macosX64("macOS")
    mingwX64("windows")

    cocoapods {
        summary = "MVU for Kotlin Multiplatform"
        homepage = "<http://oolong-kt.org>"
    }
```

have it programatically define targets rather than how it currently is?

so that it has individual build targets for each platform?

```
kotlin {
    presets.withType&lt;KotlinNativeTargetPreset&gt;().forEach {
        targetFromPreset(it) { 
            /* Configure each of the created targets */
        }
    }
}
```

I found this in the documentation at:
<https://kotlinlang.org/docs/reference/building-mpp-with-gradle.html#setting-up-targets>

so it looks like the code you posted should work the way you expect

Then followed with:
``` 
targets.all {
  compilations["main"].defaultSourceSet { /* ... */ }
}
```
That would then provide access to all “main” portions of each target and allow you to add a dependency