Set repositories and dependencies in a Maven project

For your Kotlin Maven project, you can configure where Maven looks for artifacts beyond the default Maven Central repository and define the libraries your project depends on.

Declare repositories

By default, the mavenCentral repository is available for all Maven projects. To access artifacts in other repositories, specify a custom ID for the repository name and its URL in the <repositories> section:

<repositories>
    <repository>
        <id>spring-repo</id>
        <url>https://repo.spring.io/release</url>
    </repository>
</repositories>

In general, to add a dependency on a library, you should declare a new <dependency> entry in the <dependencies> section:

<dependencies>
    <dependency>
        <groupId>org.jetbrains.kotlinx</groupId>
        <artifactId>kotlinx-serialization-json</artifactId>
        <version>1.11.0</version>
    </dependency>
</dependencies>

Set dependencies

Dependency on the standard library

Kotlin has an extensive standard library that you can use in your applications. You can add the standard library dependency manually or enable the <extensions> option to set it up automatically if it's missing.

Automatic setup

You can avoid manual configuration using the <extensions> option provided by the Kotlin Maven plugin. It automatically adds the kotlin-stdlib dependency if it's not defined in the project. For example, when you create a new Kotlin Maven project or introduce Kotlin to your existing Java Maven project.

If you already declared a dependency kotlin-stdlib, for example, with a different version, the Kotlin Maven plugin with <extensions> will not overwrite it.

You can also opt out from the automatic addition of the standard library. For that, add the following to the <properties> section:

<project>
    <properties>
        <kotlin.smart.defaults.enabled>false</kotlin.smart.defaults.enabled>         
    </properties>
</project>

Manual configuration

To manually add Kotlin's standard library to your project, update the dependencies section in your pom.xml file with the following:

<dependencies>
    <dependency>
        <groupId>org.jetbrains.kotlin</groupId>
        <artifactId>kotlin-stdlib</artifactId>
        <!-- Uses kotlin.version specified in <properties/>: --> 
        <version>${kotlin.version}</version>
    </dependency>
</dependencies>

Dependencies on test libraries

If your project uses Kotlin reflection or testing frameworks, add the relevant dependencies. Use kotlin-reflect for the reflection library, and kotlin-test and kotlin-test-junit5 for testing libraries:

<dependencies>
    <dependency>
        <groupId>org.jetbrains.kotlin</groupId>
        <artifactId>kotlin-reflect</artifactId>
        <version>${kotlin.version}</version>
    </dependency>
    <dependency>
        <groupId>org.jetbrains.kotlin</groupId>
        <artifactId>kotlin-test-junit5</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Dependency on a kotlinx library

For kotlinx libraries, you can either add the base artifact name or the name with a -jvm suffix. Refer to the library's README file on klibs.io.

For example, to add a dependency on kotlinx.coroutines library:

<dependencies>
    <dependency>
        <groupId>org.jetbrains.kotlinx</groupId>
        <artifactId>kotlinx-coroutines-core</artifactId>
        <version>1.11.0</version>
    </dependency>
</dependencies>

To add a dependency on the kotlinx-datetime library:

<dependencies>
    <dependency>
        <groupId>org.jetbrains.kotlinx</groupId>
        <artifactId>kotlinx-datetime-jvm</artifactId>
        <version>0.8.0</version>
    </dependency>
</dependencies>

Manage dependencies with a BOM

A Bill of Materials (BOM) is a special POM file that manages dependency versions in your project. This keeps related artifacts aligned and avoids version conflicts.

Kotlin publishes the kotlin-bom artifact, which specifies the versions of Kotlin libraries, such as kotlin-stdlib, kotlin-reflect, and kotlin-test, that correspond to the same Kotlin release. This is useful when other libraries in your project have transitive dependencies on Kotlin artifacts because it ensures that all dependencies resolve to the same Kotlin version.

To use the Kotlin BOM, import it in the <dependencyManagement> section of your pom.xml file as follows:

<dependencyManagement>
    <dependencies>  
        <dependency>
            <groupId>org.jetbrains.kotlin</groupId>
            <artifactId>kotlin-bom</artifactId>
            <version>2.4.10</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

After importing the BOM, you can declare Kotlin dependencies in the <dependencies> section without specifying their versions; they come from the BOM file automatically.

Importing a BOM doesn't add any dependencies to your project on its own. It only controls the versions of explicitly declared and transitive dependencies.
If you still specify a <version> for a dependency, that value overrides the version from the BOM.

If your project publishes several libraries that are released together, you can provide your own BOM so that users can align the versions of those libraries in the same way. To learn how to author your own BOM, see the Maven documentation.

What's next?

Configure Kotlin compiler

07 August 2026