Dokka is JetBrains' open-source API documentation engine for Kotlin, the tool that turns KDoc and Javadoc comments into publishable HTML and Markdown API reference sites for Kotlin, Java, and mixed-language codebases.

What it is

Dokka is an API documentation engine for Kotlin, maintained by JetBrains as an official project and distributed under the Apache-2.0 licence. Just like Kotlin itself, it supports mixed-language projects: it understands Kotlin's KDoc comments and Java's Javadoc comments, so a codebase that mixes both languages produces one coherent reference instead of two disconnected ones. Output is available in several formats, including Dokka's own modern HTML format, multiple flavors of Markdown, and Java's Javadoc HTML. The engine is highly pluggable, and the comprehensive documentation lives on kotlinlang.org rather than in the repository alone.

The concrete problem it solves is the gap between source comments and a usable reference site for Kotlin code. The specific thing it replaces is hand-maintained or Javadoc-only API documentation: Javadoc does not understand KDoc syntax, so Kotlin projects previously had to write reference docs by hand or accept output that discarded most of their comment content. Dokka reads the comments developers already write and turns them into a structured, navigable site.

Key capabilities

• Parses Kotlin KDoc and Java Javadoc comment syntax in the same build, so mixed-language modules generate unified output.
• Generates Dokka's modern HTML format, multiple flavors of Markdown, and Java-compatible Javadoc HTML.
• Applies as the Gradle plugin org.jetbrains.dokka version 2.2.0, published on Maven Central as org.jetbrains.dokka:dokka-gradle-plugin and on the Gradle Plugin Portal.
• Integrates with Maven through org.jetbrains.dokka:dokka-maven-plugin version 2.2.0, bound to the pre-site phase and invoked with the dokka:dokka goal.
• Runs standalone through a command-line runner for builds that use neither Gradle nor Maven.
• Provides dokkaHtml for single-project builds and dokkaHtmlMultiModule for multi-project builds, writing to /build/dokka/html and /build/dokka/htmlMultiModule by default.
• Highly pluggable, so processing and output can be extended past the bundled formats.

Who uses it and how

• Library maintainers publish API reference for widely consumed Kotlin artifacts; kotlinx.coroutines, Ktor, OkHttp, Hexagon, and Bitmovin all ship Dokka-generated documentation.
• Gradle uses Dokka to publish reference for its Kotlin DSL, an example of output generated from a large multi-module build.
• Multi-project builds apply the plugin in the root build script and again in each subproject, then run dokkaHtmlMultiModule to produce one combined site.
• Maven projects bind the plugin to the pre-site phase so API documentation regenerates as part of the normal site build.
• Teams needing full control over invocation can use the command-line runner instead of a build plugin.

Getting started

The standard path applies the Gradle plugin org.jetbrains.dokka version 2.2.0 and runs dokkaHtml; Maven users add org.jetbrains.dokka:dokka-maven-plugin version 2.2.0 and run the dokka:dokka goal.

How it compares

No comparable tool is named in the facts for this entry, so Dokka stands alone in this registry among API documentation engines. It is not positioned here against any named alternative, paid or free.

When to use it — and when not to

Choose Dokka when the codebase is Kotlin, or a Kotlin and Java mix, and the goal is published API reference built from comments already in the source. The command-line path is explicitly harder to set up than the Gradle or Maven plugins, so teams without a JVM build tool should expect extra configuration work. The project is marked Kotlin Beta and the repository carries 675 open issues, so adopters should expect movement in APIs and output rather than a frozen surface.

plugins {
    id("org.jetbrains.dokka") version "2.2.0"
}

subprojects {
    apply(plugin = "org.jetbrains.dokka")
}

plugins {
    id 'org.jetbrains.dokka' version '2.2.0'
}

subprojects {
    apply plugin: 'org.jetbrains.dokka'
}

<build>
    <plugins>
        <plugin>
            <groupId>org.jetbrains.dokka</groupId>
            <artifactId>dokka-maven-plugin</artifactId>
            <version>2.2.0</version>
            <executions>
                <execution>
                    <phase>pre-site</phase>
                    <goals>
                        <goal>dokka</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

dependencies {
    dokkaPlugin("org.jetbrains.dokka:android-documentation-plugin:2.2.0")
}

dependencies {
    dokkaPlugin 'org.jetbrains.dokka:android-documentation-plugin:2.2.0'
}

<plugin>
    <groupId>org.jetbrains.dokka</groupId>
    <artifactId>dokka-maven-plugin</artifactId>
    ...
    <configuration>
        <dokkaPlugins>
            <plugin>
                <groupId>org.jetbrains.dokka</groupId>
                <artifactId>android-documentation-plugin</artifactId>
                <version>2.2.0</version>
            </plugin>
        </dokkaPlugins>
    </configuration>
</plugin>