diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinMultiplatformExtension.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinMultiplatformExtension.kt
index 7ccff51..f9e8e9e 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinMultiplatformExtension.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/dsl/KotlinMultiplatformExtension.kt
@@ -25,10 +25,10 @@
     override val presets: NamedDomainObjectCollection<KotlinTargetPreset<*>> = project.container(KotlinTargetPreset::class.java)
 
     final override val targets: NamedDomainObjectCollection<KotlinTarget> = project.container(KotlinTarget::class.java)
+    internal val targetsState = project.suspendableProperty(targets)
 
     internal suspend fun awaitTargets(): NamedDomainObjectCollection<KotlinTarget> {
-        AfterFinaliseDsl.await()
-        return targets
+        return targetsState.awaitFinalValue()
     }
 
     override val compilerTypeFromProperties: KotlinJsCompilerType? = project.kotlinPropertiesProvider.jsCompiler
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ConsistentAfterEvaluate.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ConsistentAfterEvaluate.kt
new file mode 100644
index 0000000..b1a70ed
--- /dev/null
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/ConsistentAfterEvaluate.kt
@@ -0,0 +1,150 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.gradle.plugin
+
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.completeWith
+import org.gradle.api.Project
+import org.gradle.api.provider.Provider
+import org.jetbrains.kotlin.gradle.utils.getOrPut
+import kotlin.coroutines.*
+
+internal class SuspendableExecutor {
+    private val supervisorJob = SupervisorJob()
+    private val lateEvaluations = mutableListOf<suspend () -> Unit>()
+    fun runNow(block: suspend () -> Unit) {
+        val job = Job(supervisorJob)
+        val continuation = Continuation<Unit>(job) { it.getOrThrow(); job.complete() }
+        block.startCoroutine(continuation)
+    }
+
+    fun runLater(block: suspend () -> Unit) {
+        lateEvaluations += block
+    }
+
+    fun runDeferredEvaluations() {
+        try {
+            while (lateEvaluations.isNotEmpty()) {
+                val code = lateEvaluations.removeFirst()
+                runNow { code() }
+            }
+            supervisorJob.complete()
+        } catch (e: Throwable) {
+            supervisorJob.completeExceptionally(e)
+        }
+
+        check(supervisorJob.children.all { it.isCompleted }) {
+            "Following children are not completed: ${supervisorJob.children.filter { it.isActive }.toList()}"
+        }
+    }
+}
+
+internal interface SuspendableState<T> {
+    fun getFinalValueOrThrow(): T
+    suspend fun awaitFinalValue(): T
+}
+
+private class SuspendableStateImpl<T> : SuspendableState<T> {
+    private val deferred = CompletableDeferred<T>()
+    fun completeWith(result: Result<T>) {
+        deferred.completeWith(result)
+    }
+
+    override fun getFinalValueOrThrow(): T {
+        val exception = deferred.getCompletionExceptionOrNull()
+        if (exception != null) throw exception
+        return deferred.getCompleted()
+    }
+
+    override suspend fun awaitFinalValue(): T = deferred.await()
+}
+
+private fun <T> SuspendableExecutor.evaluate(code: suspend () -> T): SuspendableState<T> {
+    val provider = SuspendableStateImpl<T>()
+    runNow { provider.completeWith(runCatching { code() }) }
+    return provider
+}
+
+internal interface SuspendableMutableState<T> : SuspendableState<T> {
+    fun updateWith(code: suspend (currentValue: T) -> T)
+}
+
+private fun <T> SuspendableExecutor.mutableState(initialValue: T): SuspendableMutableState<T> {
+    val property = SuspendableMutableStateImpl(initialValue)
+    runLater { property.finalizeValue() }
+    return property
+}
+
+private class SuspendableMutableStateImpl<T>(
+    private val initialValue: T,
+    private val state: SuspendableStateImpl<T> = SuspendableStateImpl()
+): SuspendableMutableState<T> {
+    private val mutations: MutableList<suspend (T) -> T> = mutableListOf()
+
+    suspend fun finalizeValue() {
+        val finalResult = runCatching {
+            mutations.fold(initialValue) { currentValue, mutation -> mutation(currentValue) }
+        }
+        state.completeWith(finalResult)
+    }
+
+    override fun updateWith(code: suspend (currentValue: T) -> T) {
+        mutations += code
+    }
+
+    override suspend fun awaitFinalValue(): T = state.awaitFinalValue()
+
+    override fun getFinalValueOrThrow(): T = state.getFinalValueOrThrow()
+}
+
+private val Project.suspendableExecutor get() =
+    extraProperties.getOrPut(SuspendableExecutor::class.java.name) {
+        SuspendableExecutor()
+    }
+
+internal fun <T> Project.provider(code: suspend () -> T): Provider<T> {
+    val suspendableState = suspendableExecutor.evaluate(code)
+    return provider { suspendableState.getFinalValueOrThrow() }
+}
+
+internal fun <T> Project.suspendableProperty(initialValue: T): SuspendableMutableState<T> {
+    val suspendableState = suspendableExecutor.mutableState(initialValue)
+    return suspendableState
+}
+
+internal class SuspendableWrappers(
+    private val executor: SuspendableExecutor
+) {
+    private val entities = mutableMapOf<Any, WrappedEntity<*>>()
+    class WrappedEntity<T: Any> (
+        val state: SuspendableMutableState<T>,
+        val entity: T
+    )
+
+    fun <T: Any> getOrWrap(entity: T): WrappedEntity<T> {
+        @Suppress("UNCHECKED_CAST")
+        return entities.getOrPut(entity) {
+            val state = executor.mutableState(entity)
+            WrappedEntity(state, entity)
+        } as WrappedEntity<T>
+    }
+}
+
+fun main() {
+    val evaluator = SuspendableExecutor()
+    val p1 = evaluator.mutableState(emptyList<Int>())
+    val p2 = evaluator.mutableState(emptyList<Int>())
+    val p3 = evaluator.mutableState(emptyList<Int>())
+    val p0 = evaluator.evaluate { p1.awaitFinalValue() }
+    p1.updateWith { it + p2.awaitFinalValue() + 1 }
+    p2.updateWith { it + p3.awaitFinalValue() + 2 }
+    p3.updateWith { it + 3 }
+
+    evaluator.runDeferredEvaluations()
+    println(p0.getFinalValueOrThrow())
+}
\ No newline at end of file
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginLifecycle.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginLifecycle.kt
index d152174..13848b0 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginLifecycle.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPluginLifecycle.kt
@@ -65,9 +65,9 @@
  *
  * If the lifecycle already finished and Gradle moved to its execution phase, then the block will be invoked right away.
  */
