JetBrains Research Open-Sources KotlinLLM. KotlinLLM is an IntelliJ IDEA plugin for Kotlin/JVM projects that adds a language feature called Smart macros. A Smart macro is a regular Kotlin function call whose body is generated Kotlin code. The public API is deliberately small. asLlm<F, T>(from, hint) converts an input of type F into a typed value T, such as a data class, enum, list, or primitive. mockLlm<T>() generates a stateful implementation of an interface T, whose behavior depends on which methods are called on it.

val issuesApiUrl: String = asLlm(repoInput, hint = "GitHub API URL: get all issues, including closed")
val issues: List<Issue> = asLlm(response, hint = "Return all beginner-friendly issues for this repository")

The runtime loop

When a project launches through the KotlinLLM run configuration, the plugin scans for asLlm and mockLlm calls, updates generated bootstrap/provider/parser/mock files, launches the run configuration under JDI, and registers breakpoints on generated regenerate hooks. If generated logic does not match a runtime scenario, execution reaches a hook. The plugin captures runtime values and type information from the suspended frame, the LLM agent submits a code update, and the plugin compiles it and redefines the loaded class before retrying the original call.

KotlinLLM targets Kotlin/JVM specifically because the runtime evolution loop depends on JVM class redefinition through JDI.

Explainer: how a Smart macro evolves

The embed below walks the macro API, animates the nine-step runtime loop, and models why covered scenarios stop costing inference calls.

Reported results

On an adapted Spring Petclinic Kotlin project with 18 asLlm call sites, 24 of 24 application scenarios completed after Smart macro evolution, with a 100% hot-reload success rate and compilation/redefinition adding roughly 1% of total runtime overhead. A synthetic “GitHub Beginner Issue Radar” parsed real issue data across 20 repositories and 30k+ issues, reaching about 0.89 recall on ground-truth beginner labels.

Setup requirements

The plugin requires IntelliJ IDEA 2025.2.x, JDK 21, and an OpenAI API key stored in the target project’s .kotlinllm file via Tools > KotlinLLM Settings. It is released under the Apache License 2.0, with runnable examples, the thesis write-up, and the KotlinConf 2026 talk recording in the repository.

Is it deployable?

Not as a production runtime, at least not yet. JetBrains labels KotlinLLM a research prototype, and it is described it as an experimental IntelliJ IDEA plugin. The plugin is experimental, but its output is deployable. Once behavior has been generated, the target project can compile and run that behavior without another LLM request for the same scenario. You ship plain Kotlin, not a model dependency.

• Company level: best fit today is R&D groups, platform teams at mid-size to large Kotlin/JVM entities, and startups with tolerance for prototype tooling. Regulated enterprises should treat generated sources as reviewable code, which is exactly how KotlinLLM stores them.
• Industries: fintech and banking (heavy JVM/Kotlin estates), developer tooling, e-commerce, logistics, and any team parsing messy third-party API payloads.
• Applications: normalizing semi-structured API responses into typed values, building evolving test doubles, adapting to upstream schema drift, and classification over noisy text fields.

Key Takeaways

• KotlinLLM is a JetBrains Research prototype, not a production runtime.
• Smart macros generate Kotlin source that is committed, reviewed, and run without the plugin.
• Covered scenarios trigger no further LLM call, so no added latency or cost.
• Petclinic evaluation: 24/24 scenarios, 100% hot-reload, ~1% overhead.
• Apache 2.0, Kotlin/JVM only, IntelliJ IDEA 2025.2.x plus JDK 21.

---

Sources: JetBrains Research blog, the kotlinllm-plugin README, and InfoWorld