@ilya.chernikov I would expect that making incremental compilation possible by an external took (Gradle) was already more effort than doing it internally so I'm a bit confused

Well, as it usually happens, the implementation was pulled by some urgent demands at places where people are used to the incremental compilation, first in IDEA and then in gradle. Ant users are not that picky yet 😉 But yes, we’re well aware of the benefits, and will do it sooner or later. But in particular for kobalt needs, if there are any, we can think about some intermediate solution.

Last time I tried to implement incremental compilation for Kobalt was pretty tough, very little documentation, had to go through the Gradle sources and eventually gave up. Is it easier to set up now?

It depends on the approach, but at least there is a single and relatively simple entry point for incremental compilation on the daemon - https://github.com/JetBrains/kotlin/blob/1.1.0/compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/CompileService.kt#L135 And you may check usages here - https://github.com/JetBrains/kotlin/blob/1.1.0/jps-plugin/src/org/jetbrains/kotlin/compilerRunner/JpsKotlinCompilerRunner.kt#L124 and here - https://github.com/JetBrains/kotlin/blob/1.1.0/libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleKotlinCompilerRunner.kt#L202 or use a bit simplified wrapper from here - https://github.com/JetBrains/kotlin/blob/1.1.0/compiler/daemon/daemon-client/src/org/jetbrains/kotlin/daemon/client/KotlinCompilerClient.kt#L147

IC in the compiler is half-done. It can be used without daemon through more or less simple API, but it is not polished yet: 1. It does not handle changes in compile-classpath (it should at least perform full rebuild in this case). 2. API can be changed slighly. 3. No CLI support. 4. No multi-module IC. The API can be used starting from 1.1, it requires kotlin-compiler-embeddable.jar. The API entry point is here https://github.com/JetBrains/kotlin/blob/master/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt#L45 It can be used as so:

// Trivial imports are omitted 
import org.jetbrains.kotlin.incremental.makeIncrementally

// This dir will be used for as IC caches' root,
// so it should persist between builds; 
// Removing this dir forces rebuild
val chachesDir = File("build/ic-caches")

// Iterable of Java and Kotlin source roots
val sourceRoots = listOf(File("src/kotlin"), File("src/java"))

val args = K2JVMCompilerArguments()
// Output dir
args.destination = "build/classes"
args.moduleName = "someModule"
// Compile-classpath
args.classpath = compileClasspath
// Some other collector should probably be used
val messageCollector = MessageCollector.NONE

makeIncrementally(cachesDir, sourceRoots, args, messageCollector)

That should handle all cases our Gradle IC handles except classpath changes and multi-module IC. The underlying implementation is the same and the same tests are used.