`](plugin_configuration_file.md#idea-plugin__depends) Element | Functionality | Product Compatibility |
|-----------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `com.intellij.modules.java` or `com.intellij.java`See [](#java) below.
| **Java** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | IntelliJ IDEA, Android Studio |
| `com.intellij.modules.androidstudio` | Android SDK Platform, Build Tools, Platform Tools, SDK Tools | Android Studio |
| `com.intellij.modules.cidr.lang` | **C, C++, Objective-C/C++** language PSI Model, Swift/Objective-C Interaction, Inspections, Intentions, Completion, Refactoring, Test Framework | AppCode, CLion |
| `com.intellij.modules.cidr.debugger` | Debugger Watches, Evaluations, Breakpoints, Inline Debugging | AppCode, CLion, RubyMine |
| `com.intellij.modules.appcode` or `com.intellij.appcode`See [](#appcodeclion) below.
| Xcode Project Model, CocoaPods, Core Data Objects, Device & Simulator Support | AppCode |
| `com.intellij.modules.clion` or `com.intellij.clion`See [](#appcodeclion) below.
| CMake, Profiler, Embedded Development, Remote Development, Remote Debug, Disassembly | CLion |
| `com.intellij.cidr.base` | Native Debugger Integration, Utility Classes, C/C++ Project Model/Workspace Support (OCWorkspace, CidrWorkspace, etc.), C/C++ Build and Run Support | AppCode, CLion |
| `com.intellij.database` | **Database Tools and SQL** language PSI Model, Inspections, Completion, Refactoring, Queries | DataGrip, IntelliJ IDEA Ultimate, AppCode, PhpStorm, PyCharm Professional, RubyMine, CLion, GoLand, Rider, and WebStorm if the Database Tools and SQL plugin is installed. |
| `org.jetbrains.plugins.go` | **Go** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | GoLand |
| `com.intellij.modules.python` | **Python** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | PyCharm, and other products if the Python plugin is installed. |
| `com.intellij.modules.rider` | Connection to **ReSharper** Process in Background | Rider |
| `com.intellij.modules.ruby` | **Ruby** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | RubyMine, and IntelliJ IDEA Ultimate if the Ruby plugin is installed. |
| `com.intellij.modules.ultimate` | Licensing | All commercial IDEs (IntelliJ IDEA Ultimate, PhpStorm, DataGrip, ...) |
| `com.intellij.swift` | **Swift** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | AppCode, CLion |
| `com.jetbrains.php` | **PHP** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | PhpStorm, and other products if the PHP plugin is installed. |
| `JavaScript` | **JavaScript** language PSI Model, Inspections, Intentions, Completion, Refactoring, Test Framework | WebStorm, and other products if the JavaScript plugin is installed. |
#### Java
The [Java language functionality](https://blog.jetbrains.com/platform/2019/06/java-functionality-extracted-as-a-plugin/) was extracted as a plugin in version 2019.2 of the IntelliJ Platform.
This refactoring separated the Java implementation from the other, non-language portions of the platform.
A dependency on the Java plugin (Plugin ID `com.intellij.java`) must be setup using [](plugin_dependencies.md).
#### AppCode/CLion
The [AppCode and CLion code was restructured](https://blog.jetbrains.com/clion/2020/12/migration-guide-for-plugins-2020-3/) in version 2020.3.
This refactoring extracted some functionalities into specific modules for easier maintainability and reuse between AppCode/CLion and other JetBrains IDEs.
Consequently, [dependencies](plugin_dependencies.md) on [AppCode](app_code.md) and [CLion](clion.md) functionalities are expressed differently in plugin.xml depending on the version of the IDE being targeted:
* Syntax for 2020.3 and later releases:
* plugin.xml (_allowable alternative_):
```xml
com.intellij.clion
```
* Gradle build script (_required_):
```kotlin
intellij {
plugins.set(listOf("com.intellij.clion"))
}
```
```groovy
intellij {
plugins = ['com.intellij.clion']
}
```
* Syntax _required_ for releases prior to 2020.3, _allowable_ in all releases:
* plugin.xml:
```xml
com.intellij.modules.clion
```
See also: [](clion.md).
* Syntax for 2020.3 and later releases:
* plugin.xml (_allowable alternative_):
```xml
com.intellij.appcode
```
* Gradle build script (_required_):
```kotlin
intellij {
plugins.set(listOf("com.intellij.appcode"))
}
```
```groovy
intellij {
plugins = ['com.intellij.appcode']
}
```
* Syntax _required_ for releases prior to 2020.3, _allowable_ in all releases:
* plugin.xml:
```xml
com.intellij.modules.appcode
```
See also: [](app_code.md).
## Exploring Module and Plugin APIs
Once the [dependency on a module or plugin](plugin_dependencies.md) is declared in plugin.xml, it's useful to explore the packages and classes available in that dependency.
The section below gives some recommended procedures for discovering what's available in a module or plugin on which a project depends.
These procedures assume a project has the Gradle build script and plugin.xml dependencies configured correctly.
### Exploring APIs as a Consumer
Exploring the available packages and classes in a plugin or module utilizes features in the IntelliJ IDEA IDE.
If the project is not up-to-date, [reimport the Gradle project](https://www.jetbrains.com/help/idea/work-with-gradle-projects.html#gradle_refresh_project) as a first step.
Reimporting the project will automatically update the dependencies.
In the Project Window, select Project View and scroll to the bottom to see [External Libraries](https://www.jetbrains.com/help/idea/project-tool-window.html#content_pane).
Look for the library `Gradle:unzipped.com.jetbrains.plugins:foo:`, where "foo" matches, or is similar to the contents of the [``](plugin_configuration_file.md#idea-plugin__depends) tags in plugin.xml or the [`intellij.plugins`](tools_gradle_intellij_plugin.md#intellij-extension-plugins) declaration in the Gradle build script.
The image below shows the External Libraries for the example plugin project configuration explained in [Configuring Gradle build script](dev_alternate_products.md#configuring-gradle-build-script-using-the-intellij-idea-product-attribute) and [Configuring plugin.xml](dev_alternate_products.md#configuring-pluginxml).
{width="700"}
Expand the External Library (as shown) to reveal the JAR files contained in the library.
Drill down into the JAR files to expose the packages and (decompiled) classes.
### Exploring APIs as an Extender
If a project is dependent on a plugin or module, in some cases, the project can also [extend](plugin_extensions.md) the functionality available from the plugin or module.
> See [Explore the IntelliJ Platform API](explore_api.md) for more information and strategies.
> Dedicated Extension Point Lists specific to IDEs are available under _Part VIII — Product Specific_.
>
To browse the opportunities for an extension, start by placing the cursor on the contents of the [``](plugin_configuration_file.md#idea-plugin__depends) elements in the project's plugin.xml file.
Use the [Go to Declaration](https://www.jetbrains.com/help/idea/navigating-through-the-source-code.html#go_to_declaration) IDE feature to navigate to the plugin.xml file for the plugin on which the project depends.
For example, performing this procedure on the `com.jetbrains.php` declaration in a project's plugin.xml file will navigate to the plugin.xml file for the `com.jetbrains.php` (PHP) project.
A common, but not universal, pattern in the IntelliJ Platform is for a plugin (like PHP) to declare [``](plugin_configuration_file.md#idea-plugin__extensionPoints) and then implement each one as [``](plugin_configuration_file.md#idea-plugin__extensions).
Continuing the example, search the PHP plugin's plugin.xml file for:
* `` to find the opportunities for extending the PHP plugin's functionality.
* `` to find where the PHP plugin extends functionality.
The extension namespace (in this example `com.jetbrains.php`) will match the [``](plugin_configuration_file.md#idea-plugin__id) defined in the plugin.xml file.
> If a dependency plugin [bundles its API sources](bundling_plugin_openapi_sources.md) in the distribution file, the Gradle IntelliJ Plugin (1.7.0+) will attach them to the plugin dependency in IDE, making sources available when navigating to the plugin API classes.
>
## Verifying Dependency
Before marking a plugin project as _dependent only on modules in a target product_ in addition to `com.intellij.modules.platform`, verify the plugin isn't implicitly dependent on any APIs that are specific to IntelliJ IDEA.
For [Gradle-based](developing_plugins.md) projects, [](verifying_plugin_compatibility.md#plugin-verifier) can be used to ensure compatibility with all specified target IDEs.
For DevKit-based projects, [create an SDK](setting_up_theme_environment.md#add-intellij-platform-plugin-sdk) pointing to an installation of the intended target IntelliJ Platform-based product, e.g., PhpStorm, rather than IntelliJ IDEA.
Use the same development version of the IntelliJ Platform as the targeted product.
Based on the tables above, the [JetBrains Marketplace](https://plugins.jetbrains.com/) automatically detects the JetBrains products with which a plugin is compatible, and makes the compatibility information available to plugin authors.
The compatibility information determines if plugins are available for users of a particular JetBrains product.
## Platform API Version Compatibility
The API of IntelliJ Platform and bundled plugins may change between releases.
The significant changes that may break plugins are listed on [Incompatible Changes in IntelliJ Platform and Plugins API](api_changes_list.md) page.