Kotlin/dokka

Dokka is a multi-platform documentation engine for Kotlin and Java that generates API documentation from source code. It supports multiple build integrations, including Gradle and Maven, and produces output in various formats such as HTML, Javadoc, and GitHub Flavored Markdown. The system handles complex project structures, including multi-module and Kotlin Multiplatform setups, while providing features like versioning, custom plugin extensibility, and interactive code samples.

64 changes.

This period focused on migrating Dokka's core analysis engine to the Kotlin K2 symbols-based infrastructure and restructuring the project into a modular plugin architecture. It introduced new output formats like GFM and Javadoc, established comprehensive integration test suites, and added extensive example projects to demonstrate multiplatform and plugin development capabilities.

59 changes.

This period focused on migrating the Dokka Gradle Plugin to the new v2 architecture, making it the default while deprecating the legacy v1 engine. The work included implementing a modular task structure, new configuration models, and comprehensive integration tests for multiplatform and Android projects. Additionally, the frontend UI kit was updated with new design tokens and components, requiring corresponding updates to test baselines and expected HTML outputs.

10 changes.

This period focused on expanding the integration test suite to cover external libraries like kotlinx-datetime and kotlinx-io, while updating baselines for multiplatform and Android-JVM scenarios. It also introduced new plugin capabilities, including a custom plugin example for hiding internal APIs and a Kotlin Playground plugin for interactive code samples.

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

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

A new example demonstrates how to configure a custom Dokka plugin that excludes code annotated with a specific marker from generated documentation. The example includes a \HideInternalApiPlugin\ implementation that filters documentables based on a configurable annotation fully-qualified name, along with a sample library containing the \@HideFromDokka\ annotation to illustrate the integration.

demo-library, dokka-plugin-hide-internal-api, examples/gradle-v2/custom-dokka-plugin-example/dokka-plugin-hide-internal-api · high confidence

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

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

The core module now includes a standard OSGi-style MANIFEST.MF file and a dokka-version.properties file under META-INF. The properties file exposes the current Dokka version via the ${dokkaVersion} placeholder, enabling runtime or build-time introspection of the library version, while the manifest provides basic bundle metadata.

dokka-subprojects/core/src/main/resources · high confidence

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

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

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

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

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

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

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

The Dokka core module has been reorganized, introducing a new plugin architecture via \CoreExtensions\ that exposes extension points for the generation pipeline (source translation, merging, transformation, and rendering). This change adds a \DokkaBootstrap\ interface for external integration, new API visibility annotations (\DelicateDokkaApi\, \ExperimentalDokkaApi\, \InternalDokkaApi\) to manage stability, and utility functions for JSON configuration serialization and content node transformation. It also standardizes logging behavior through a new \DokkaLogger\ interface and introduces a \CleanUpAction\ extension point to ensure resources are released even if generation fails.

dokka-subprojects/core/src/main/kotlin · high confidence

New Kotlin source files have been added to the Gradle and Maven example projects, including a Greeter class for the custom format, Kotlin-as-Java, library publishing, and Maven examples, as well as module-specific classes for the multimodule example.

(repo-wide) · high confidence

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

This change establishes the foundational structure for the Dokka project by adding essential documentation and configuration files. It introduces a comprehensive README with setup instructions for Gradle, Maven, and Android, alongside CONTRIBUTING and CODE\_OF\_CONDUCT guidelines. The project now includes standard license files (LICENSE.txt, NOTICE.txt) and a .gitignore to manage build artifacts and IDE files. Additionally, it configures Git attributes (.gitattributes) to handle line endings consistently across scripts and source code, and adds the Gradle wrapper scripts (gradlew, gradlew.bat) to enable building the project without a pre-installed Gradle. The legacy IntelliJ module file (dokka.iml) is removed in favor of the Gradle-based build system.

(repo-wide) · high confidence

This change adds the core implementation for the new Kotlin symbols analysis engine within the \analysis-kotlin-symbols\ module. It introduces the \KotlinAnalysis\ context for managing Analysis API sessions, \DefaultSymbolToDocumentableTranslator\ to map Kotlin symbols to Dokka's documentable model, and \SymbolExternalDocumentablesProvider\ for resolving external class-like symbols. It also includes \KtPsiDocumentableSource\ for source location tracking, \SymbolSampleAnalysisEnvironment\ for resolving and rewriting \@sample\ links, and new KDoc parsing classes (\KotlinDocComment\, \DescriptorDocumentationContent\, \KotlinInheritDocTagContentProvider\) to handle documentation content resolution. This infrastructure enables Dokka to use the Kotlin Analysis API (K2) for symbol resolution and documentation extraction.

