I’m having this really strange issue with compose for desktop. With the following code, sometimes the Text doesn’t update:

import androidx.compose.material.Text
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.window.Window
import androidx.compose.ui.window.application
import kotlinx.coroutines.delay
import kotlinx.coroutines.isActive
import kotlin.time.Duration.Companion.seconds

fun main() = application {
    Window(onCloseRequest = ::exitApplication) {
        var counter: Int by remember { mutableStateOf(0) }
        LaunchedEffect(Unit) {
            while(isActive) {
                delay(1.seconds)
                counter++
            }
        }
        Text(
            text = remember(counter) {
                counter.toString().also {
                    println("counter: $it")
                }
            },
        )
    }
}

Here’s a video to demonstrate what I mean. It will occasionally not update.

org.jetbrains.compose

version is 1.4.0

Not sure if the issue, but why having remember on counter inside Text? Its already remembered earlier in same composable?

I put the extra remember to print out

Could also try increment counter after its printed :)

it still happens occasionally with this:

fun main() = application {
    Window(onCloseRequest = ::exitApplication) {
        var counter: Int by remember { mutableStateOf(0) }
        LaunchedEffect(Unit) {
            while (isActive) {
                delay(1.seconds)
                counter++
                println(counter)
            }
        }
        Text(
            text = counter.toString(),
        )
    }
}

And if doing println, counter++ and last delay in each loop? Feels like delay clock cycle different in desktop then causing compose skip frames as not fast enough, or cancels rendering as value changes before rendered

println, counter++, delay has the same effect

Then not sure, I guess coroutines in desktop causing other context switching compared.

Here is a slightly less trivial example that exhibits the same behaviour:

import androidx.compose.material.Text
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.ui.window.Window
import androidx.compose.ui.window.application
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.isActive
import kotlin.coroutines.coroutineContext
import kotlin.time.Duration.Companion.seconds

fun main() {
    val counterViewModel = CounterViewModel()
    application {
        Window(onCloseRequest = ::exitApplication) {
            val counter: String by counterViewModel.counter.collectAsState()
            Text(text = counter)
        }
    }
}

class CounterViewModel {
    val counter: StateFlow<String> = flow {
        var counter = 0
        while (coroutineContext.isActive) {
            emit(counter.toString())
            delay(1.seconds)
            counter++
        }
    }.stateIn(
        scope = GlobalScope,
        started = SharingStarted.WhileSubscribed(
            stopTimeoutMillis = 0,
            replayExpirationMillis = 0
        ),
        initialValue = "",
    )
}

It’s probably this: https://github.com/JetBrains/compose-multiplatform/issues/3137

Thank you 😄

We’ll be releasing the next 1.4 update soon with the fix.

Great to hear! I was losing my mind over this for a day 😂

That’s nothing. I was losing my mind over it for a year.

your effort is greatly appreciated 😅