# Dependencies Extension

> For the complete documentation index, see [llms.txt](https://plugins.jetbrains.com/docs/intellij/llms.txt).

> **Tip: FAQ**
> See [IntelliJ Platform Gradle Plugin – FAQ](tools-intellij-platform-gradle-plugin-faq.html) and [Migrating from Gradle IntelliJ Plugin (1.x)](tools-intellij-platform-gradle-plugin-migration.html).

IntelliJ Platform Gradle Plugin enhances the `dependencies {}` configuration block by applying a nested `dependencies.intellijPlatform {}` extension.

This class provides methods for adding dependencies to different IntelliJ Platform [products](#default-target-platforms) and managing [local](#custom-target-platforms) dependencies.

It also includes methods for adding [plugins](#plugins) (including bundled), [JetBrains Runtime](#java-runtime), as well as [tools](#tools) like IntelliJ Plugin Verifier and Marketplace ZIP Signer.

> **Note:**
> Corresponding required repositories must be defined in the `repositories {}` section, see [Repositories Extension](tools-intellij-platform-gradle-plugin-repositories-extension.html).

Example:

* setup Maven Central and [defaultRepositories()](tools-intellij-platform-gradle-plugin-repositories-extension.html#default-repositories)

* target IntelliJ IDEA 2026.3

* add dependency on the bundled Java plugin

* add a JUnit4 test dependency

* add Test Framework for testing a plugin with JUnit4

Kotlin:

```KOTLIN
import org.jetbrains.intellij.platform.gradle.TestFrameworkType

repositories {
  mavenCentral()

  intellijPlatform {
    defaultRepositories()
  }
}

dependencies {
  intellijPlatform {
    intellijIdea("2026.3")

    bundledPlugin("com.intellij.java")

    testFramework(TestFrameworkType.Platform)
  }

  testImplementation("junit:junit:4.13.2")
  // other dependencies, e.g., 3rd-party libraries
}
```

Groovy:

```GROOVY
import org.jetbrains.intellij.platform.gradle.TestFrameworkType

repositories {
  mavenCentral()

  intellijPlatform {
    defaultRepositories()
  }
}

dependencies {
  intellijPlatform {
    intellijIdea '2026.3'

    bundledPlugin 'com.intellij.java'

    testFramework TestFrameworkType.Platform.INSTANCE
  }

  testImplementation 'junit:junit:4.13.2'
  // other dependencies, e.g., 3rd-party libraries
}
```

## Target Platforms

> **Warning:**
> Only one IntelliJ Platform dependency can be added to the project at a time.

### Default Target Platforms

See [Custom Target Platforms](#custom-target-platforms) for non-default targets.

| Function | Description |
| --- | --- |
| `androidStudio(version, configure = {})` | [Android Studio](android-studio.html) |
| `clion(version, configure = {})` | [CLion](clion.html) |
| `datagrip(version, configure = {})` | [DataGrip](data-grip.html) |
| `dataspell(version, configure = {})` | [DataSpell](https://www.jetbrains.com/dataspell/) |
| `fleetBackend(version, configure = {})` | [Fleet](https://www.jetbrains.com/fleet/) Backend |
| `gateway(version, configure = {})` | [Gateway](https://www.jetbrains.com/remote-development/gateway/) |
| `goland(version, configure = {})` | [GoLand](goland.html) |
| `intellijIdea(version, configure = {})` | [IntelliJ IDEA](idea.html) |
| `mps(version, configure = {})` | [MPS](https://www.jetbrains.com/mps/) |
| `phpstorm(version, configure = {})` | [PhpStorm](phpstorm.html) |
| `pycharm(version, configure = {})` | [PyCharm](pycharm.html) |
| `rider(version, configure = {})` | [Rider](rider.html) |
| `rubymine(version, configure = {})` | [RubyMine](rubymine.html) |
| `rustRover(version, configure = {})` | [RustRover](https://www.jetbrains.com/rust/) |
| `webstorm(version, configure = {})` | [WebStorm](webstorm.html) |

Notes:

* Writerside (`WRS`) is deprecated and no longer available as a target IntelliJ Platform.

* Aqua (`QA`) has been removed as a target IntelliJ Platform.

* IntelliJ IDEA Community (`IC`) and Ultimate (`IU`) legacy helpers remain available for versions earlier than 2025.3.

* PyCharm Community (`PC`) and Professional (`PY`) legacy helpers remain available for versions earlier than 2025.3.

### Legacy Target Platform Helpers

The following helpers are still available for resolving pre-2025.3 product lines:

| Function | Description |
| --- | --- |
| `intellijIdeaCommunity(version, configure = {})` | IntelliJ IDEA Community (`IC`) for versions earlier than 2025.3. |
| `intellijIdeaUltimate(version, configure = {})` | IntelliJ IDEA Ultimate (`IU`) for versions earlier than 2025.3. |
| `pycharmCommunity(version, configure = {})` | PyCharm Community (`PC`) for versions earlier than 2025.3. |
| `pycharmProfessional(version, configure = {})` | PyCharm Professional (`PY`) for versions earlier than 2025.3. |

### Custom Target Platforms

| Function | Description |
| --- | --- |
| `create(type, version, configure = {})` | Adds a configurable dependency on the IntelliJ Platform. See [Parametrize IntelliJ Platform Dependency](tools-intellij-platform-gradle-plugin.html#dependenciesParametrizePlatform). |
| `local(localPath)` | Adds a dependency on a local IntelliJ Platform instance. See [Local IntelliJ Platform IDE Instance](tools-intellij-platform-gradle-plugin.html#dependenciesLocalPlatform). |

### Dependency Configuration Parameters

The last argument passed to the dependency helpers is a `configure` closure that allows to configure the dependency. The following parameters can be specified:

| Parameter | Type | Description |
| --- | --- | --- |
| `type` | `IntelliJPlatformType` | The type of the IntelliJ Platform dependency (target product). |
| `version` | `String` | The version of the IntelliJ Platform dependency. |
| `productMode` | `ProductMode` | Describes a mode in which a product may be started. Default: `ProductMode.MONOLITH`. |
| `useInstaller` | `Boolean` | Switches between resolving the IDE installer and a multi-OS archive from the IntelliJ Maven repository. Default: `true`. |
| `useCache` | `Boolean` | Switches between the Gradle cache and a custom cache directory. Default: `false`. See `GradleProperties.IntellijPlatformIdesCache`. |

All of the above parameters support assignment of direct values and Provider instances.

When `productMode = ProductMode.FRONTEND`, the dependency resolves the matching JetBrains Client artifact. When `splitMode` is enabled or a non-`MONOLITH` `productMode` is requested, the IDE is extracted into the managed IDE cache even if `useCache` is disabled.

See also:

* [Types: IntelliJPlatformType](tools-intellij-platform-gradle-plugin-types.html#IntelliJPlatformType)

* [Types: ProductMode](tools-intellij-platform-gradle-plugin-types.html#ProductMode)

## Target Versions

The IntelliJ Platform Gradle Plugin allows for using two types of IntelliJ Platform artifacts for development: installers and multi-OS ZIP archives. Both have advantages and drawbacks, but in the 2.x releases, installers are now the default choice when setting up the project.

### Installers

When declaring a dependency on IntelliJ Platform, the IDE installer is resolved by default. The IntelliJ Platform installer is the IDE final distribution used by end-users for installing and running IDE in their machines. Those artifacts are resolved from JetBrains Download CDN (download.jetbrains.com) or Android Studio CDN.

Kotlin:

```KOTLIN
repositories {
  intellijPlatform {
    defaultRepositories()
  }
}

dependencies {
  intellijPlatform {
    intellijIdea("2026.3")
  }
}
```

Groovy:

```GROOVY
repositories {
  intellijPlatform {
    defaultRepositories()
  }
}

dependencies {
  intellijPlatform {
    intellijIdea '2026.3'
  }
}
```

The listing of all present installers can be resolved with updates XML files for [JetBrains IDEs](https://www.jetbrains.com/updates/updates.xml) and [Android Studio](https://jb.gg/android-studio-releases-list.xml) as well as by executing the [printProductsReleases](tools-intellij-platform-gradle-plugin-tasks.html#printProductsReleases) task.

IntelliJ Platform installers are OS-specific and contain bundled [JetBrains Runtime (JBR)](tools-intellij-platform-gradle-plugin-jetbrains-runtime.html), but are limited to public releases only.

To apply required repositories, use [Default Repositories](tools-intellij-platform-gradle-plugin-repositories-extension.html#default-repositories) or explicit [IntelliJ Platform Installers](tools-intellij-platform-gradle-plugin-repositories-extension.html#intellij-platform-installers) helpers.

### Multi-OS Archives

It is still possible to use Multi-OS ZIP archives resolved from [IntelliJ Maven Repositories](tools-intellij-platform-gradle-plugin-repositories-extension.html#intellij-maven-repositories).

To enable resolving this kind of artifacts, opt out from installer dependencies by setting `useInstaller = false` in the helper configuration:

Kotlin:

```KOTLIN
repositories {
  intellijPlatform {
    defaultRepositories()
  }
}

dependencies {
  intellijPlatform {
    intellijIdea("2026.3") {
      useInstaller = false
    }
  }
}
```

Groovy:

```GROOVY
repositories {
  intellijPlatform {
    defaultRepositories()
  }
}

dependencies {
  intellijPlatform {
    intellijIdea("2026.3") {
      useInstaller = false
    }
  }
}
```

The Multi-OS Archives don't bundle [JetBrains Runtime (JBR)](tools-intellij-platform-gradle-plugin-jetbrains-runtime.html) needed to run the IDE locally, perform testing, and other crucial operations. Therefore, it is required to explicitly add a dependency on JetBrains Runtime (JBR) by adding extra `jetbrainsRuntime()` repository and dependency entries.

It is advised to rely on installer releases, but targeting EAP multi-OS archives helps when making sure the plugin will work in the upcoming IDE releases.

To apply required repositories, use [Default Repositories](tools-intellij-platform-gradle-plugin-repositories-extension.html#default-repositories) or explicit [IntelliJ Maven Repositories](tools-intellij-platform-gradle-plugin-repositories-extension.html#intellij-maven-repositories) helpers.

### Latest Version

Set the version of an installer-based IntelliJ Platform dependency to `"latest"` (or the `Constraints.LATEST_VERSION` constant) to resolve the newest available release for the requested platform type. The version is resolved from the product releases listing across all channels for the requested type, picking the newest matching release by build number:

Kotlin:

```KOTLIN
import org.jetbrains.intellij.platform.gradle.Constants.Constraints

dependencies {
  intellijPlatform {
    intellijIdea("latest")
    // or:
    intellijIdea(Constraints.LATEST_VERSION)
  }
}
```

Groovy:

```GROOVY
dependencies {
  intellijPlatform {
    intellijIdea 'latest'
  }
}
```

The `"latest"` version works only with the installer distribution (the default `useInstaller = true`); combining it with `useInstaller = false` fails the build.

The same version value can be used for [custom testing configurations](tools-intellij-platform-gradle-plugin-testing-extension.html) registered with `intellijPlatformTesting`:

```KOTLIN
val runLatestIde = intellijPlatformTesting.runIde.register("runLatestIde") {
  type = IntelliJPlatformType.IntellijIdea
  version = "latest"
}
```

> **Warning:**
> Because the resolved version follows the latest release, the exact IntelliJ Platform used may change over time, which affects build reproducibility.

## Plugins

Make sure that required [plugin repositories](tools-intellij-platform-gradle-plugin-repositories-extension.html#plugin-repositories) are defined to access non-bundled plugins.

See also:

* [Plugin Dependencies](plugin-dependencies.html)

> **Tip: Bundled vs. Non-Bundled Plugins**
> Use the correct function depending on whether the targeted plugin is bundled with the Target Platform or not.

### Bundled Plugin

Use `bundledPlugin(id)` or `bundledPlugins(ids)` to add a dependency on the bundled plugin within the currently targeted IntelliJ Platform. The list of bundled plugin IDs is available via [printBundledPlugins](tools-intellij-platform-gradle-plugin-tasks.html#printBundledPlugins) task.

| Function | Description |
| --- | --- |
| `bundledPlugin(id)` | Adds a dependency on a bundled plugin. |
| `bundledPlugins(ids)` | Adds a dependency on multiple bundled plugins. |

### Bundled Modules

Use `bundledModule(id)` or `bundledModules(ids)` to add a dependency on an IntelliJ Platform bundled module. This is useful when a specific platform module is required on the classpath. The `id` value can be either a bundled module ID or a module alias exported by the target IDE, for example `com.intellij.modules.vcs`.

| Function | Description |
| --- | --- |
| `bundledModule(id)` | Adds a dependency on a bundled module or module alias. |
| `bundledModules(ids)` | Adds dependencies on multiple bundled modules or aliases. |

### Non-Bundled Plugin

Use `plugin(notation)` or `plugins(notations)` to add a dependency on a non-bundled plugin (for example, hosted on [JetBrains Marketplace](https://plugins.jetbrains.com)).

Parameter `notation` uses the following format:

* `pluginId:version` or

* `pluginId:version@channel`.

Alternatively, use:

* `plugin(id, version, group)` – where `group` may define a release channel, like `@eap`, or a full Maven coordinates group (defaults to `com.jetbrains.plugins`).

* `plugins(vararg notations)` / `plugins(List<String>)` – for multiple plugins.

The `group` parameter can also describe the release channel by prefixing the value with `@` character, like `@eap` or `@nightly`. The channel value is used to prepend the JetBrains Marketplace group and build `nightly.com.jetbrains.plugins`.

If defined explicitly, can be used along with any custom plugin repository, like `org.acme.plugins`.

| Function | Description |
| --- | --- |
| `plugin(id, version, group)` | Adds a dependency on a plugin. |
| `plugin(notation)` | Adds a dependency on a plugin. |
| `plugins(notations)` | Adds a dependency on multiple plugins. |

The `plugin(id, version, group)` and `plugin(notation)` functions accept an optional trailing configuration block for [excluding bundled libraries](#excluding-plugin-bundled-libraries) shipped with the plugin.

#### Excluding Plugin Bundled Libraries

A non-bundled plugin may ship libraries in its `lib/` and `lib/modules/` directories that conflict with the ones already provided by the target IntelliJ Platform or by the developed plugin. To exclude such files, pass a configuration block to `plugin(...)` and declare patterns with `excludeBundledLibrary(pattern)` or `excludeBundledLibraries(vararg patterns)`:

Kotlin:

```KOTLIN
dependencies {
  intellijPlatform {
    plugin("pluginId", "1.0.0") {
      excludeBundledLibrary("jena-*.jar")
    }
  }
}
```

Groovy:

```GROOVY
dependencies {
  intellijPlatform {
    plugin('pluginId', '1.0.0') {
      excludeBundledLibrary 'jena-*.jar'
    }
  }
}
```

The patterns use Gradle's Ant-style matching, relative to the plugin's `lib/` and `lib/modules/` directories, for example `jena-*.jar`. Exclusions apply consistently to both the project classpaths and the sandbox installations. Patterns declared for the same plugin ID are combined build-wide.

The same configuration block is available for the test-scope [testPlugin(...)](#test-scope-plugin-and-module-helpers) helpers.

### Compatible Plugins

Helpers that automatically pick a version compatible with the currently configured IntelliJ Platform by requesting the JetBrains Marketplace API. These helpers are incubating.

These resolve plugin versions against the target platform configured via this extension. Make sure the required [plugin repositories](tools-intellij-platform-gradle-plugin-repositories-extension.html#plugin-repositories) are defined.

| Function | Description |
| --- | --- |
| `compatiblePlugin(id)` | Adds a dependency on a compatible plugin. |
| `compatiblePlugins(ids)` | Adds a dependency on multiple compatible plugins. |

### Multi-Module Setup

When working on a multi-module project, use `pluginComposedModule(dependency)` to add a dependency on a plugin module to be bundled within the main plugin JAR. This will produce a single plugin Jar file with all submodules' classes composed:

```KOTLIN
pluginComposedModule(implementation(project(":submodule")))
```

In order to use the plugin model v2, use the `pluginModule(dependency)` instead, which will move the submodule's jar into the `lib/modules/` subdirectory.

```KOTLIN
pluginModule(implementation(project(":submodule")))
```

### Local Plugin

Use `localPlugin(localPath)` to add a dependency on a local IntelliJ Platform plugin. It accepts a path to a plugin directory/archive or a project dependency.

## Testing

To implement [tests](testing-plugins.html) for IntelliJ Platform plugin, it is necessary to explicitly add a dependency on the `test-framework` library containing the necessary test base classes. In most cases, the `TestFrameworkType.Platform` variant will be used:

Kotlin:

```KOTLIN
import org.jetbrains.intellij.platform.gradle.TestFrameworkType

dependencies {
  intellijPlatform {
    testFramework(TestFrameworkType.Platform)
  }

  testImplementation("junit:junit:4.13.2")
}
```

Groovy:

```GROOVY
import org.jetbrains.intellij.platform.gradle.TestFrameworkType

dependencies {
  intellijPlatform {
    testFramework TestFrameworkType.Platform.INSTANCE
  }

  testImplementation 'junit:junit:4.13.2'
}
```

See [TestFrameworkType](tools-intellij-platform-gradle-plugin-types.html#TestFrameworkType) reference for other test-frameworks, for example, `Plugin.Java` when testing Java-based functionality.

The provided helpers make it possible to add the base artifact to the test classpath or its variants, such as Java, Go, ReSharper, etc.

| Function | Description |
| --- | --- |
| `testFramework(type, version)` | Adds a dependency on Test Framework or its variant using [TestFrameworkType](tools-intellij-platform-gradle-plugin-types.html#TestFrameworkType) type. |
| `testFrameworks(vararg types)` | Adds dependencies on all provided Test Framework variants. Each version is selected to match the configured IntelliJ Platform build. |
| `testFrameworks(types: List<TestFrameworkType>)` | Adds dependencies on all Test Framework variants in the provided list. Each version is selected to match the configured IntelliJ Platform build. |

Use either plural overload to add multiple Test Framework variants at once:

Kotlin:

```KOTLIN
import org.jetbrains.intellij.platform.gradle.TestFrameworkType

dependencies {
  intellijPlatform {
    testFrameworks(
      TestFrameworkType.Platform,
      TestFrameworkType.Plugin.Java,
    )
    testFrameworks(
      listOf(
        TestFrameworkType.JUnit5,
        TestFrameworkType.Plugin.Maven,
      )
    )
  }
}
```

Groovy:

```GROOVY
import org.jetbrains.intellij.platform.gradle.TestFrameworkType

dependencies {
  intellijPlatform {
    testFrameworks(
      TestFrameworkType.Platform.INSTANCE,
      TestFrameworkType.Plugin.Java.INSTANCE
    )
    testFrameworks([
      TestFrameworkType.JUnit5.INSTANCE,
      TestFrameworkType.Plugin.Maven.INSTANCE
    ])
  }
}
```

The plural overloads do not accept an explicit version. To pin a specific version, call `testFramework(type, version)` separately.

> **Warning:**
> In rare cases when the bundled `$PLATFORM_PATH$/lib/testFramework.jar` library is required, attach it with [TestFrameworkType.Bundled](tools-intellij-platform-gradle-plugin-types.html#TestFrameworkType).

There are two known issues related to `Platform` and `JUnit5` Test Frameworks:

* [Missing opentest4j dependency in Test Framework](tools-intellij-platform-gradle-plugin-faq.html#missing-opentest4j-dependency-in-test-framework)

* [JUnit5 Test Framework refers to JUnit4](tools-intellij-platform-gradle-plugin-faq.html#junit5-test-framework-refers-to-junit4)

See also:

* [Types: TestFrameworkType](tools-intellij-platform-gradle-plugin-types.html#TestFrameworkType)

### Test-scope plugin and module helpers

The extension also provides helpers to add dependencies needed only for tests:

| Function | Description |
| --- | --- |
| `testPlugin(notation)` | Adds a test dependency on a non-bundled plugin using `pluginId:version` or `pluginId:version@channel` notation. |
| `testPlugins(vararg notations)` | Adds test dependencies on multiple non-bundled plugins. |
| `testBundledPlugin(id)` | Adds a test dependency on a bundled plugin by ID. |
| `testBundledPlugins(vararg ids)` | Adds test dependencies on multiple bundled plugins by IDs. |
| `testLocalPlugin(localPath)` | Adds a test dependency on a local plugin; accepts a path or a project dependency. |
| `testBundledModule(id)` | Adds a test dependency on a specific bundled platform module or module alias. |
| `testBundledModules(vararg ids)` | Adds test dependencies on multiple bundled platform modules or aliases. |

Provider and list-based overloads are available for the above helpers, mirroring their production-scope counterparts. The `testPlugin(...)` helpers also accept the same configuration block as [plugin(...)](#excluding-plugin-bundled-libraries) for excluding libraries bundled with the plugin.

## Sandbox Runtime Classpaths

The plugin uses dedicated resolvable configurations for dependencies copied to the developed plugin's `lib/` directory in a sandbox:

| Configuration | Description |
| --- | --- |
| `intellijPlatformSandboxRuntimeClasspath` | Extends the project's `runtimeClasspath` and supplies runtime dependencies for regular sandboxes, such as the one created by [prepareSandbox](tools-intellij-platform-gradle-plugin-tasks.html#prepareSandbox). |
| `intellijPlatformTestSandboxRuntimeClasspath` | Extends `intellijPlatformSandboxRuntimeClasspath` and `intellijPlatformTestRuntimeClasspath`, and supplies runtime dependencies for test sandboxes created by [prepareTestSandbox](tools-intellij-platform-gradle-plugin-tasks.html#prepareTestSandbox). |

Excluding a dependency from either configuration changes only the contents of the corresponding sandbox. It does not remove the dependency from the project's compile, runtime, or test classpaths. Because the test sandbox configuration extends the regular sandbox configuration, exclusions added to `intellijPlatformSandboxRuntimeClasspath` apply to both regular and test sandboxes. Configure `intellijPlatformTestSandboxRuntimeClasspath` instead when an exclusion should apply only to test sandboxes.

For example, the following keeps Joda-Time available to compile the plugin but prevents its JAR from being copied into either sandbox:

Kotlin:

```KOTLIN
dependencies {
  implementation("joda-time:joda-time:2.8.1")
}

configurations.named("intellijPlatformSandboxRuntimeClasspath") {
  exclude(group = "joda-time", module = "joda-time")
}
```

Groovy:

```GROOVY
dependencies {
  implementation 'joda-time:joda-time:2.8.1'
}

configurations.named('intellijPlatformSandboxRuntimeClasspath') {
  exclude group: 'joda-time', module: 'joda-time'
}
```

By default, both sandbox configurations exclude `org.jetbrains.kotlin:kotlin-stdlib`, `org.jetbrains.kotlin:kotlin-stdlib-jdk8`, and the known Kotlin Coroutines modules supplied by the IntelliJ Platform. The Coroutines exclusions cover the `org.jetbrains.kotlinx`, `com.intellij.platform`, and `org.jetbrains.intellij.deps.kotlinx` groups. Set [org.jetbrains.intellij.platform.useDefaultSandboxExclusions=false](tools-intellij-platform-gradle-plugin-gradle-properties.html#useDefaultSandboxExclusions) to opt out.

## Tools

| Function | Description |
| --- | --- |
| `pluginVerifier(version)` | Adds a dependency on [IntelliJ Plugin Verifier](verifying-plugin-compatibility.html). Applied by default and refers to the latest available tool's version. |
| `zipSigner(version)` | Adds a dependency on [Marketplace ZIP Signer](plugin-signing.html). Applied by default and refers to the latest available tool's version. |
| `bundledLibrary(path)` | SEE NOTE BELOW  Adds a dependency on a bundled library JAR file of the current IntelliJ Platform, like `lib/annotations.jar`.   |
| `platformDependency(coordinates, version)` | Adds a dependency on a custom IntelliJ Platform dependency available in the [IntelliJ Maven Repositories](tools-intellij-platform-gradle-plugin-repositories-extension.html#intellij-maven-repositories). If version is omitted, the closest compatible version is used. |
| `testPlatformDependency(coordinates, version)` | Adds a test dependency on a custom IntelliJ Platform dependency available in the [IntelliJ Maven Repositories](tools-intellij-platform-gradle-plugin-repositories-extension.html#intellij-maven-repositories). If version is omitted, the closest compatible version is used. |

> **Warning:**
> Do not use `bundledLibrary()` in production, as direct access to the IntelliJ Platform libraries is not recommended.
>
>
>
> It should only be used as a workaround in case the IntelliJ Platform Gradle Plugin is not aligned with the latest IntelliJ Platform classpath changes.

See also:

* [Verifying Plugin Compatibility](verifying-plugin-compatibility.html), [Tasks: verifyPlugin](tools-intellij-platform-gradle-plugin-tasks.html#verifyPlugin)

* [Plugin Signing](plugin-signing.html), [Tasks: signPlugin](tools-intellij-platform-gradle-plugin-tasks.html#signPlugin)

## Java Runtime

Using the `jetbrainsRuntime()` or `jetbrainsRuntimeExplicit()` dependency helpers, it is possible to load a custom version of JetBrains Runtime. However, it is recommended to rely on the runtime bundled within the IntelliJ Platform dependency, if present.

The `jetbrainsRuntime()` helper is applied by default and if JetBrains Runtime is not bundled within the currently used IntelliJ Platform, it refers the relevant runtime version automatically.

| Function | Description |
| --- | --- |
| `jetbrainsRuntime()`   | Adds a dependency on [JetBrains Runtime](ide-development-instance.html#using-a-jetbrains-runtime-for-the-development-instance) in version obtained with the current IntelliJ Platform if resolved from IntelliJ Maven Repository. |
| `jetbrainsRuntime(version, variant, architecture)`   | Adds a dependency on [JetBrains Runtime](ide-development-instance.html#using-a-jetbrains-runtime-for-the-development-instance). |
| `jetbrainsRuntimeLocal(path)`   | Adds a dependency on a local [JetBrains Runtime](ide-development-instance.html#using-a-jetbrains-runtime-for-the-development-instance) instance. |
| `jetbrainsRuntimeExplicit(explicitVersion)`   | Adds a dependency on [JetBrains Runtime](ide-development-instance.html#using-a-jetbrains-runtime-for-the-development-instance) in explicit version. |

See [JetBrains Runtime (JBR)](tools-intellij-platform-gradle-plugin-jetbrains-runtime.html) for more details.

## Code Instrumentation

The code instrumentation process handled with the [instrumentCode](tools-intellij-platform-gradle-plugin-tasks.html#instrumentCode) task requires extra dependencies to work and properly adjust the Java bytecode. The removed `instrumentationTools()` convenience helper is no longer necessary. You can still add and configure the dependencies separately if needed.

Adds a Java Compiler dependency for code instrumentation. The version is determined by the IntelliJ Platform build number. If the exact version is unavailable, the closest one is used, found by scanning all releases.

The `javaCompiler()` helper is applied by default and refers to the tool version close to the currently used IntelliJ Platform.

| Function | Description |
| --- | --- |
| `javaCompiler()`  `javaCompiler(version)`   | Adds a dependency on Java Compiler. |

* [instrumentCode](tools-intellij-platform-gradle-plugin-tasks.html#instrumentCode)

## Grammar and Parser Generation

Helpers for the [GrammarKit](tools-intellij-platform-gradle-plugin-plugins.html#grammarkit) plugin tasks.

| Function | Description |
| --- | --- |
| `grammarKit()`   `grammarKit(version)` | Adds a Grammar Kit dependency used by [generateParser](tools-intellij-platform-gradle-plugin-tasks.html#generateParser). |
| `jflex()`   `jflex(version)` | Adds a JFlex dependency used by [generateLexer](tools-intellij-platform-gradle-plugin-tasks.html#generateLexer). |

## Compose UI

| Function | Description |
| --- | --- |
| `composeUI()` | Adds the bundled modules required for working with Compose UI in the IntelliJ Platform. |

`composeUI()` is incubating and resolves bundled modules according to the target IDE build:

| Target build | Added modules |
| --- | --- |
| 2024.3+ | `intellij.libraries.skiko`, `intellij.platform.compose` |
| 2025.1+ | `intellij.libraries.compose.foundation.desktop`, `intellij.platform.jewel.foundation`, `intellij.platform.jewel.ui`, `intellij.platform.jewel.ideLafBridge` |
| 2025.3+ | `intellij.libraries.compose.runtime.desktop` |

## Dependency Exclusions

| Function | Description |
| --- | --- |
| `excludeKotlinStdlib()` | Excludes transitive Kotlin Standard Library artifacts from a dependency. |
| `excludeCoroutines()` | Excludes transitive Kotlin Coroutines artifacts from a dependency. |

> **Note: Something missing?**
> If a topic is not covered in the above sections, let us know via the Feedback widget displayed on the right, or [other channels](getting-help.html#problems-with-the-guide).
>
>
>
> Be specific about the topics and reasons for adding them and leave your email in case we need more details. Thanks for your feedback!