Set up your project

There are two ways to add Compose Hot Reload to your project:

• Create a project from scratch in IntelliJ IDEA or Android Studio
• Add it as a Gradle plugin to an existing project

Create a project from scratch

Follow the Kotlin Multiplatform quickstart guide to set up your environment and create a project. Be sure to select the desktop target when you create the project.

Apply the Gradle plugin to your project

1. In your project, update the version catalog. In gradle/libs.versions.toml, add the following code:

   composeHotReload = { id = "org.jetbrains.compose.hot-reload", version.ref = "composeHotReload"}
   

2. In the build.gradle.kts of your parent project, add the following code to your plugins {} block:

   plugins {
       alias(libs.plugins.composeHotReload) apply false
   }
   

   This prevents the Compose Hot Reload plugin from being loaded multiple times in each of your subprojects.

3. In the build.gradle.kts of the subproject containing your multiplatform application, add the following code to your plugins {} block:

   plugins { 
       alias(libs.plugins.composeHotReload)
   }
   

4. An installation of the JetBrains Runtime is required: Launching Compose Hot Reload with the Kotlin Multiplatform IDE plugin will re-use IntelliJ's installation of the JetBrains Runtime. If you want Gradle to automatically download the JetBrains Runtime, add the following code to your settings.gradle.kts file

   plugins {
       id("org.gradle.toolchains.foojay-resolver-convention") version "1.0.0"
   }
   

   Alternatively, you can use automatic JetBrains Runtime provisioning for the hot reload tasks by enabling the compose.reload.jbr.autoProvisioningEnabled property.

[!IMPORTANT]
Automatic JetBrains Runtime provisioning is an experimental feature. Please report any issues you encounter.

5. Click the Sync Gradle Changes button to synchronize Gradle files:

Use Compose Hot Reload

You can run your application with Compose Hot Reload using your IDE or the CLI via Gradle tasks. Compose Hot Reload supports two modes: Explicit mode and Auto mode.

• In Explicit mode, you manually trigger the reload to apply changes.
• In Auto mode, Compose Hot Reload uses Gradle’s file-watching and continuous build system to automatically reload when file changes are detected. To enable this mode, specify the --autoReload or --auto arguments in CLI or in the run configuration settings.

In the IDE

In IntelliJ IDEA or Android Studio, you can run Compose Hot Reload directly from the IDE gutter.

1. Click the Run icon in the gutter of your main function and select Run 'shared [jvm]' with Compose Hot Reload.

2. When you save code changes, the reload is triggered automatically.

   Alternatively, you can trigger the reload explicitly by pressing the assigned shortcut key or clicking the Reload UI button:

You can modify the trigger behavior on the Settings | Tools | Compose Hot Reload page in your IDE.

[!IMPORTANT]
If you don't have the Kotlin Multiplatform IDE plugin installed, you can manually create Gradle run configurations with hot reload tasks (see Run tasks). In this case, you can trigger the reload by clicking the Reload UI button or running the reload Gradle task.

From the CLI

Run tasks

The Compose Hot Reload plugin automatically creates the following tasks to launch the application:

• :hotRunJvm: For multiplatform projects. The async alternative is :hotRunJvmAsync.
• :hotRun: For Kotlin/JVM projects. The async alternative is :hotRunAsync.

You can run these Gradle tasks from the command line:

./gradlew :app:hotRunJvm
# or
./gradlew :composeApp:hotRunJvm

After making changes, save all files to automatically update your app's UI.

Custom target name

If you define a custom JVM target name, Gradle uses a different task name. For example, if your target name is desktop:

kotlin {
    jvm("desktop")
}

The task name is :hotRunDesktop.

Command-line arguments

Here's a list of all the possible arguments that you can use with the Gradle run tasks:

Configure the main class

You can configure the main class directly in your build script instead of passing it as a command-line argument.

You can configure it in the Compose Hot Reload task:

tasks.withType<ComposeHotRun>().configureEach {
    mainClass.set("com.example.MainKt")
}

Or if you use Compose Multiplatform, in the application {} block:

compose.desktop {
    application {
        mainClass = "com.example.MainKt"
    }
}

Reload tasks (Explicit mode)

[!WARNING]
You can't run reload tasks with the --autoReload or --auto command-line argument.

The Compose Hot Reload plugin also provides Gradle tasks to recompile and reload your application:

• reload: Reload all, currently running, applications.
• hotReloadJvmMain: Reload all applications that use the jvmMain source set.

For example:

./gradlew :app:reload

Use developer builds

If you want to try the latest changes in Compose Hot Reload, you can use dev builds. To use the latest 'dev' builds of Compose Hot Reload, add the firework Maven repository in your settings.gradle.kts file:

pluginManagement {
    repositories {
        maven("https://packages.jetbrains.team/maven/p/firework/dev")
    }
}

dependencyResolutionManagement {
    repositories {
        maven("https://packages.jetbrains.team/maven/p/firework/dev")
    }
}

MCP server for AI agents

Note: the MCP server is in experimental status and available since the 1.2.0-alpha01 version of Compose Hot Reload.

Compose Hot Reload includes a Model Context Protocol (MCP) server that allows AI agents to interact with a running Compose application. The MCP server connects to the application's orchestration layer and exposes the following tools: