Using Maven

    Define the version of Kotlin you want to use via a kotlin.version property:

    Dependencies

    Kotlin has an extensive standard library that can be used in your applications. Configure the following dependency in the pom file:

    2.     <dependency>
    3.         <groupId>org.jetbrains.kotlin</groupId>
    4.         <artifactId>kotlin-stdlib</artifactId>
    5.         <version>${kotlin.version}</version>
    6.     </dependency>
    7. </dependencies>

    If you’re targeting JDK 7 or JDK 8, you can use extended versions of the Kotlin standard library which contain additional extension functions for APIs added in new JDK versions. Instead of kotlin-stdlib, use kotlin-stdlib-jdk7 or kotlin-stdlib-jdk8, depending on your JDK version (for Kotlin 1.1.x use kotlin-stdlib-jre7 and kotlin-stdlib-jre8 as the jdk counterparts were introduced in 1.2.0).

    If your project uses or testing facilities, you need to add the corresponding dependencies as well. The artifact IDs are kotlin-reflect for the reflection library, and kotlin-test and kotlin-test-junit for the testing libraries.

    Compiling Kotlin only source code

    To compile source code, specify the source directories in the tag:

    1. <build>
    2.     <sourceDirectory>${project.basedir}/src/main/kotlin</sourceDirectory>
    3.     <testSourceDirectory>${project.basedir}/src/test/kotlin</testSourceDirectory>
    4. </build>

    Compiling Kotlin and Java sources

    To compile mixed code applications Kotlin compiler should be invoked before Java compiler. In maven terms that means that kotlin-maven-plugin should run before maven-compiler-plugin using the following method. Make sure that the kotlin plugin comes before the maven-compiler-plugin in your pom.xml file:

    1. <build>
    2.     <plugins>
    3.         <plugin>
    4.             <groupId>org.jetbrains.kotlin</groupId>
    5.             <artifactId>kotlin-maven-plugin</artifactId>
    6.             <version>${kotlin.version}</version>
    7.             <executions>
    8.                 <execution>
    9.                     <id>compile</id>
    10.                     <goals>
    11.                         <goal>compile</goal>
    12.                     </goals>
    13.                     <configuration>
    14.                         <sourceDirs>
    15.                             <sourceDir>${project.basedir}/src/main/java</sourceDir>
    16.                         </sourceDirs>
    17.                     </configuration>
    18.                 </execution>
    19.                 <execution>
    20.                     <id>test-compile</id>
    21.                     <goals> <goal>test-compile</goal> </goals>
    22.                     <configuration>
    23.                         <sourceDirs>
    24.                             <sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
    26.                         </sourceDirs>
    27.                     </configuration>
    28.                 </execution>
    29.             </executions>
    30.         </plugin>
    31.         <plugin>
    32.             <groupId>org.apache.maven.plugins</groupId>
    33.             <artifactId>maven-compiler-plugin</artifactId>
    34.             <version>3.5.1</version>
    35.             <executions>
    36.                 <!-- Replacing default-compile as it is treated specially by maven -->
    37.                 <execution>
    38.                     <id>default-compile</id>
    39.                     <phase>none</phase>
    40.                 </execution>
    41.                 <!-- Replacing default-testCompile as it is treated specially by maven -->
    42.                 <execution>
    43.                     <id>default-testCompile</id>
    44.                     <phase>none</phase>
    45.                 </execution>
    46.                 <execution>
    47.                     <id>java-compile</id>
    48.                     <phase>compile</phase>
    49.                     <goals>
    50.                         <goal>compile</goal>
    51.                     </goals>
    52.                 </execution>
    53.                 <execution>
    54.                     <id>java-test-compile</id>
    55.                     <goals>
    56.                         <goal>testCompile</goal>
    57.                     </goals>
    58.                     <configuration>
    59.                         <skip>${maven.test.skip}</skip>
    60.                     </configuration>
    61.                 </execution>
    62.             </executions>
    63.         </plugin>
    64.     </plugins>
    65. </build>

    To make your builds faster, you can enable incremental compilation for Maven (supported since Kotlin 1.1.2). In order to do that, define the kotlin.compiler.incremental property:

    1. <properties>
    2.     <kotlin.compiler.incremental>true</kotlin.compiler.incremental>
    3. </properties>

    Alternatively, run your build with the -Dkotlin.compiler.incremental=true option.

    Annotation processing

    See the description of (kapt).

    Jar file

    To create a small Jar file containing just the code from your module, include the following under build->plugins in your Maven pom.xml file, where main.class is defined as a property and points to the main Kotlin or Java class:

    Self-contained Jar file

    1. <plugin>
    2.     <groupId>org.apache.maven.plugins</groupId>
    3.     <artifactId>maven-assembly-plugin</artifactId>
    4.     <version>2.6</version>
    5.     <executions>
    6.         <execution>
    7.             <id>make-assembly</id>
    8.             <phase>package</phase>
    9.             <goals> <goal>single</goal> </goals>
    10.             <configuration>
    11.                 <archive>
    12.                     <manifest>
    13.                         <mainClass>${main.class}</mainClass>
    14.                     </manifest>
    15.                 </archive>
    16.                 <descriptorRefs>
    17.                     <descriptorRef>jar-with-dependencies</descriptorRef>
    18.                 </descriptorRefs>
    19.             </configuration>
    20.         </execution>
    21.     </executions>
    22. </plugin>

    This self-contained jar file can be passed directly to a JRE to run your application:

    1. java -jar target/mymodule-0.0.1-SNAPSHOT-jar-with-dependencies.jar

    Additional options and arguments for the compiler can be specified as tags under the <configuration> element of the Maven plugin node:

    Many of the options can also be configured through properties:

    1. <project ...>
    2.     <properties>
    3.         <kotlin.compiler.languageVersion>1.0</kotlin.compiler.languageVersion>
    4. </project>

    The following attributes are supported:

    Generating documentation

    The standard JavaDoc generation plugin () does not support Kotlin code. To generate documentation for Kotlin projects, use ; please refer to the Dokka README for configuration instructions. Dokka supports mixed-language projects and can generate output in multiple formats, including standard JavaDoc.

    OSGi

    Examples

    An example Maven project can be