Kotlin/dokka
41.1
Weak · 14 November 2026
45k
lines of production code
Kotlin
primary language
5
measurements over time
What this system is
Features
Add Kotlin Multiplatform UI showcase test project
A new Kotlin Multiplatform (KMP) test project has been added to the Dokka integration test suite to validate documentation generation across multiple targets. The project includes common source sets demonstrating Kotlin 2.2 context receivers, expect/actual class declarations, and coroutine extensions, alongside platform-specific implementations for JVM, JS, Linux, and macOS, including C interop usage on native targets.
dokka-integration-tests/gradle/projects/ui-showcase/kmp · high confidence
Add Kotlin Multiplatform example project with Gradle v2
The examples/gradle-v2/kotlin-multiplatform-example directory now contains a complete Kotlin Multiplatform sample project demonstrating Gradle v2 configuration. This example includes common source code with expect/actual declarations for coroutines, date utilities, custom exceptions, and web services, along with platform-specific actual implementations for JVM, JS, iOS, Linux, macOS, MinGW, WasmJS, and Web targets. It also demonstrates custom source sets (like customJdk9) and mixed Java/Kotlin source files, providing a reference implementation for multiplatform project structure and Gradle v2 build configuration.
examples/gradle-v2/kotlin-multiplatform-example · high confidence
Add default transformer for rendering @sample code snippets
A new DefaultSamplesTransformer has been introduced to process documentation pages containing @sample tags. This transformer locates Sample nodes within the documentation model, resolves the corresponding code snippets using the Kotlin analysis environment, and injects them as formatted code blocks into the generated page content. This ensures that sample code referenced in documentation is properly extracted and displayed in the final output.
dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/pages · high confidence
Add example for custom Dokka plugin to hide internal APIs
Added a new Gradle v2 example demonstrating how to configure a custom Dokka plugin that excludes code annotated with a specific marker from generated documentation. The example includes the \HideInternalApiPlugin\ implementation, which filters documentables based on a configurable annotation fully qualified name, and a demo library using a \@HideFromDokka\ annotation to suppress the \main\ function from the output.
demo-library, examples/gradle-v2/custom-dokka-plugin-example/dokka-plugin-hide-internal-api · high confidence
Add hide-internal-api plugin example
The \examples/plugin/hide-internal-api\ sample project has been added to demonstrate how to create a Dokka plugin that filters documentation. The plugin hides any declarations marked with the \org.jetbrains.dokka.internal.test.Internal\ annotation by extending the \SuppressedByConditionDocumentableFilterTransformer\. The example includes the plugin implementation, a service provider configuration, and a test verifying that annotated functions are excluded from the generated documentation.
examples/plugin/hide-internal-api · high confidence
Add multi-module versioning example project
A new Gradle example project demonstrating Dokka's multi-module versioning capabilities has been added. It includes two child modules (childProjectA and childProjectB) containing Kotlin source files with \@since\ annotations to illustrate how version-specific documentation is handled across modules.
examples/gradle/dokka-versioning-multimodule-example/parentProject/childProjectA, examples/gradle/dokka-versioning-multimodule-example/parentProject/childProjectB · high confidence
Added Gradle v2 example projects
New example projects under the \examples/gradle-v2/\ directory demonstrate how to configure Dokka with Gradle v2, including basic Kotlin and Java setups, composite builds, custom styling, Javadoc generation, Kotlin-as-Java conversion, library publishing, and multi-module configurations.
(repo-wide) · high confidence
Added Gradle v2 multimodule versioning example projects
The examples/gradle-v2/versioning-multimodule-example directory now includes two child modules, childProjectA and childProjectB, demonstrating how to structure and version a multimodule Gradle project. childProjectA contains Kotlin classes (ChildProjectAClass, FancyAPI) with @since annotations indicating API stability levels (0.9 and 1.0), while childProjectB provides a base class (ChildProjectBClass) and a utility function (superFunction42) also annotated with versioning metadata. These files serve as a concrete reference for users implementing similar versioning strategies in their own Gradle v2 multimodule setups.
examples/gradle-v2/versioning-multimodule-example/childProjectA, examples/gradle-v2/versioning-multimodule-example/childProjectB · high confidence
Added Kotlin source example for Dokka Gradle usage
The dokka-gradle-example location now includes a sample Kotlin file (HelloWorld.kt) containing a Greeter class and main function, providing a concrete codebase for users to test Dokka's documentation generation capabilities.
dokka-gradle-example · high confidence
Added documentation and template for running Gradle integration tests locally
A new README guide and a \template.settings.gradle.kts\ file have been added to the integration test projects, enabling developers to open and build individual test projects in IntelliJ IDEA. The template configures plugin resolution for Kotlin (versions 2.0.0+), Dokka (versions 2.1.0+), and Android Gradle plugins via configurable properties, allowing users to override specific versions and Maven repositories for local testing.
dokka-integration-tests/gradle/projects · high confidence
Added integration test documentation and AWS sync utility
The integration test suite now includes a README explaining how to import Gradle projects, update external dependencies via git patches, and manage expected HTML output data. Additionally, an AWS sync script (aws\_sync.sh) was added to automate the publishing of test artifacts to S3, retaining only the most recent commit versions.
dokka-integration-tests · high confidence
Added local Dokka testing automation script
A new shell script, testDokka.sh, has been added to the scripts directory to streamline local development and testing of Dokka. This tool automates the process of building the current Dokka source, publishing it to the local Maven repository, and generating documentation against a specified test project (defaulting to the Gradle example). It supports single and multi-module projects, allows customization of the test version, target directory, and local server port, and automatically starts a Python web server to display the generated HTML documentation in a browser.
scripts · high confidence
Dokka base plugin resources and client-side navigation logic
This change introduces the foundational resource files and client-side scripts for the Dokka base plugin. It registers the \DokkaBase\ plugin via a new \META-INF/services\ descriptor and defines format descriptors for HTML, GFM, Jekyll, and other output types through new \.properties\ files. A comprehensive set of SVG icons is added to support the UI, including symbols for code elements (classes, interfaces, functions), UI controls (theme toggle, copy, filter), and navigation. Additionally, new JavaScript files are included to handle client-side behavior: \navigation-loader.js\ manages the Table of Contents (TOC) state, scroll position, and expansion logic, while \platform-content-handler.js\ implements platform-dependent content filtering, anchor scrolling, and dark mode switching.
dokka-subprojects/plugin-base/src/main/resources · high confidence
Dokka example source files added to repository
The repository now includes sample Kotlin source files for various Dokka example projects, including Gradle-based examples (custom format, Kotlin-as-Java, library publishing, and multimodule setups) and a Maven-based example. These files provide the underlying code for documentation generation demos.
(repo-wide) · high confidence
Initial implementation of Kotlin Symbols-based documentation analysis
This change introduces the core infrastructure for analyzing Kotlin source code using the new Kotlin Analysis API (K2) instead of the legacy PSI-based approach. It adds the \KotlinAnalysis\ context for managing analysis sessions, the \DefaultSymbolToDocumentableTranslator\ to map Kotlin symbols to Dokka's documentable model, and new KDoc parsing components (\KotlinDocComment\, \DescriptorDocumentationContent\) to handle documentation extraction. This enables more accurate symbol resolution and documentation generation for Kotlin projects.
analysis-kotlin-symbols · high confidence
Initial project scaffolding and repository configuration
The repository is initialized with essential project files, including a comprehensive README.md detailing usage for Gradle, Maven, and Android, along with CONTRIBUTING.md and CODE\_OF\_CONDUCT.md guidelines. The build system is configured with Gradle wrapper scripts (gradlew, gradlew.bat) and a .gitattributes file to manage line endings and language statistics. Additionally, the legacy IntelliJ IDEA module file (dokka.iml) is removed in favor of modern Gradle-based project structures.
(repo-wide) · high confidence
Initial release of the Dokka Maven Plugin
This change introduces the Dokka Maven Plugin, providing a new Maven Mojo to generate Kotlin documentation directly from Maven builds. The plugin exposes configuration options for source directories, classpaths, module names, and output directories, along with support for per-package options (such as visibility and deprecation handling), external documentation links, and source code links. It also includes a Maven-specific logger and utilizes a cache-redirector for faster dependency resolution.
dokka-runners/runner-maven-plugin · high confidence
Initial support for GitHub Flavored Markdown (GFM) output format
Dokka now supports generating documentation in GitHub Flavored Markdown. This adds a new GFM renderer that outputs .md files, a GFM-specific template processing strategy for resolving links in markdown templates, and a Markdown location provider. The change also includes a plugin to filter Android-specific documentation (hiding members marked with @hide) and introduces a new page merger strategy to correctly merge member pages with the same name across different source sets.
(repo-wide) · high confidence
Introduce new CLI runner with JSON configuration support
The \dokka-runners/runner-cli\ module now provides a new command-line interface for generating documentation. Users can supply a JSON configuration file via the \-json\ argument to define global settings (such as module name, output directory, plugins, and source links) and per-source-set options. The CLI automatically merges global settings into each source set and appends default external documentation links (JDK and Kotlin stdlib) unless explicitly disabled. A new test suite validates that global configurations are correctly applied to all source sets and that the runner handles configurations with no specific source-set options gracefully.
dokka-runners/runner-cli · high confidence
New Dokka Gradle Plugin v2 example projects
Added a new set of example projects under \examples/gradle-v2\ to demonstrate how to use the Dokka Gradle Plugin in v2 mode. These examples cover various configurations including basic usage, Java documentation, Kotlin Multiplatform, multi-project builds, composite builds, custom styling, custom plugins, library publishing, and versioning.
examples/gradle-v2 · high confidence
New Dokka Multiplatform Example Project
Added a new Gradle-based example project demonstrating Dokka's multiplatform documentation generation capabilities. The example includes source files for common, JVM, JS, Linux, and macOS targets, featuring expect/actual declarations for coroutines and date utilities, custom source sets, and mixed Kotlin/Java code to illustrate how Dokka handles multiplatform artifacts.
examples/gradle/dokka-multiplatform-example · high confidence
New Java PSI analysis plugin for documentation generation
Dokka now includes a new Java analysis plugin that parses Java source files using the IntelliJ Platform's PSI (Program Structure Interface) to generate documentation. This plugin introduces a new architecture for Java support, featuring a \DefaultPsiToDocumentableTranslator\ to traverse source roots, a \JavaDocParser\ to handle Javadoc comments (including support for \@param\ on classes, \@snippet\, and Markdown doc comments), and a \SyntheticElementDocumentationProvider\ to generate documentation for synthetic enum methods like \values()\ and \valueOf()\. It also registers necessary search executors to ensure Java inheritance documentation is correctly resolved.
dokka-subprojects/analysis-java-psi/src/main/kotlin · high confidence
New Javadoc output format plugin
Dokka now includes a new Javadoc output format plugin that generates HTML documentation compatible with the standard Java Javadoc structure. This addition introduces a complete rendering pipeline, including a custom page creator, location provider, and signature provider, alongside the necessary static resources like jQuery and CSS stylesheets to support the generated pages.
dokka-subprojects/plugin-javadoc/src/main · high confidence
New UI kit assets, design tokens, and components for Dokka documentation
The \plugin-base-frontend\ UI kit has been populated with a new set of design tokens (colors, breakpoints, typography, sizes) and a comprehensive library of SVG assets, including navigation icons for Kotlin language elements (classes, interfaces, enums, etc.) and UI controls (copy, check, filter, theme toggle). This update introduces foundational UI components such as breadcrumbs, buttons, checkboxes, code blocks, and copy-to-clipboard tooltips, providing the visual and interactive basis for the documentation generator's frontend.
dokka-subprojects/plugin-base-frontend/src/main/ui-kit · high confidence
New all-modules-page plugin resolves cross-module local links
This change introduces the \AllModulesPagePlugin\ (located in \dokka-subprojects/plugin-all-modules-page\) which provides the infrastructure for generating the 'All modules' overview page in multi-module documentation. Specifically, it adds a \ResolveLinkCommandHandler\ that resolves local links between modules; when a link target is found, it generates the correct relative href, and when a link cannot be resolved, it marks the element with a \data-unresolved-link\ attribute. The plugin also registers the \MultimodulePageCreator\ to build the modules table and includes support for resolving links in both HTML and GFM output formats.
dokka-subprojects/plugin-all-modules-page · high confidence
New build-logic utility functions for Gradle configuration and testing
The build-logic module introduces several new Kotlin utility files to improve Gradle build configuration and test execution. These include \DokkaGradleExampleDirectoriesSource\ for safely fetching example directories as Gradle configuration cache inputs, \SystemPropertyAdder\ to simplify adding system properties to Test tasks while correctly registering them as task inputs/outputs, and \downloadLatestKotlinStdlibJvmSources\ to automatically download and unpack Kotlin stdlib sources. Additionally, \gradle.kt\ provides helpers for managing Gradle configuration types (declarable, resolvable, consumable) and excluding embedded Gradle dependencies, while \gradleKotlinCompatibility.kt\ configures Kotlin compiler versions to maintain compatibility with older Gradle versions.
build-logic/src/main/kotlin/dokkabuild/utils · high confidence
New fuzzy search UI with keyboard shortcuts
The Dokka frontend now features a new search interface that supports fuzzy matching and keyboard navigation. Users can open the search popup by pressing the platform-specific accelerator key (Cmd on macOS, Ctrl on Windows/Linux) plus 'K'. The search results are displayed in a popup with highlighted matches, and the interface includes a clear button and focus trapping for better accessibility. The search component fetches page data from 'scripts/pages.json' and allows users to navigate to documentation pages directly from the search results.
dokka-subprojects/plugin-base-frontend/src/main/components · high confidence
New internal analysis API and Java PSI support modules
This change introduces the \analysis-kotlin-api\ and \analysis-java-psi\ subprojects, establishing a public API for interacting with Kotlin analysis and an internal module for parsing Java sources. The \analysis-kotlin-api\ module exposes extension points for external documentable providers, sample analysis environments, and sample rewriters, allowing plugins to analyze Kotlin samples and resolve external dependencies. The \analysis-java-psi\ module includes copied IntelliJ platform classes like \MethodSuperSearcher\ to ensure super-method search works without depending on heavy indexing infrastructure, and defines Javadoc tag parsers. These modules provide the foundational APIs and Java support required by the new symbols-based (K2) analysis implementation.
dokka-subprojects · high confidence
New templating command infrastructure and Jackson configuration
The templating subsystem introduces a new \Command\ interface hierarchy to support structured template operations, including \AddToNavigationCommand\ for module navigation, \ResolveLinkCommand\ for document reference resolution, and \SubstitutionCommand\ for pattern-based text replacement. An \ImmediateHtmlCommandConsumer\ interface is added to define how these commands are processed against HTML template blocks. Additionally, a dedicated Jackson \ObjectMapper\ (\jsonMapperForPlugins\) is provided, configured with a custom \TypeFactory\ bound to the plugin class loader and a \File\ serializer, ensuring correct JSON serialization and deserialization within the plugin environment.
dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/templating · high confidence
New templating plugin for HTML command and substitution processing
A new \TemplatingPlugin\ has been added to the \dokka-subprojects/plugin-templating\ module, introducing a directive-based HTML template processing strategy. This plugin enables the use of \dokka-template-command\ tags and HTML comments to execute specific templating operations during documentation generation. It includes built-in handlers for substituting values (such as module names and version numbers) and adding content to navigation and search indexes, along with a fallback strategy to pass through files unchanged when no commands are present.
dokka-subprojects/plugin-templating · high confidence
New test infrastructure for Dokka configuration and execution
The core-test-api module now provides a new suite of utilities for writing and running Dokka integration tests. This includes a DSL-based \TestDokkaConfigurationBuilder\ for constructing \DokkaConfiguration\ objects, a \MockContext\ to simulate the plugin execution environment, and a \TestLogger\ that captures log output for verification. The \AbstractTest\ runner has been updated to use \java.nio.file.Files.createTempDirectory\ for temporary output folders, and new assertion helpers (\assertDokkaConfigurationEquals\, \assertDokkaSourceSetEquals\) ensure consistent comparison of configuration objects, including robust handling of URL-based links.
dokka-subprojects/core-test-api · high confidence
UI showcase test project now supports versioning and custom footer configuration
The UI showcase integration test project has been updated with new build-logic scripts that enable specific Dokka features for testing purposes. The Kotlin Multiplatform (KMP) variant now configures a custom HTML footer displaying Kotlin Foundation and Apache 2 license information, along with a specific homepage link. The standard variant now includes the versioning plugin, allowing the test project to generate documentation with version history support by referencing previous documentation versions.
dokka-integration-tests/gradle/projects/ui-showcase/build-logic · high confidence
Removals
Removal of legacy main entry point and compiler integration
The \src/main.kt\ file, which previously served as the entry point for the compiler-as-a-service setup, has been deleted. This removes the direct integration with the Kotlin compiler's \JetCoreEnvironment\, \BindingContext\, and \AnalyzerFacadeForJVM\ from this location, effectively stripping out the low-level compilation and analysis logic that was previously housed here.
src · high confidence
Architecture
New Dokka Gradle Plugin v2 format plugin architecture
The Dokka Gradle Plugin introduces a new v2 architecture for managing documentation output formats. This change adds a base \DokkaFormatPlugin\ that handles the core setup of publications, dependency configurations, and generation tasks for a specific format. Concrete format plugins, such as \DokkaHtmlPlugin\ and \DokkaJavadocPlugin\, now extend this base to provide format-specific configurations (e.g., HTML versioning, Javadoc plugin inclusion). This restructuring separates the concerns of task generation (\DokkaFormatTasks\) and publication management (\DokkaPublication\), providing a more modular foundation for future format support and migration from v1.
dokka-runners/dokka-gradle-plugin/src/main/kotlin/formats · high confidence
Refactored HTML rendering into a new modular renderer architecture
The HTML rendering logic in the Dokka base plugin has been restructured into a new set of components within the \renderers\ package. This introduces an \OutputWriter\ interface and a \FileWriter\ implementation to handle asynchronous file and resource output, a \DefaultRenderer\ abstract class to standardize content node building, and new services like \PackageListService\ and transformers such as \PackageListCreator\ to manage package list generation. This change replaces the previous monolithic rendering approach with a more modular, extensible design that separates content construction from file I/O.
dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/renderers · high confidence
Behavioural changes
1 commit (0 fixes) modifying dokka-subprojects/analysis-kotlin-api/src/main/resources
A change to existing behaviour in dokka-subprojects/analysis-kotlin-api/src/main/resources — 1 commit, 5 files: “Move Enum templates into the analysis-kotlin-api project and update the \Enum.entries\ KDoc (\#4475)” (refs \#4475).
dokka-subprojects/analysis-kotlin-api/src/main/resources · medium confidence · unverified
2 commits (0 fixes) modifying dokka-integration-tests/gradle/projects/it-basic-groovy, dokka-integration-tests/gradle/projects/it-sequential-tasks-execution-stress, it-basic-groovy
A change to existing behaviour in dokka-integration-tests/gradle/projects/it-basic-groovy, dokka-integration-tests/gradle/projects/it-sequential-tasks-execution-stress, it-basic-groovy — 2 commits, 8 files: “\[K2\] Run Gradle integration tests (\#3390)”; “Restructure the project to utilize included builds (\#3174)” (refs \#3390, \#3174).
dokka-integration-tests/gradle/projects/it-basic-groovy, dokka-integration-tests/gradle/projects/it-sequential-tasks-execution-stress, it-basic-groovy · medium confidence · unverified
2 commits (1 fix) modifying dokka-integration-tests/gradle/projects/it-android-compose/core, dokka-integration-tests/gradle/projects/it-android-compose/material3
A change to existing behaviour in dokka-integration-tests/gradle/projects/it-android-compose/core, dokka-integration-tests/gradle/projects/it-android-compose/material3 — 2 commits (1 fix), 4 files: “DGPv2 Android integration tests (\#3904)”; “KT-71784 Fix classpath for KMP shared source sets (\#3942)” (refs \#3904, \#3942).
dokka-integration-tests/gradle/projects/it-android-compose/core, dokka-integration-tests/gradle/projects/it-android-compose/material3 · medium confidence · unverified
Add cleanup extension point and cache clearing for AllModulesPageGeneration
The AllModulesPageGeneration class now includes a finally block that executes cleanup actions registered via the CoreExtensions.cleanUpActions extension point. This ensures that resources are properly released after generation, even if errors occur during the process. Additionally, the PackageList cache is explicitly cleared during cleanup to prevent memory leaks and ensure fresh data in subsequent runs.
plugin-all-modules-page · high confidence
Centralized Gradle build scan and cache configuration
A new \dokkasettings.settings.gradle.kts\ file centralizes the configuration for Gradle Develocity build scans and remote build caching. This change ensures that build scans are consistently enabled on CI environments (GitHub Actions and TeamCity) and that remote cache push is enabled when running in CI, while keeping local caching enabled by default for local development. The configuration handles obfuscation of sensitive data in build scans and aligns with the root settings to support composite builds.
build-settings-logic · high confidence
Core model and configuration refactoring
The core module has been restructured to introduce a new configuration and model architecture. A new \DokkaConfiguration\ interface and \DokkaConfigurationImpl\ data class now define global and source-set options, including a new \suppressAnnotatedWith\ option to suppress declarations by annotation. The internal representation of source sets has changed: \DokkaSourceSet\ is now uniquely identified by a \DokkaSourceSetID\ (combining scope and name), and a new \DisplaySourceSet\ model with a \CompositeSourceSetID\ is used for rendering, with caching added to improve performance. The \DRI\ (DokkaResourceIdentifier) model has been extended with an \isProperty\ flag on \Callable\ to distinguish properties from functions, and \TypeReference\ is now a sealed class with specific implementations like \JavaClassReference\ and \TypeParam\.
dokka-subprojects/core · high confidence
Dokka Gradle Plugin V1 tasks and configurations are disabled in V2 mode
When using the Dokka Gradle Plugin in V2 mode, legacy V1 tasks (such as \dokkaHtml\, \dokkaJavadoc\, and their multi-module/collector variants) and their associated Gradle configurations are now disabled. Attempting to run these V1 tasks will immediately fail with an error instructing users to migrate to the new V2 tasks (e.g., \dokkaGenerateHtml\). This change ensures that users are guided away from deprecated V1 features and prevents accidental usage of obsolete task configurations.
dokka-runners/dokka-gradle-plugin/src/main/kotlin/internal · high confidence
Dokka Gradle Plugin V2 is now the default
The Dokka Gradle Plugin now uses the V2 engine by default, replacing the legacy V1 implementation. This change brings improved performance and support for the K2 compiler analysis engine, along with new features such as lifecycle tasks for generating documentation formats and better handling of Android multi-variant projects. Users migrating from V1 may encounter changes in configuration options and task behaviors, so reviewing the migration guide is recommended to ensure compatibility with the new V2 architecture.
dokka-gradle-plugin · high confidence
Dokka Gradle Plugin v1 is deprecated and scheduled for removal
The classic Dokka Gradle Plugin (DGPv1) is now deprecated and marked for removal. All core plugin components in this location—including the main \DokkaClassicPlugin\, task classes like \AbstractDokkaTask\, source-set builders, and configuration helpers—are annotated with deprecation warnings. Users should prepare to migrate to the new Dokka Gradle Plugin v2.
dokka-runners/dokka-gradle-plugin/src/classicMain/kotlin · high confidence
Dokka Gradle Plugin v2 API surface and configuration options
The Dokka Gradle Plugin exposes a new public API surface for version 2, introducing base plugin classes (DokkaBasePlugin, DokkaClassicPlugin) and task hierarchies (AbstractDokkaTask, AbstractDokkaLeafTask, AbstractDokkaParentTask) that support multi-module layouts and child task management. The DokkaExtension now exposes configuration properties for output directories (basePublicationsDirectory, dokkaPublicationDirectory), module metadata, and engine isolation. Source set configuration is handled via GradleDokkaSourceSetBuilder, which provides options to control documentation generation such as suppressing inherited members or obvious functions, linking JDK/stdlib/Android SDK docs, and managing source roots and dependencies.
dokka-runners/dokka-gradle-plugin · high confidence
Dokka Gradle Plugin v2 introduces new default conventions and output directory structure
The Dokka Gradle Plugin v2 (DGPv2) establishes new default behaviors for documentation generation, including renaming the base output directory property from \dokkaPublicationDirectory\ to \basePublicationsDirectory\ and setting the default \modulePath\ to the project name for root projects to prevent output clashes during aggregation. It also configures default visibility modifiers to \Public\, enables Kotlin standard library and JDK documentation links by default, and sets \suppressGeneratedFiles\ to true, while introducing new options like \suppressInheritedMembers\ and \suppressObviousFunctions\ to aid migration from previous versions.
dokka-runners/dokka-gradle-plugin/src/main/kotlin · high confidence
Enforced UI-kit build and staging checks in pre-commit hook
The pre-commit hook for the plugin-base-frontend module now automatically runs lint-staged and checks for staged changes. If staged changes are detected, it triggers a build of the ui-kit. Additionally, it prevents commits if there are unstaged changes in the plugin-base/src/main/resources/dokka/ui-kit directory, ensuring the UI kit resources remain consistent.
.husky · high confidence
Enhanced JavaDoc parsing with Markdown support, @snippet handling, and improved link resolution
The JavaDoc analysis engine in the \analysis-java-psi\ module has been significantly updated to support modern JavaDoc features and improve documentation accuracy. It now supports JEP 467 Markdown Doc Comments, allowing Markdown syntax within JavaDoc to be converted to HTML. Additionally, it implements the JEP 413 \@snippet\ tag, enabling inline and external code snippets to be included in documentation with markup operations like highlighting and replacement. The parser also now correctly handles \@param\ tags for classes and fixes unresolved Javadoc \@link\ references to overridden methods, ensuring that links in generated documentation point to the correct elements.
analysis-java-psi · high confidence
Improved generation reliability with cleanup hooks and source set validation
The documentation generation process now includes a dedicated cleanup extension point that runs in a finally block to ensure resources are released even if errors occur, and it explicitly clears the PackageList cache to prevent stale data. Additionally, a new pre-generation check validates that all source sets have unique IDs, failing the build with a clear error message if duplicates are detected. These changes are supported by new test utilities that allow capturing output and verifying the generation pipeline stages.
dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/generation, plugin-base-test-utils · high confidence
Integration test projects now support overriding Dokka version and fail-on-warning behavior
The integration test projects for coroutines and serialization have been updated to allow the Dokka version to be overridden via the \dokka\_it\_dokka\_version\ Gradle property, replacing hardcoded version references in build scripts and version catalogs. Additionally, a new \dokka\_it\_failOnWarning\ property has been introduced to control whether Dokka treats warnings as failures, and the \kotlinx-knit\ dependency now explicitly excludes the \dokka-pathsaver-plugin\. These changes enable more flexible testing of different Dokka versions and stricter warning handling in the test environment.
dokka-integration-tests/gradle/projects/serialization · high confidence
Internal Kotlin integration utilities added to Dokka Gradle Plugin
The Dokka Gradle Plugin now includes a new set of internal utility files in the \kotlin\ package (such as \KotlinGradlePluginVersion\, \KotlinNativeDistributionAccessor\, and \kotlinCompilationUtils\) to manage Kotlin-specific logic. These utilities handle version parsing, Kotlin Native distribution access, and source set compilation resolution, providing the foundational support needed for the plugin to interact with the Kotlin Gradle Plugin's internal APIs.
dokka-runners/dokka-gradle-plugin/src/classicMain/kotlin/kotlin · high confidence
Introduce VersioningStorage for managing documentation version directories
The versioning plugin now uses a new VersioningStorage interface and DefaultVersioningStorage implementation to manage documentation version directories. This change enables the plugin to track previous and current documentation versions, resolve output directories for older versions based on a configurable folder name, and create version metadata files. Users benefit from more flexible organization of older documentation versions in custom subdirectories.
plugin-versioning · high confidence
Kotlin Playground samples are now a separate plugin
The Kotlin Playground runnable samples feature has been extracted into a dedicated plugin (\KotlinPlaygroundSamplesPlugin\). This change ensures that the Kotlin Playground JavaScript and CSS resources are only included in documentation pages that actually contain \@sample\ annotations, rather than being loaded on every page. Users can now configure a custom Kotlin Playground server URL via the plugin configuration, and the plugin handles the injection of the necessary scripts and styles specifically for runnable code samples.
dokka-subprojects/plugin-kotlin-playground-samples · high confidence
Maven integration tests now use JetBrains cache-redirector for Maven Central
The Maven integration test infrastructure has been updated to route Maven Central requests through the JetBrains cache-redirector (cache-redirector.jetbrains.com/maven-central) instead of the direct URL. This change, implemented in the new \settingsXml.kt\ helper, ensures that integration tests rely on the cached repository mirror, which may improve reliability and speed of dependency resolution during test execution.
maven · high confidence
Migrate JS integration test to Kotlin Multiplatform
The \it-js-ir-0\ integration test project has been updated to use the Kotlin Multiplatform plugin instead of the deprecated \kotlin-js\ plugin. This change includes new test source files in \src/jsMain/kotlin\ (such as \RootPackageClass.kt\ and \PublicClass.kt\) that verify Dokka's handling of public, internal, and private members, as well as suppression rules, within a Kotlin/JS target.
dokka-integration-tests/gradle/projects/it-js-ir-0, it-js-ir-0 · high confidence
New Gradle plugin parameter model for Dokka v2
The Gradle plugin introduces a new internal parameter model (Dokka v2) to configure documentation generation. This change adds new specification classes for external documentation links, source links, package options, and source sets, replacing the previous configuration approach. Users should note that the \DokkaInternalApi\ annotation has been renamed to \InternalDokkaGradlePluginApi\.
dokka-runners/dokka-gradle-plugin/src/main/kotlin/engine/parameters · high confidence
New HTML rendering engine and navigation structure
The plugin-base module introduces a new HTML rendering pipeline, replacing the previous implementation with a new HtmlRenderer that generates tabbed content for class members and package summaries. A new NavigationPage component now handles the table of contents, supporting icons and accessibility features like skip links. Search functionality is restructured via a new SearchbarDataInstaller that generates a pages.json index, and template handling is updated with a new DefaultTemplateModelFactory for Freemarker integration. Additionally, the location provider (DokkaLocationProvider) and package list resolver (PackageList) have been rewritten to improve path resolution and caching performance.
plugin-base · high confidence
New HTML rendering infrastructure and navigation logic
The HTML renderer in the base plugin has been restructured to support a new UI and more flexible content generation. This includes a new \HtmlCodeBlockRenderer\ interface that allows plugins to customize how code blocks are rendered based on language. Navigation logic has been moved into \NavigationDataProvider\, which now handles the generation of navigation nodes, icons, and sorting, including support for an 'All Types' page. The rendering pipeline now uses an \ImmediateResolutionTagConsumer\ to process template commands (like link resolution and version replacement) directly during HTML generation, replacing the previous deferred approach. Additionally, new page transformers (\ScriptsInstaller\, \StylesInstaller\, \AssetsInstaller\) manage the inclusion of frontend assets, and utility functions in \htmlFormatingUtils\ improve text breakability for long identifiers.
dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/renderers/html · high confidence
New JetBrains Markdown analysis implementation for Dokka
This change introduces a new markdown parsing implementation in the \analysis-markdown-jb\ subproject, replacing the previous logic with a custom \MarkdownParser\ that leverages IntelliJ's markdown library for GFM support. The new parser correctly handles blockquotes and code blocks (fixing issues with \\>\ characters in code), uses the KDoc tag subject name when rendering \@see\ tags, and includes updated utility functions for HTML encoding and whitespace normalization. This refactoring improves the accuracy of markdown-to-KDoc conversion in Dokka.
dokka-subprojects/analysis-markdown-jb/src/main/kotlin/org/jetbrains/dokka/analysis/markdown/jb · high confidence
New KDoc resolution and parsing implementation
The analysis-kotlin-symbols module now uses a new KDoc resolution and parsing implementation. This includes a new KDocProvider that retrieves documentation from symbols, a KdocMarkdownParser for parsing KDoc tags into documentation nodes, and a ResolveKDocLink component that resolves KDoc links to Document Reference Identifiers (DRIs). Additionally, a SyntheticKDocProvider generates documentation for enum members, and a ModuleAndPackageDocumentationReader handles module and package documentation. Java KDoc comments are now parsed using a KotlinDocCommentParser and DescriptorKotlinDocCommentCreator. This change represents a significant shift in how KDoc is processed within the symbols analysis plugin.
dokka-subprojects/analysis-kotlin-symbols · high confidence
New build-logic conventions for Dokka build properties and Maven publishing
The build-logic module introduces new Kotlin source files that define the \DokkaBuildProperties\ extension and the \DevMavenPublishExtension\. These additions provide a centralized way to manage build configuration (such as Java toolchain versions, CI detection, and integration test settings) and simplify the setup of local Maven publishing for development and integration tests by automatically handling repository inputs and system properties.
build-logic/src/main/kotlin/dokkabuild · high confidence
New build-logic tasks for constants generation, Git checkout, and Maven execution
The build system introduces three new Gradle tasks in the build-logic module to standardize and improve caching for internal build operations. GenerateDokkaGradlePluginConstants now programmatically generates the internal DokkaConstants object from a map of properties, ensuring consistent API exposure. GitCheckoutTask replaces manual git submodule handling by cloning repositories to a specific commit and verifying their status, with logic to re-run if the local repository is dirty or out of sync. MvnExec provides a cacheable wrapper for running Maven commands, handling class/resource synchronization and ensuring reproducible builds by stripping non-deterministic timestamps from generated properties files.
build-logic/src/main/kotlin/dokkabuild/tasks · high confidence
New configuration flags for All Types and Since Kotlin pages
The Dokka base plugin now supports two new internal configuration flags that control the visibility of specific documentation pages. Users can enable the 'All Types' page by setting the system property \dokka.shouldDisplayAllTypesPage\ to \1\ or \true\, and enable 'Since Kotlin' rendering by setting \dokka.shouldDisplaySinceKotlin\ to \1\ or \true\. These flags are read at initialization and allow users to toggle these features without code changes.
dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base · high confidence
New developer documentation site structure and build configuration
The developer documentation module has been restructured to use MkDocs with the Material theme, replacing the previous setup. A new README explains how to build the docs via Gradle or Docker, and the mkdocs.yml configures the site navigation, including links to user guides, developer guides, and community resources. An index.html file now redirects users to the generated documentation site.
docs-developer · high confidence
New documentable transformers for filtering, inheritance, and documentation
The base plugin introduces several new transformers in the documentables package that refine how API documentation is generated. The \JvmMappedMethodsDocumentableFilterTransformer\ and \JvmMappedPropertiesDocumentableFilterTransformer\ now filter out synthetic JVM-mapped methods and properties (such as \describeConstable\) that lack source documentation, preventing them from appearing in the output. Users can now suppress inherited members via the \suppressInheritedMembers\ configuration option using the \InheritedEntriesDocumentableFilterTransformer\, and suppress obvious functions via \suppressObviousFunctions\ using the \ObviousFunctionsDocumentableFilterTransformer\. Additionally, the \DeprecatedDocumentableFilterTransformer\ enforces suppression of \@Deprecated\ items based on global or package-level settings, while the \InheritorsExtractorTransformer\ now explicitly attaches inheritors information to classes and interfaces. The \ActualTypealiasAdder\ ensures actual typealiases are correctly linked to their expect counterparts, and the \ReportUndocumentedTransformer\ provides warnings for public APIs missing documentation when the \reportUndocumented\ option is enabled.
dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/documentables · high confidence
New internal Gradle plugin adapters for Android, Java, and Kotlin source sets
The Dokka Gradle Plugin now includes a new set of internal adapter plugins (AndroidAdapter, JavaAdapter, KotlinAdapter) that automatically discover and configure Dokka source sets based on the project's build environment. AndroidAdapter integrates with the Android Gradle Plugin to handle multi-variant projects and AGP 9 compatibility, JavaAdapter registers source sets for standard Java projects while suppressing duplicates when Android or Kotlin plugins are present, and KotlinAdapter maps Kotlin Multiplatform source sets and compilations to Dokka source sets with correct classpaths and platform detection. These adapters replace manual configuration by automatically wiring Gradle source sets to Dokka, ensuring proper classpath resolution and platform identification across Android, Java, and Kotlin projects.
dokka-runners/dokka-gradle-plugin/src/main/kotlin/adapters · high confidence
New internal parameter builders for Gradle plugin configuration
The Gradle plugin now uses new internal builder classes, \DokkaParametersBuilder\ and \DokkaSourceSetBuilder\, to convert Gradle-specific configuration specs into the internal Dokka Generator model. This refactoring isolates the conversion logic to prevent Dokka Generator classes from leaking into the public Gradle plugin API. The builders handle the creation of \DokkaConfiguration\ and \DokkaSourceSetImpl\ instances, including processing source sets, plugin classpaths, module descriptors, and various source set options like suppression and visibility modifiers.
dokka-runners/dokka-gradle-plugin/src/main/kotlin/engine/parameters/builders · high confidence
New modular Dokka Gradle task architecture
The Dokka Gradle plugin introduces a new task structure for generating documentation, replacing previous implementations with distinct tasks for module and publication generation. Users will now see \DokkaGenerateModuleTask\ for creating individual module outputs and \DokkaGeneratePublicationTask\ for assembling complete publications, both extending a new \DokkaBaseTask\. A \LogHtmlPublicationLinkTask\ has been added to automatically log the local server URL for the generated HTML documentation, with its execution controlled by the \enableLogHtmlPublicationLink\ property in the \PluginFeaturesService\. Task names are now standardized via the \TaskNames\ class, supporting format-specific generation tasks like \dokkaGenerate\, \dokkaGeneratePublication\, and \dokkaGenerateModule\.
dokka-runners/dokka-gradle-plugin/src/main/kotlin/tasks · high confidence
Refactored Gradle plugin configuration into a new parameter model hierarchy
The Dokka Gradle plugin's internal configuration model has been restructured to improve modularity and maintainability. A new base class, \DokkaPluginParametersBaseSpec\, has been introduced to standardize how plugin parameters are defined and serialized to JSON. Specific plugin configurations, such as those for the Versioning plugin (\DokkaVersioningPluginParameters\) and the Kotlin Playground Samples plugin (\DokkaKotlinPlaygroundSamplesParameters\), now extend this base class. This change encapsulates the logic for handling inputs like \olderVersionsDirName\ and \kotlinPlaygroundScript\ within dedicated parameter classes, separating the Gradle-side configuration details from the core plugin logic.
dokka-runners/dokka-gradle-plugin/src/main/kotlin/engine/plugins · high confidence
Refactored signature rendering into a modular provider architecture
The signature rendering logic in the Dokka base plugin has been restructured to use a new \SignatureProvider\ interface and dedicated utility classes (\JvmSignatureUtils\, \KotlinSignatureProvider\). This change introduces a cleaner separation of concerns for generating documentation signatures for Kotlin and JVM documentables, supporting features like companion extensions, nested typealiases, and platform-specific modifiers (WasmWasi, WasmJs) through a more maintainable codebase.
dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/signatures · high confidence
Reorganized build-logic into convention plugins with improved test and publishing support
The build-logic module has been restructured into a set of convention plugins (e.g., \dokkabuild.base\, \dokkabuild.java\, \dokkabuild.kotlin-jvm\) to standardize project configuration. This change introduces JVM Test Suites for integration and K2 tests, enabling better isolation and caching of test outputs. It also adds a dedicated \dev-maven-publish\ mechanism for publishing artifacts to local directories for integration testing, avoiding issues with Maven Local's timestamping behavior. Additionally, the build now enforces reproducible archives, configures test retries on CI, and sets up specific publishing configurations for JVM and shadowed artifacts.
build-logic/src/main/kotlin · high confidence
Restructured comment parsing with new converter interface and expanded HTML tag support
The comment-to-content conversion logic in the Dokka base plugin has been restructured to use a new \CommentsToContentConverter\ interface and a \DocTagToContentConverter\ implementation. This change introduces support for additional Javadoc HTML tags, specifically \\<mark\>\ (highlighted text), \\<h4\>\ through \\<h6\>\ (headings), and ensures consistent styling for \\<b\>\, \\<strong\>\, \\<em\>\, and \\<i\>\ tags. It also fixes Markdown table parsing to correctly use \\<th\>\ nodes for headers and applies the \language-java\ CSS class to code blocks generated from Java sources.
dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/pages/comments · high confidence
Restructured documentation translation into modular components
The documentation generation logic in the base plugin has been refactored from a monolithic translator into a set of specialized, modular components. The new \DefaultDocumentableToPageTranslator\ now orchestrates the creation of pages by delegating to distinct creators: \DeprecationSectionCreator\ handles detailed rendering of Kotlin and Java deprecation annotations (including \DeprecatedSinceKotlin\ footnotes and \ReplaceWith\ suggestions), \DescriptionSections\ manages custom tags and unnamed KDoc tags, and \paramsSectionContent\ now explicitly separates context parameters, type parameters, and standard parameters into distinct table sections. Additionally, \briefFromContentNodes\ provides a new algorithm for extracting the first sentence as a brief description, handling HTML content and sentence boundaries more robustly.
dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/translators · high confidence
Restructured external and local documentation link resolution
The documentation link resolution logic in the Dokka base plugin has been reorganized into a new modular structure under the \resolvers\ package. External documentation links (such as Javadoc, Android SDK, and Kotlin website references) are now handled by dedicated providers like \JavadocExternalLocationProvider\ and \AndroidExternalLocationProvider\, which manage URL construction and anchor generation based on specific link formats. Local documentation links are resolved through a refactored \DefaultLocationProvider\ and \DokkaBaseLocationProvider\ that utilize a new \LocationProvider\ interface and factory pattern. This change introduces explicit support for various Javadoc versions (1-7, 8-9, 10+) and standardizes how external package lists are loaded and mapped to documentation pages.
dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/resolvers · high confidence
Reworks Gradle dependency configurations and attributes for better ecosystem integration
The Dokka Gradle Plugin now uses a new set of Gradle Configuration Attributes (Format, ModuleComponent, Classpath) and a custom 'dokka-java-runtime' Usage value to manage dependencies between subprojects. This change introduces a compatibility rule that allows Dokka's custom usage to interoperate with standard Java runtime configurations, resolving conflicts where Gradle previously confused Dokka plugin classpaths with project JARs. Users benefit from more reliable dependency resolution in multi-module projects and improved integration with the broader Gradle ecosystem.
dokka-runners/dokka-gradle-plugin/src/main/kotlin/dependencies · high confidence
Updated Android integration test expected HTML output
The expected HTML output for the \it-android-kotlin-jvm-builtin\ integration test has been updated to reflect the new Dokka UI design. This includes new SVG assets for navigation and type icons (such as classes, interfaces, and annotations), a restructured layout with a new navigation header, sidebar, and footer, and updated CSS/JS references to support the new theme and interactive elements like the table of contents and search.
dokka-integration-tests/gradle/projects/it-android · high confidence
Updated Gradle wrapper to version 7.6.3 in example projects
The Gradle wrapper in the \examples/gradle\ subprojects (including \dokka-customFormat-example\, \dokka-gradle-example\, \dokka-kotlinAsJava-example\, \dokka-library-publishing-example\, and \dokka-multimodule-example\) has been updated to use Gradle 7.6.3. This ensures that running the examples uses a consistent, up-to-date build tool version.
examples/gradle · high confidence
Updated Kotlin Multiplatform integration test expected outputs
The expected HTML and image assets for the Kotlin Multiplatform integration test have been updated to reflect the new Dokka design. This includes new SVG icons for UI elements (such as the burger menu, theme toggle, and copy button) and updated type-specific icons (for classes, interfaces, enums, and annotations) that now include Kotlin modifiers. The HTML structure has also been adjusted to support the new navigation, platform filtering, and dark mode toggle features.
dokka-integration-tests/gradle/projects/it-kotlin-multiplatform · high confidence
Updated expected HTML output for the basic Gradle example integration test
The expected HTML snapshots for the \basic-gradle-example\ integration test have been refreshed to reflect the new Dokka UI design. The generated pages now include the updated navigation header, table of contents sidebar, and footer, along with the new CSS and JavaScript assets (such as \ui-kit.min.css\ and \ui-kit.min.js\) required for the redesigned interface.
dokka-integration-tests/gradle/src/testExampleProjects · high confidence
Updated multiplatform integration test project structure
The it-multiplatform-0 integration test project has been restructured to include platform-specific source sets (JVM, JS, Linux, macOS, Desktop) with corresponding actual implementations for expected classes and coroutine functions. This change ensures the test suite properly validates Dokka's handling of Kotlin Multiplatform projects with diverse target configurations.
dokka-integration-tests/gradle/projects/it-multiplatform-0, it-multiplatform-0 · high confidence
Versioning plugin resources and service registration
The versioning plugin now registers itself via a new META-INF/services file and includes updated static assets: a redesigned 'page not found' HTML template that displays the specific documentation version requested, and new CSS styles for the version selector dropdown to improve layout and responsiveness.
dokka-subprojects/plugin-versioning/src/main/resources · high confidence
Versioning plugin restructured with configurable older versions directory
The versioning plugin has been restructured to support specifying a custom folder name for older documentation versions via the new \olderVersionsDirName\ configuration option (defaulting to "older"). This change introduces a \DefaultPreviousDocumentationCopyPostAction\ that copies previous version documentation while filtering out the configured older versions directory and hidden files, and adds \MultiModuleStylesInstaller\ and \NotFoundPageInstaller\ page transformers to handle CSS and fallback pages. The plugin now also exposes extension points for version ordering and navigation creation, allowing for customizable version lists and navigation dropdowns in the generated HTML.
dokka-subprojects/plugin-versioning/src/main/kotlin · high confidence
Fixes
Fix DGP reading all Gradle properties
This change addresses an issue where Dokka Gradle Plugin (DGP) failed to read all Gradle properties. The fix ensures that property resolution works correctly within the integration test project, allowing tests to properly access configuration values defined in Gradle.
it-kotlin-jvm · medium confidence
Test coverage
Add integration tests for Maven plugin custom resources and BioJava project; Add integration tests for Wasm JS/WASI Dokka generation; Added Android Compose integration test baseline; Added Android Gradle integration tests; Added Gradle integration test for kotlinx-io project; Added Gradle integration tests for Dokka; Added Gradle integration tests for Dokka build cache behavior; Added Gradle integration tests for kotlinx-coroutines and kotlinx-serialization; Added Kotlin/JVM integration test fixtures for visibility and suppression scenarios; Added ModuleD test fixture with cross-module links; Added UI showcase test project with Dokka 0.9 baseline assets; Added UI test data class for JVM integration tests; Added Wasm integration test fixtures for WASI and JS targets; Added functional tests for Dokka Gradle Plugin behavior and integration; Added integration test for Dokka HTML generation in Kotlin/JS IR projects; Added integration test for multi-module multiplatform HTML generation; Added integration test for the UI showcase project; Added integration test source files for Dokka CLI, Gradle, and Maven projects; Added integration tests for Dokka Gradle Plugin v2 on Android and Kotlin Multiplatform; Added integration tests for Dokka collector and multi-module outputs; Added integration tests for kotlinx-datetime with Dokka 2; Added integration tests for multi-module versioning output structure; Added multi-module integration test for annotation opt-in handling; Added sample source files for CLI integration tests; Added sequential task execution stress test; Added test fixtures for inter-module link resolution; Added tests for Dokka Gradle plugin conventions and module path defaults; Added tests for Dokka Gradle plugin engine parameters; Added tests for Dokka Gradle plugin format tasks and dependency resolution; Added tests for Dokka plugin parameter configurations; Added tests for Javadoc plugin template maps and rendering; Added tests for Kotlin API analysis and configuration validation; Added tests for Kotlin-as-Java plugin behavior; Added tests for directory content comparison utility; Added tests for integration test version configurations; Added tests for the classic Dokka Gradle plugin; Added unit tests for internal Dokka Gradle plugin utilities; Added unit tests for the Dokka base plugin; Basic integration test project source files added; Expanded UI test showcase with comprehensive Kotlin documentation examples; New CLI integration tests for Dokka command-line execution; New Gradle integration test infrastructure and utilities; New Gradle integration test infrastructure and wrapper update; New JUnit 5 integration test framework for Dokka Gradle Plugin; New content-matcher test utilities for validating Dokka documentation structure; New integration test utility library for validation and environment handling; New test fixtures for analyzing Kotlin and Java projects; New test-fixture utilities for Gradle project configuration and assertions; Updated expected HTML output for Android Kotlin Multiplatform integration test; Updated expected HTML output for multiplatform Android-JVM integration test; Updated test fixtures for multi-module project generation and Kotlin version.
Dependencies
New Gradle build infrastructure and integration test suite
The project introduces a new Gradle build structure with dedicated \build-logic\ and \build-settings-logic\ subprojects to centralize build conventions, plugin configuration (including Develocity and toolchain resolvers), and version catalog management. This change also adds a comprehensive \dokka-integration-tests\ module, which includes a CLI integration test suite and a Gradle integration test suite covering various project templates (Android, Multiplatform, Compose) and external libraries (kotlinx-io, kotlinx-datetime, kotlinx-coroutines, kotlinx-serialization). Additionally, a new \docs-developer\ module is added to build the developer documentation site using MkDocs.
(dependencies) · high confidence
Update Gradle wrapper to version 7.6.3
The \hide-internal-api\ example now uses Gradle 7.6.3 for its build execution, ensuring compatibility with the latest wrapper distribution and build environment.
examples/plugin/hide-internal-api/gradle · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 39 → 41 (+2.1)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 50 → 49 (-1.1)
- Architecture 97 → 96 (-0.4)
- Maturity 47 → 50 (+2.9)
- Readiness 43 → 47 (+3.2)
- Security 53 → 57 (+4.3)
- Accessibility 26 → 28 (+1.8)
- Performance 100 → 100 (+0.0)
Resolved (42)
- Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
- Duplicated block (10 lines × 2) (dokka-subprojects/analysis-kotlin-symbols/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/translators/DefaultSymbolToDocumentableTranslator.kt)
- Duplicated block (10 lines × 2) (dokka-subprojects/analysis-kotlin-symbols/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/translators/DefaultSymbolToDocumentableTranslator.kt)
- Duplicated block (11 lines × 2) (dokka-runners/dokka-gradle-plugin/src/main/kotlin/tasks/DokkaGenerateTask.kt)
- Duplicated block (11 lines × 2) (dokka-subprojects/analysis-java-psi/src/main/kotlin/org/jetbrains/dokka/analysis/java/util/PsiUtil.kt)
- Duplicated block (11 lines × 2) (dokka-subprojects/plugin-all-modules-page/src/main/kotlin/org/jetbrains/dokka/allModulesPage/AllModulesPageGeneration.kt)
- Duplicated block (12 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/pages/DefaultSamplesTransformer.kt)
- Duplicated block (13 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/pages/DefaultSamplesTransformer.kt)
- Duplicated block (16–17 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/pages/DefaultSamplesTransformer.kt)
- Duplicated block (21 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/renderers/DefaultRenderer.kt)
- Duplicated block (2–5 lines × 7) (dokka-subprojects/core/src/main/kotlin/org/jetbrains/dokka/transformers/documentation/DefaultDocumentableMerger.kt)
- Duplicated block (5 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/documentables/DocumentableReplacerTransformer.kt)
- Duplicated block (5 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/documentables/DocumentableReplacerTransformer.kt)
- Duplicated block (5 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/documentables/DocumentableReplacerTransformer.kt)
- Duplicated block (5 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt)
- Duplicated block (5 lines × 2) (dokka-subprojects/plugin-javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/signatures/JavadocSignatureProvider.kt)
- Duplicated block (5 lines × 4) (dokka-subprojects/analysis-kotlin-symbols/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/translators/DefaultSymbolToDocumentableTranslator.kt)
- Duplicated block (5 lines × 4) (dokka-subprojects/plugin-kotlin-as-java/src/main/kotlin/org/jetbrains/dokka/kotlinAsJava/transformers/JvmNameDocumentableTransformer.kt)
- Duplicated block (6 lines × 2) (dokka-subprojects/core/src/main/kotlin/org/jetbrains/dokka/transformers/documentation/DefaultDocumentableMerger.kt)
- Duplicated block (6 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/documentables/DocumentableReplacerTransformer.kt)
- …and 22 more
New (90)
- Duplicated block (10 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/signatures/KotlinSignatureProvider.kt)
- Duplicated block (11 lines × 2) (dokka-runners/dokka-gradle-plugin/src/main/kotlin/tasks/DokkaGenerateTask.kt)
- Duplicated block (11 lines × 2) (dokka-subprojects/analysis-java-psi/src/main/kotlin/org/jetbrains/dokka/analysis/java/util/PsiUtil.kt)
- Duplicated block (11 lines × 2) (dokka-subprojects/plugin-all-modules-page/src/main/kotlin/org/jetbrains/dokka/allModulesPage/AllModulesPageGeneration.kt)
- Duplicated block (11 lines × 4) (dokka-subprojects/analysis-kotlin-symbols/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/translators/DefaultSymbolToDocumentableTranslator.kt)
- Duplicated block (11–12 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt)
- Duplicated block (13 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/pages/DefaultSamplesTransformer.kt)
- Duplicated block (15 lines × 2) (dokka-subprojects/core/src/main/kotlin/org/jetbrains/dokka/model/Documentable.kt)
- Duplicated block (15 lines × 2) (dokka-subprojects/core/src/main/kotlin/org/jetbrains/dokka/model/Documentable.kt)
- Duplicated block (15 lines × 2) (dokka-subprojects/core/src/main/kotlin/org/jetbrains/dokka/model/Documentable.kt)
- Duplicated block (16–17 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/pages/DefaultSamplesTransformer.kt)
- Duplicated block (21 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/renderers/DefaultRenderer.kt)
- Duplicated block (21 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/signatures/KotlinSignatureProvider.kt)
- Duplicated block (25 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/pages/DefaultSamplesTransformer.kt)
- Duplicated block (2–5 lines × 7) (dokka-subprojects/core/src/main/kotlin/org/jetbrains/dokka/transformers/documentation/DefaultDocumentableMerger.kt)
- Duplicated block (5 lines × 2) (dokka-subprojects/analysis-kotlin-symbols/src/main/kotlin/org/jetbrains/dokka/analysis/kotlin/symbols/translators/DefaultSymbolToDocumentableTranslator.kt)
- Duplicated block (5 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/documentables/DocumentableReplacerTransformer.kt)
- Duplicated block (5 lines × 2) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/documentables/DocumentableReplacerTransformer.kt)
- Duplicated block (5 lines × 2) (dokka-subprojects/plugin-javadoc/src/main/kotlin/org/jetbrains/dokka/javadoc/signatures/JavadocSignatureProvider.kt)
- Duplicated block (5 lines × 3) (dokka-subprojects/plugin-base/src/main/kotlin/org/jetbrains/dokka/base/transformers/documentables/SuppressedByConditionDocumentableFilterTransformer.kt)
- …and 70 more
Changes since last survey
- 2 commits — 2 feature/other, 0 fixes
By area
- dokka-runners/dokka-gradle-plugin — 1 commit
- examples/gradle — 1 commit
Notable commits
- change: Remove 'api reference' from Gradle Plugin publishing (#4616)
- change: Update Dokka version references to 2.3.0 and Gradle to 9.8.2 in examples (#4617)
Architecture
- Containers 0 added · 0 removed · contexts 3 added · 3 removed · edges 13 added · 13 removed
Added bounded contexts (3)
- build-logic
- dokka-integration-tests/gradle/projects/it-android-compose/core
- dokka-subprojects/core
Removed bounded contexts (3)
- build-logic
- dokka-integration-tests/gradle/projects/it-android-compose/core
- dokka-subprojects/core
Added dependency edges (13)
- analysis-java-psi → dokka-subprojects/core (coupling)
- analysis-kotlin-api → dokka-subprojects/core (coupling)
- analysis-kotlin-symbols → dokka-subprojects/core (coupling)
- dokka-gradle-plugin → dokka-subprojects/core (coupling)
- plugin-all-modules-page → dokka-subprojects/core (coupling)
- plugin-base → dokka-subprojects/core (coupling)
- plugin-base-test-utils → dokka-subprojects/core (coupling)
- plugin-gfm → dokka-subprojects/core (coupling)
- plugin-javadoc → dokka-subprojects/core (coupling)
- plugin-kotlin-as-java → dokka-subprojects/core (coupling)
- plugin-templating → dokka-subprojects/core (coupling)
- plugin-versioning → dokka-subprojects/core (coupling)
- runner-cli → dokka-subprojects/core (coupling)
Removed dependency edges (was a dependency, now gone) (13)
- analysis-java-psi → dokka-subprojects/core (coupling)
- analysis-kotlin-api → dokka-subprojects/core (coupling)
- analysis-kotlin-symbols → dokka-subprojects/core (coupling)
- dokka-gradle-plugin → dokka-subprojects/core (coupling)
- plugin-all-modules-page → dokka-subprojects/core (coupling)
- plugin-base → dokka-subprojects/core (coupling)
- plugin-base-test-utils → dokka-subprojects/core (coupling)
- plugin-gfm → dokka-subprojects/core (coupling)
- plugin-javadoc → dokka-subprojects/core (coupling)
- plugin-kotlin-as-java → dokka-subprojects/core (coupling)
- plugin-templating → dokka-subprojects/core (coupling)
- plugin-versioning → dokka-subprojects/core (coupling)
- runner-cli → dokka-subprojects/core (coupling)
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
Kotlin/dokka was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit afb51334e4d057ce70b053e75379cee25971d8e1 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.