analysis-kotlin-symbols · high confidence

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

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

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

This release introduces a new GitHub Flavored Markdown (GFM) output format, implemented via the \GfmPlugin\ and \GfmTemplateProcessingPlugin\, which renders documentation as Markdown files using a \CommonmarkRenderer\ and supports template-based link resolution. It also adds an \AndroidDocumentationPlugin\ that filters out Android-specific \@hide\-tagged members from the generated documentation, and includes a new CLI argument type for specifying the output platform.

(repo-wide) · high confidence

The plugin-base module now includes a complete new HTML rendering pipeline, introducing a configurable \DokkaBaseConfiguration\ that allows users to specify custom style sheets, custom assets, a footer message, and a homepage link. This new rendering system adds an 'All Types' page to the generated documentation, implements a new navigation structure with icons and accessibility features, and installs the necessary scripts, styles, and assets (including new UI kit resources) to support the updated look and feel.

plugin-base · high confidence

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

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

A new Dokka plugin, \plugin-kotlin-playground-samples\, has been added to enable runnable Kotlin code samples in generated documentation. This plugin introduces a \KotlinPlaygroundSamplesTransformer\ that processes \@sample\ annotations to inject interactive playground code blocks, and installers that embed the necessary JavaScript and CSS resources. Users can configure the plugin to use a custom Kotlin Playground script URL or a custom backend server via \kotlinPlaygroundScript\ and \kotlinPlaygroundServer\ configuration options. The plugin is designed to replace the default samples transformer, providing enhanced interactivity for code examples.

dokka-subprojects/plugin-kotlin-playground-samples, plugin-kotlin-playground-samples · high confidence

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

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

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

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

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

The \plugin-all-modules-page\ module now provides the core logic for generating a unified 'All Modules' documentation page. This includes \AllModulesPageGeneration\ to orchestrate the creation, transformation, and rendering of the page, \MultimoduleLocationProvider\ to handle URL resolution for the aggregated index, and \ExternalModuleLinkResolver\ to correctly resolve links to external modules, including a fix for disambiguating local modules with identical package names.

plugin-all-modules-page · high confidence

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

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

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

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

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

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

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

The core module introduces a new \DokkaSourceSetID\ to uniquely identify source sets by scope and name, replacing previous equality logic and enabling the \CompositeSourceSetID\ used by \DisplaySourceSet\ to merge multiple source sets. The \Platform\ enum is extended with \wasmWasi\ and \wasmJs\ (deprecating the generic \wasm\), and the \Callable\ model gains an \isProperty\ flag and \contextParameters\ to correctly distinguish properties from functions and support context parameters in signatures. Documentation rendering is enhanced with new \DocTag\ types for \\<mark\>\, \\<h4\>\, \\<h5\>\, and \\<h6\>\, and the \Annotations\ model is updated to support merging by source set and distinguishing between direct and file-level scopes.

core · high confidence

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

The Dokka Gradle Plugin has shifted its default behavior to use the new V2 architecture, replacing the legacy V1 engine. This change is managed by the new \PluginFeaturesService\, which detects the plugin mode and logs a deprecation warning if users are still on V1. The V2 implementation introduces a new \KotlinAdapter\ that automatically registers Kotlin source sets as Dokka source sets, improving integration with Kotlin Multiplatform and Android projects. It also adds support for new platforms like WasmWasi and WasmJs, and includes lifecycle tasks for generating documentation formats. Users migrating from V1 may see changes in how source sets are processed and may need to update their configuration to align with the new V2 defaults.

dokka-gradle-plugin · high confidence

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

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

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

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

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

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

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

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

The Javadoc plugin has been completely rewritten to use the Korte templating engine instead of the previous implementation. This introduces a new rendering pipeline (KorteJavadocRenderer) that maps Dokka content nodes to Korte templates, adds a new set of page and content node models (JavadocContentNodes, JavadocPageNodes), and includes a new search index generator (SearchScriptsCreator). The plugin now strictly supports only JVM source sets and will reject multiplatform configurations.

plugin-javadoc · high confidence

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

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

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

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

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

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

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

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

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

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

