Skip to main content
Development builds allow you to test the latest changes in Compose Hot Reload before they’re included in stable releases. This is useful for trying new features, testing bug fixes, or helping the team validate changes.

​
What are Development Builds?

Development builds (also called “dev builds”) are published from the main development branch and contain the latest code changes. Unlike stable releases, dev builds:
  • Are published automatically from the development branch
  • May contain unreleased features and experimental changes
  • Are not subject to the same level of testing as stable releases
  • Have version numbers that differ from official releases
  • Are hosted on a separate Maven repository
Development builds are intended for testing and experimentation. They may contain bugs or breaking changes. Do not use dev builds in production applications.

​
Adding the Firework Repository

To use development builds, add the firework Maven repository to your project’s settings.gradle.kts file:
settings.gradle.kts
pluginManagement {
    repositories {
        maven("https://packages.jetbrains.team/maven/p/firework/dev")
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}

dependencyResolutionManagement {
    repositories {
        maven("https://packages.jetbrains.team/maven/p/firework/dev")
        google()
        mavenCentral()
    }
}
Add the firework repository before other repositories to ensure dev builds are prioritized when available.

​
Using Development Builds

Once you’ve added the firework repository, you can specify a dev build version in your project configuration.

​
In Version Catalog

Update your gradle/libs.versions.toml to use a dev build version:
gradle/libs.versions.toml
[versions]
composeHotReload = "<dev-version>"

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

​
Direct Plugin Declaration

Or specify the version directly in your build.gradle.kts:
build.gradle.kts
plugins {
    id("org.jetbrains.compose.hot-reload") version "<dev-version>"
}

​
For Runtime API Dependency

If you’re using the runtime API:
build.gradle.kts
dependencies {
    implementation("org.jetbrains.compose.hot-reload:hot-reload-runtime-api:<dev-version>")
}

​
Version Numbering

Development builds follow a specific version numbering scheme: 
<major>.<minor>.<patch>-dev-<build-number>
For example:
  • 0.7.0-dev-1234
  • 0.8.0-dev-5678
  • 1.0.0-dev-9012
The build number increments with each commit to the development branch, making it easy to identify and track specific builds.

​
Finding the Latest Dev Build

To find the latest development build version:
  1. Check the Compose Hot Reload releases page
  2. Look for versions tagged with -dev-
  3. Browse the firework repository

​
Release Channels

Compose Hot Reload uses different release channels:

​
Stable Releases

  • Published to Maven Central
  • Thoroughly tested
  • Recommended for production use
  • Version format: X.Y.Z (e.g., 0.7.0, 1.0.0)
plugins {
    id("org.jetbrains.compose.hot-reload") version "0.7.0"
}

​
Development Builds

  • Published to the firework repository
  • Contain latest changes
  • For testing and experimentation
  • Version format: X.Y.Z-dev-BUILD (e.g., 0.7.0-dev-1234)
plugins {
    id("org.jetbrains.compose.hot-reload") version "0.7.0-dev-1234"
}

​
When to Use Dev Builds

​
Good Use Cases

Testing bug fixes - A fix for your issue was merged but not yet released
Trying new features - You want to experiment with features in development
Providing feedback - The team requested testing of a specific change
Contributing - You’re developing a feature or fix and need to test it

​
When to Avoid Dev Builds

Production applications - Never use dev builds in production
Stable projects - Stick to stable releases for established projects
Critical deadlines - Dev builds may introduce unexpected issues

​
Switching Between Channels

​
From Stable to Dev

  1. Add the firework repository to settings.gradle.kts
  2. Update the version to a dev build
  3. Sync Gradle
// Before
plugins {
    id("org.jetbrains.compose.hot-reload") version "0.7.0"
}

// After
plugins {
    id("org.jetbrains.compose.hot-reload") version "0.7.0-dev-1234"
}

​
From Dev to Stable

  1. Update the version to a stable release
  2. Optionally remove the firework repository
  3. Sync Gradle
// Before
plugins {
    id("org.jetbrains.compose.hot-reload") version "0.7.0-dev-1234"
}

// After
plugins {
    id("org.jetbrains.compose.hot-reload") version "0.8.0"
}

​
Reporting Issues

When using development builds and encountering issues:
  1. Note the exact version - Include the full version number (e.g., 0.7.0-dev-1234)
  2. Check if it’s fixed - Try a newer dev build if available
  3. Report the issue - Submit to the issue tracker
  4. Provide context - Mention you’re using a dev build

​
Issue Report Template

**Compose Hot Reload Version:** 0.7.0-dev-1234 (dev build)
**Kotlin Version:** 2.1.20
**Compose Version:** 1.8.2

**Description:**
Describe the issue here...

**Steps to Reproduce:**
1. Step one
2. Step two
3. ...

**Expected Behavior:**
What you expected to happen...

**Actual Behavior:**
What actually happened...

​
Complete Example

Here’s a complete example of a project configured to use dev builds:
settings.gradle.kts
pluginManagement {
    repositories {
        maven("https://packages.jetbrains.team/maven/p/firework/dev")
        google()
        mavenCentral()
        gradlePluginPortal()
    }
}

dependencyResolutionManagement {
    repositories {
        maven("https://packages.jetbrains.team/maven/p/firework/dev")
        google()
        mavenCentral()
    }
}
gradle/libs.versions.toml
[versions]
kotlin = "2.1.20"
compose = "1.8.2"
composeHotReload = "0.7.0-dev-1234"

[plugins]
kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
jetbrainsCompose = { id = "org.jetbrains.compose", version.ref = "compose" }
composeCompiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
composeHotReload = { id = "org.jetbrains.compose.hot-reload", version.ref = "composeHotReload" }
build.gradle.kts
plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.jetbrainsCompose)
    alias(libs.plugins.composeCompiler)
    alias(libs.plugins.composeHotReload)
}