-internal fun Project.launch(block: suspend KotlinPluginLifecycle.() -> Unit) {
-    kotlinPluginLifecycle.launch(block)
-}
+//internal fun Project.launch(block: suspend KotlinPluginLifecycle.() -> Unit) {
+//    kotlinPluginLifecycle.launch(block)
+//}
 
 /**
  * See [launch] and [launchInRequiredStage]
@@ -76,12 +76,12 @@
  * @param block Is guaranteed to be executed *not before* [stage]. However, when this function is called in a higher stage then specified
  * the [block] will still be launched.
  */
-internal fun Project.launchInStage(stage: Stage, block: suspend KotlinPluginLifecycle.() -> Unit) {
-    launch {
-        await(stage)
-        block()
-    }
-}
+//internal fun Project.launchInStage(stage: Stage, block: suspend KotlinPluginLifecycle.() -> Unit) {
+//    launch {
+//        await(stage)
+//        block()
+//    }
+//}
 
 /**
  * See also [launch]
@@ -98,13 +98,13 @@
  * }
  * ```
  */
-internal fun Project.launchInRequiredStage(stage: Stage, block: suspend KotlinPluginLifecycle.() -> Unit) {
-    launchInStage(stage) {
-        requiredStage(stage) {
-            block()
-        }
-    }
-}
+//internal fun Project.launchInRequiredStage(stage: Stage, block: suspend KotlinPluginLifecycle.() -> Unit) {
+//    launchInStage(stage) {
+//        requiredStage(stage) {
+//            block()
+//        }
+//    }
+//}
 
 /**
  * Universal way of retrieving the current lifecycle
@@ -118,9 +118,9 @@
 /**
  * Will start the lifecycle, this shall be called before the [kotlinPluginLifecycle] is effectively used
  */
