Has anyone measured the compilation time of compose? I’m curious because I know compose uses a different version of the Kotlin compiler or something or other. I’m not exactly sure how it works, so I’m curious if there are any problems with it in terms of scaling compose in large projects.

It uses the stock compiler, but with the new, experimental IR backend (which you can turn on via a flag). It also uses a compiler plugin. The compiler plugin is known to add some lag, since it’s doing more work, but probably not a significant amount. The IR backend should be comparable to the current backend, because it will soon become the default, and it will probably end up getting faster as it’s optimized in the future.

It's also hard to imagine such benchmark, because what would be a baseline?

I imagine you’d have to build the same complex UI in both classic views and Compose and try to benchmark the compilation? But that code would be so different, there’d be a million variables you couldn’t control for

Yes, this is my point, it would be always comparing apples to oranges I would like to see how much compose compiler adds to compilation in absolute numbers, but it requires someone to build a relatively big application and measure impact of compiler plugin (if it even possible to measure) Also would be interesting to see how incremental compilation works with compose

@Patrick Yin has done some basic comparisons with (i think) a toy app that uses android views and a similar one in compose, and the compile time only changed a second on a 23-second build time. I’m not sure how many samples he used, but i’m not too worried

So that was my worry actually. The IR backend isn’t even incremental yet, is it?

I don’t think so. Where did you get this information?

the IR Compiler is the compiler that’s shared between jvm, js, and native, right? I thought jvm ir compiler was pretty new. I know that native and js (ir) aren’t incremental. I guess I assumed jvm (ir) wasn’t as well.

JS IR is definitely incremental

During the Kotlin 1.4 RC, I asked about slow compilation in the javascript channel, as the IR compiler was noticeably slower than the legacy, and got this response. I didn’t remember it exactly right, but you see where I got the idea from I suppose - https://kotlinlang.slack.com/archives/C0B8L3U69/p1595408441069000?thread_ts=1595361872.066300&cid=C0B8L3U69

it may be not completely ready, but it doesn’t mean that there is no incremental compilation