kotlin {
    jvm()
    
    sourceSets {
        commonMain.dependencies {
            implementation(compose.runtime)
            implementation(compose.foundation)
            implementation(compose.material3)
            
            // Add runtime API for dev builds
            implementation("org.jetbrains.compose.hot-reload:hot-reload-runtime-api:0.7.0-dev-1234")
        }
    }
}

​
Best Practices

​
Use Version Variables

Define dev build versions in one place:
gradle/libs.versions.toml
[versions]
composeHotReload = "0.7.0-dev-1234"
This makes it easy to update across all modules.

​
Pin Specific Versions

Avoid using + or version ranges with dev builds: 
// Bad - unpredictable
implementation("org.jetbrains.compose.hot-reload:hot-reload-runtime-api:0.7.0-dev-+")

// Good - predictable
implementation("org.jetbrains.compose.hot-reload:hot-reload-runtime-api:0.7.0-dev-1234")

​
Document Dev Build Usage

Add a comment explaining why you’re using a dev build: 
// Using dev build 0.7.0-dev-1234 to test fix for issue #123
plugins {
    id("org.jetbrains.compose.hot-reload") version "0.7.0-dev-1234"
}

​
Test Before Committing

When using dev builds in a team:
  1. Test thoroughly before committing the version change
  2. Communicate with your team about the switch
  3. Document any known issues
  4. Have a rollback plan

​
Troubleshooting

​
Dev Build Not Found

If Gradle can’t find the dev build:
  1. Verify the firework repository is added to settings.gradle.kts
  2. Check the version number is correct
  3. Ensure the repository is listed before Maven Central
  4. Try refreshing Gradle dependencies
./gradlew --refresh-dependencies

​
Build Fails with Dev Version

If your build fails after switching to a dev version:
  1. Check the release notes for breaking changes
  2. Verify compatibility with your Kotlin and Compose versions
  3. Try a different dev build or revert to stable
  4. Report the issue if it persists

​
Unexpected Behavior

If you encounter unexpected behavior:
  1. Clear Gradle caches: ./gradlew clean
  2. Invalidate IDE caches (IntelliJ: File > Invalidate Caches)
  3. Try a newer or older dev build
  4. Compare with stable release behavior
  5. Report the issue with details

Build docs developers (and LLMs) love

Get started for freeTalk to us