-internal fun Project.startKotlinPluginLifecycle() {
-    (kotlinPluginLifecycle as KotlinPluginLifecycleImpl).start()
-}
+//internal fun Project.startKotlinPluginLifecycle() {
+//    (kotlinPluginLifecycle as KotlinPluginLifecycleImpl).start()
+//}
 
 /**
  * Similar to [currentCoroutineContext]: Returns the current [KotlinPluginLifecycle] instance used to launch
@@ -135,9 +135,9 @@
  * Suspends execution until we *at least* reached the specified [this@await]
  * This will return right away if the specified [this@await] was already executed or we are currently executing the [this@await]
  */
-internal suspend fun Stage.await() {
-    currentKotlinPluginLifecycle().await(this)
-}
+//internal suspend fun Stage.await() {
+//    currentKotlinPluginLifecycle().await(this)
+//}
 
 /**
  * See [LifecycleAwareProperty]
@@ -154,18 +154,18 @@
  * }
  * ```
  */
-internal inline fun <reified T : Any> Project.newKotlinPluginLifecycleAwareProperty(
-    finaliseIn: Stage = Stage.FinaliseDsl, initialValue: T? = null
-): LifecycleAwareProperty<T> {
-    return kotlinPluginLifecycle.newLifecycleAwareProperty(T::class.java, finaliseIn, initialValue)
-}
+//internal inline fun <reified T : Any> Project.newKotlinPluginLifecycleAwareProperty(
+//    finaliseIn: Stage = Stage.FinaliseDsl, initialValue: T? = null
+//): LifecycleAwareProperty<T> {
+//    return kotlinPluginLifecycle.newLifecycleAwareProperty(T::class.java, finaliseIn, initialValue)
+//}
 
 /**
  * Will return the [LifecycleAwareProperty] instance if the given receiver was created by [newKotlinPluginLifecycleAwareProperty]
  */
-internal suspend fun <T : Any> Property<T>.findKotlinPluginLifecycleAwareProperty(): LifecycleAwareProperty<T>? {
-    return (currentKotlinPluginLifecycle() as KotlinPluginLifecycleImpl).findLifecycleAwareProperty(this)
-}
+//internal suspend fun <T : Any> Property<T>.findKotlinPluginLifecycleAwareProperty(): LifecycleAwareProperty<T>? {
+//    return (currentKotlinPluginLifecycle() as KotlinPluginLifecycleImpl).findLifecycleAwareProperty(this)
+//}
 
 /**
  * Will suspend until the property finalises its value and therefore a final value can returned.
@@ -175,32 +175,32 @@
  * If a property was not created using 'newKotlinPluginLifecycleAwareProperty' then the execution
  * will suspend until 'FinaliseDsl' and calls [Property.finalizeValue] before returnign the actual value
  */
-internal suspend fun <T : Any> Property<T>.awaitFinalValue(): T? {
-    val lifecycleAwareProperty = findKotlinPluginLifecycleAwareProperty()
-    if (lifecycleAwareProperty != null) {
-        return lifecycleAwareProperty.awaitFinalValue()
-    }
-
-    Stage.FinaliseDsl.await()
-    finalizeValue()
-    return orNull
-}
+//internal suspend fun <T : Any> Property<T>.awaitFinalValue(): T? {
+//    val lifecycleAwareProperty = findKotlinPluginLifecycleAwareProperty()
+//    if (lifecycleAwareProperty != null) {
+//        return lifecycleAwareProperty.awaitFinalValue()
+//    }
+//
+//    Stage.FinaliseDsl.await()
+//    finalizeValue()
+//    return orNull
+//}
 
 /**
  * @return true if this property has an associated [LifecycleAwareProperty]
  */