The Dokka Gradle Plugin now includes new internal adapter components to better integrate with Gradle's build ecosystem. The new AndroidAdapter discovers Android Gradle Plugin configuration to correctly set up source roots and classpaths for Android projects, including specific handling for AGP version 9+ to avoid known bugs. The JavaAdapter automatically registers Dokka source sets for standard Java projects while suppressing duplicates if Android or Kotlin plugins are already present. Additionally, a TransformedMetadataDependencyProvider has been added to work around a Kotlin Gradle Plugin issue (KT-80551) where metadata compilations are missing for shared Wasm targets, ensuring Dokka can access shared symbols like kotlin.AutoCloseable.

dokka-runners/dokka-gradle-plugin/src/main/kotlin/adapters · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The versioning plugin has been restructured to support specifying a custom folder name for older versions via the new \olderVersionsDirName\ configuration property (defaulting to "older"). The plugin now filters non-directory and hidden files when scanning for previous versions, ensuring only valid version directories are included. Additionally, a new \ReplaceVersionCommandHandler\ manages version navigation rendering, and version ordering can be customized via configuration or defaults to semantic versioning sorting.

plugin-versioning · high confidence

The versioning plugin has been restructured to introduce a new HTML-based version selector dropdown and improved handling of older documentation versions. A new \DefaultPreviousDocumentationCopyPostAction\ now copies previous version assets to the output directory, respecting a configurable \olderVersionsDirName\ to exclude specific folders. The UI is driven by \HtmlVersionsNavigationCreator\, which generates a styled dropdown (supported by new \multimodule.css\) that allows users to switch between documentation versions, including a fallback \not-found-version.html\ page for missing content. The plugin wiring in \VersioningPlugin\ has been updated to register these new components, including the command consumer for replacing version links and the page transformers for installing styles and the not-found page.

dokka-subprojects/plugin-versioning · high confidence

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

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 core model and configuration utilities; 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.

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

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 watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 49 → 43 (-6.7)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 67 → 68 (+0.5)
• Architecture 100 → 98 (-2.1)
• Maturity 73 → 70 (-3.8)
• Readiness 42 → 42 (-0.3)
• Security 42 → 55 (+13.2)
• Accessibility 62 → 28 (-33.4)
• Performance 100 (new)

• Documentation: no installation or build instructions (dokka-subprojects/plugin-jekyll/README.md)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [CVE redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• …and 40 more

• High CVE: [GHSA redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [GHSA redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [GHSA redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [GHSA redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [GHSA redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [GHSA redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [GHSA redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High CVE: [GHSA redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High vulnerability: [GHSA redacted] (dokka-subprojects/plugin-base-frontend/package-lock.json)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 93 more

• 3 commits — 2 feature/other, 1 fixes

• dokka-runners/dokka-gradle-plugin — 1 commit
• dokka-subprojects/analysis-kotlin-symbols — 1 commit
• dokka-subprojects/plugin-base — 1 commit

• fix: Fix top-level callable external links (KT-89467, #3891) (#4605)
• change: Drop usages of Configuration.isVisible on Gradle 9+ as it's no-op there, as well as it's deprecated for removal (#4601)
• change: Resolve KDoc links to constructor value parameters (#4604)

• Containers 0 added · 0 removed · contexts 41 added · 1 removed · edges 41 added · 0 removed

• analysis-java-psi
• analysis-kotlin-api
• analysis-kotlin-symbols
• basic-gradle-example
• build-logic
• cli
• core
• custom-styling-example
• demo-library
• dokka-customFormat-example
• dokka-gradle-example
• dokka-gradle-plugin
• dokka-kotlinAsJava-example
• dokka-library-publishing-example
• dokka-plugin-hide-internal-api
• gradle
• it-basic
• it-basic-groovy
• it-js-ir-0
• it-kotlin-jvm
• …and 21 more

• hide-internal-api

• analysis-java-psi → core (coupling)
• analysis-kotlin-api → core (coupling)
• analysis-kotlin-symbols → analysis-java-psi
• analysis-kotlin-symbols → analysis-kotlin-api
• analysis-kotlin-symbols → core (coupling)
• dokka-gradle-plugin → core (coupling)
• dokka-plugin-hide-internal-api → core
• dokka-plugin-hide-internal-api → plugin-base
• plugin-all-modules-page → analysis-kotlin-api
• plugin-all-modules-page → core (coupling)
• plugin-all-modules-page → plugin-base
• plugin-all-modules-page → plugin-templating (coupling)
• plugin-android-documentation → core
• plugin-android-documentation → plugin-base
• plugin-base → analysis-kotlin-api
• plugin-base → core (coupling)
• plugin-base-test-utils → core (coupling)
• plugin-base-test-utils → plugin-base
• plugin-gfm → core (coupling)
• plugin-gfm → plugin-base
• …and 21 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

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.