intellij-sdk-code-samples/reference_guide/intellij_artifacts.md

---
title: IntelliJ Platform Artifacts Repositories
---

> **WARNING** When using additional repositories, make sure to use HTTPS always.

JetBrains maintains public repositories that host artifacts related to the IntelliJ Platform, such as binaries and source code. These 
repositories make artifacts more accessible for plugin developers.

The IntelliJ Platform artifacts repositories are:
* [Releases repository](https://www.jetbrains.com/intellij-repository/releases/) for release and EAP versions.
* [Snapshots repository](https://www.jetbrains.com/intellij-repository/snapshots/) for EAP candidates and the latest EAP for each branch.

Both the Releases and Snapshots repositories have two types of content:
* Binary and source code artifacts for cross-platform, ZIP distributions of IntelliJ Platform-based IDEs, such as IntelliJ IDEA, CLion, Rider, and MPS.
These artifacts are _not intended_ to be accessed directly from a plugin project's `build.gradle` file. 
The `gradle-intellij-plugin` will access them as-needed for a plugin project.
* Artifacts for individual modules from the IntelliJ Platform. 
These may be downloaded, or accessed directly from a `build.gradle` file, as explained below.
  
Artifacts for IntelliJ Platform third-party dependencies are hosted at the [Bintray repository](https://jetbrains.bintray.com/intellij-third-party-dependencies). 
A link to this repository should be added to `pom.xml`/`build.gradle` files when individual modules from an IntelliJ Platform artifacts repository are used.    

## Using IntelliJ Platform Module Artifacts
IntelliJ Platform module artifacts are utilized by adding information to a project's `build.gradle` file. 
More information about [Gradle support](https://www.jetbrains.com/help/idea/gradle.html) is available in the IntelliJ IDEA Help documentation. 

To setup dependencies on a module there are two types of information needed:
1. Specify the corresponding repository URL for the artifact.
2. Specify the [Maven coordinates](https://maven.apache.org/pom.html#Maven_Coordinates) for the artifact. 
 
### Specify the Repository URL 
The URL for the desired artifact needs to be added to a Maven or Gradle script:
* For release or EAP versions, use `https://www.jetbrains.com/intellij-repository/releases` 
* For EAP candidate snapshots, use `https://www.jetbrains.com/intellij-repository/snapshots`
* For dependencies on individual modules from the IntelliJ Platform, also use `https://jetbrains.bintray.com/intellij-third-party-dependencies` 

### Specify the Maven Coordinates for the Artifact
Describing a desired IntelliJ Platform module artifact is done with Maven coordinates: _groupId_, _artifactId_, and _version_.
The Maven coordinates are based on the names of modules.

The _groupId_ for a module is the prefix `com.jetbrains.` concatenated with the first two parts of the module name.  
For example, the module `intellij.xml` would have the groupId `com.jetbrains.intellij.xml`. 

The _artifactId_ is the second.._n_ parts of the module name separated by "-" characters.  
For example, the module `intellij.xml` would have the artifactId `xml`.
There are some special cases to artifactId names. 
If the second part of the module name is a common group like `platform`, `vcs`, or `cloud`, the second part of the module name is dropped, and the artifactId becomes the third.._n_ parts of the module name, separated by "-" characters.
Portions of the module name expressed in `camelCase` format are divided and used in the artifactId as (all lower case) `camel-case`.  

The table below shows some example module names and their corresponding groupId and artifactId.

| Module Name                    | groupId                         | artifactId |
|--------------------------------|---------------------------------|----------------|
|intellij.java.compiler.antTasks | com.jetbrains.intellij.java     | java-compiler-ant-tasks |
|intellij.java.debugger          | com.jetbrains.intellij.java     | java-debugger |
|intellij.platform.util          | com.jetbrains.intellij.platform | util |
|intellij.platform.vcs.log       | com.jetbrains.intellij.platform | vcs-log |
|intellij.spring                 | com.jetbrains.intellij.spring   | spring |
|intellij.xml.impl               | com.jetbrains.intellij.xml      | xml-impl |

The artifact _version_ can be specified in one of several ways because each artifact [at the Repository URLs](#specify-the-repository-url) has multiple versions available: 
* A branch build is specified as _BRANCH.BUILD[.FIX]_. For example, a branch build such as `141.233`, or a branch build with a fix such as `139.555.1`
* Release numbers are specified as _MAJOR[.MINOR][.FIX]_. For example `14`, or `14.1`, or `14.1.1`
* A snapshot of a branch from which the next EAP/release build will be produced is specified as _BRANCH-EAP-SNAPSHOT_. For example `141-EAP-SNAPSHOT`

### Example Artifact Specification
For example, to specify the `jps-model-serialization` module:
  * _groupId_ = `com.jetbrains.intellij.platform`
  * _artifactId_ = `jps-model-serialization`
  * _classifier_ = `""`
  * _packaging_ = `jar`


## Gradle Example for an Individual Module from the IntelliJ Platform
This section presents an example of using a Gradle script to incorporate an IntelliJ Platform module and repository in a `build.gradle` file. 
The example illustrates declaring the artifact URL, Maven coordinates, and version for the `jps-model-serialization` module artifact.
There are two parts to the example: the repository and the dependency sections.

### Repositories Section  
This code snippet selects the release repository with the first URL, and repository of IntelliJ Platform dependencies with the second URL.
The second URL is needed because this example selects individual modules. 
```groovy
repositories {
	maven { url "https://www.jetbrains.com/intellij-repository/releases" }
	maven { url "https://jetbrains.bintray.com/intellij-third-party-dependencies" }
}
```

### Dependencies Section  
This code snippet specifies the desired module artifacts.
```groovy
dependencies {
	compile "com.jetbrains.intellij.platform:jps-model-serialization:182.2949.4"
	compile "com.jetbrains.intellij.platform:jps-model-impl:182.2949.4"
}
```
Note:
 * The artifact version (`182.2949.4`) must match in both statements.
 * In this example `jps-model-serialization` declares the APIs and `jps-model-impl` provides the implementation, so both
   are required dependencies.

<!--
Save until after review.
#### Legacy Artifacts
The table below describes the groupId and artifactId for **Legacy** artifacts published at IntelliJ Platform artifacts repositories.
These artifacts will continue to be published using these groupId and artifactId. 
The [version](#specifying-version) specification below still apply to these legacy artifacts.

| **groupId** | **artifactId** | **Description** |
|-------------|----------------|-----------------|
|com.jetbrains.intellij.idea | ideaIC | Full zip distribution of IDEA Community |
|com.jetbrains.intellij.idea | ideaIU | Full zip distribution of IDEA Ultimate |
|org.jetbrains.intellij.deps | trove4j | Third-party dependencies of IntelliJ IDEA project |
|org.jetbrains | annotations | Old versions of IDEA annotations |
|com.intellij | javac2 | Old versions of javac2 Ant tasks |
|org.jetbrains.intellij | plugin-repository-rest-client | JetBrains plugin repository client |
|org.jetbrains.kotlin | kotlin-stdlib | Kotlin artifacts |
|org.jetbrains.teamcity | teamcity-rest-client | TeamCity rest client |
-->