-internal suspend fun Property<*>.isKotlinPluginLifecycleAware(): Boolean {
-    return findKotlinPluginLifecycleAwareProperty() != null
-}
+//internal suspend fun Property<*>.isKotlinPluginLifecycleAware(): Boolean {
+//    return findKotlinPluginLifecycleAwareProperty() != null
+//}
 
 /**
  * See also [withRestrictedStages]
  *
  * Will ensure that the given [block] can only execute in the given [stage]
  */
-internal suspend fun <T> requiredStage(stage: Stage, block: suspend () -> T): T {
-    return withRestrictedStages(hashSetOf(stage), block)
-}
+//internal suspend fun <T> requiredStage(stage: Stage, block: suspend () -> T): T {
+//    return withRestrictedStages(hashSetOf(stage), block)
+//}
 
 /**
  * See also [withRestrictedStages]
@@ -216,9 +216,9 @@
  * }
  * ```
  */
-internal suspend fun <T> requireCurrentStage(block: suspend () -> T): T {
-    return requiredStage(currentKotlinPluginLifecycle().stage, block)
-}
+//internal suspend fun <T> requireCurrentStage(block: suspend () -> T): T {
+//    return requiredStage(currentKotlinPluginLifecycle().stage, block)
+//}
 
 /**
  * Will ensure that the given [block] cannot leave the specified allowed stages [allowed]
@@ -233,11 +233,11 @@
  * }
  * ```
  */
-internal suspend fun <T> withRestrictedStages(allowed: Set<Stage>, block: suspend () -> T): T {
-    return withContext(RestrictedLifecycleStages(currentKotlinPluginLifecycle(), allowed)) {
-        block()
-    }
-}
+//internal suspend fun <T> withRestrictedStages(allowed: Set<Stage>, block: suspend () -> T): T {
+//    return withContext(RestrictedLifecycleStages(currentKotlinPluginLifecycle(), allowed)) {
+//        block()
+//    }
+//}
 
 /*
 Definition of the Lifecycle and its stages
@@ -476,7 +476,7 @@
     ) : LifecycleAwareProperty<T> {
 
         override suspend fun awaitFinalValue(): T? {
-            finaliseIn.await()
+            //finaliseIn.await()
             return property.orNull
         }
     }
diff --git a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/NativeCompilerDownloader.kt b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/NativeCompilerDownloader.kt
index 9329a46..614b43d 100644
--- a/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/NativeCompilerDownloader.kt
+++ b/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/NativeCompilerDownloader.kt
@@ -6,9 +6,12 @@
 @file:Suppress("PackageDirectoryMismatch") // Old package for compatibility
 package org.jetbrains.kotlin.gradle.utils
 
+import org.gradle.api.InvalidUserCodeException
 import org.gradle.api.Project
 import org.gradle.api.artifacts.repositories.ArtifactRepository
 import org.gradle.api.file.FileTree
+import org.gradle.api.initialization.resolve.RepositoriesMode
+import org.gradle.api.internal.GradleInternal
 import org.gradle.api.logging.Logger
 import org.jetbrains.kotlin.compilerRunner.KotlinNativeToolRunner
 import org.jetbrains.kotlin.compilerRunner.konanHome
@@ -87,14 +90,19 @@
         }
 
     private fun setupRepo(repoUrl: String): ArtifactRepository {
-        return project.repositories.ivy { repo ->
-            repo.setUrl(repoUrl)
-            repo.patternLayout {
-                it.artifact("[artifact]-[revision].[ext]")
+        try {
+            return project.repositories.ivy { repo ->
+                repo.setUrl(repoUrl)
+                repo.patternLayout {
+                    it.artifact("[artifact]-[revision].[ext]")
+                }
+                repo.metadataSources {
+                    it.artifact()
+                }
             }
-            repo.metadataSources {
-                it.artifact()
-            }
+        } catch (e: InvalidUserCodeException) {
+            logger.error("e: Can't add Kotlin Native Distribution repository. Please add it yourself, default repository url: '$repoUrl'")
+            throw e
         }
     }