A modern programming language that makes developers happier.

kotlinlang

Are the JetBrains compiler and runtime now versioned independently? I see dev764 of the runtime (also on the GitHub releases) but only 755 of the compiler.

The release notes say it's based on 1.2.1

Looks like it's <https://github.com/JetBrains/compose-jb/blob/33237b662e8ff6bcc89b9c750e618e2b1665cd15/gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/ComposeCompilerKotlinSupportPlugin.kt#L25|hard coded> in the gradle plugin to the value in <https://github.com/JetBrains/compose-jb/blob/33237b662e8ff6bcc89b9c750e618e2b1665cd15/gradle-plugins/gradle.properties#L11|the property>

Yes, Compiler will be released independently and stable versions will be released faster. That is because Google also switched Compiler to a separate release cycle.

We don’t do automatic dev builds for compiler now, only manual ones, which are built directly from stable commit of Google’s compiler.

We are also experimenting with approach, when we don’t build our compiler at all, and just use compiler published by Google.

Will this cause any issue?

Nope. Just eager to use the new iOS simulator target in the runtime so we can stop building our own runtime!

oh no it didn't make it in time for the release. looking forward to the next one then!

&gt; We are also experimenting with approach, when we don’t build our compiler at all, and just use compiler published by Google.
Yes, please! I would love to switch back to that as well. I advocated for them to ship a non-relocated copy back when native needed it but they never did. Now that we only need a relocated version as long as you all are still upstreaming native and JS fixes I would greatly prefer to stick to theirs.

<@U0BFDUP0E> This seems to work well for me with JetBrains' Compose Gradle plugin and Google's Compose compiler plugin:

`gradle.propreties`:
```kotlinVersion=1.7.10
serializationVersion=1.4.0
coroutinesVersion=1.6.4
ktorVersion=2.1.0

composeCompilerVersion=1.3.0
composeVersion=1.2.0-alpha01-dev755```
`settings.gradle.kts`:
```pluginManagement {
    // ...

    plugins {
        kotlin("multiplatform") version kotlinVersion
        kotlin("plugin.serialization") version kotlinVersion
        id("org.jetbrains.compose") version composeVersion
    }
}```
Root `build.gradle.kts`:
```// ...

plugins {
    kotlin("multiplatform") apply false
    kotlin("plugin.serialization") apply false
    id("org.jetbrains.compose") apply false
}

allprojects {
    configurations.all {
        resolutionStrategy.dependencySubstitution {
            substitute(module("org.jetbrains.compose.compiler:compiler")).apply {
                using(module("androidx.compose.compiler:compiler:$composeCompilerVersion"))
            }
        }
    }
}```
Child module with Compose's `build.gradle.kts`:
```plugins {
    kotlin("multiplatform")
    id("org.jetbrains.compose")
}

// Usual kotlin {} and compose {} configuration
// ...```
Platform: Gradle 7.5.1 / OpenJDK 17.0.4 / Fedora 36 (Gnome+Wayland+Pipewire) / GNU/Linux 5.18.18-200.fc36.x86_64

Yeah we already have a project working. We switched from Google's compiler to JetBrains' because it had essential fixes for native and JS targets that weren't upstream yet a few months ago.

Now that Kotlin 1.7 drops the need for a hosted version of compiler plugins and since JB upstreamed their fixes it's probably safe to switch back.

And as soon as the next runtime release is out we can stop building our own runtime for iOS.

Sorry, I think I was out of subject. :stuck_out_tongue: (I had difficulties gathering all the ingredients from the different threads.)