A modern programming language that makes developers happier.

kotlinlang

is there a coroutines implementation for general JVM apps, e.g. a desktop application?

Yes but for specific GUI frameworks. JavaFX, Swing, etc.

i am using coroutines for server things... did not expect UI to be involved

Then why are you using `Dispatchers.Main`?

You should be using `Dispatchers.Default`, `<http://Dispatchers.IO|Dispatchers.IO>` and custom dispatchers if you see fit.

If your app starting point is the `main` function, you can just start it that way:
```
suspend fun main(): Unit = coroutineScope {
    // app starts here, launch coroutines and all
}
```

Might as well just use `runBlocking`, right?

`suspend fun main` uses `Dispatchers.Default` in its `coroutineContext`, which is multi-threaded (at least 2 threads, configured for number of CPU cores), while `runBlocking` reuses the JVM *single* initial thread.

Reuse appeals to me. Also this can be done.
```
fun main() = runBlocking(Dispatchers.Default) {
    // stuff
}
```

Although, that doesn't look much better that your initial example. So :shrug::skin-tone-3: I guess.

<@U2E974ELT> Does `suspend fun main` inject/reuse the JVM initial thread into `Dispatchers.Default`? If not, is it possible without major drawbacks?

The major drawback is that UI apps might also have suspend fun main

<@U3ZLHBTLG> suspend fun main can't use Dispatchers.Default because that's kotlinx

Although it will default to that dispatcher in kotlinx because context contains no dispatcher

It'd be nice to have it configurable then.

<@UCPH15U5U> I remember reading it checking if kotlinx.coroutines is in the classpath.

I take that back, I'm pretty sure it's single thread event loop

That would be pretty poor design honestly

I know `suspend fun main` does result in a multi-threaded coroutineContext regardless.