IntelliJ Platform Plugin SDK Help

Publishing Plugins with Gradle

Once you have configured Gradle support, you can automatically build and deploy your plugin to the JetBrains Marketplace. To automatically deploy a plugin, you need to have already published the plugin to the plugin repository at least once. Please see the guide page for manually publishing a plugin for the first time and Building Distribution on obtaining the initial plugin distribution artifact.

Building Distribution

For initial upload, manual distribution or local installation, invoke the buildPlugin Gradle task to create the plugin distribution. The resulting ZIP file is located in build/distributions and can then be installed via drag & drop (or using plugin manager) or uploaded to a custom plugin repository.

Providing Your Personal Access Token to Gradle

To deploy a plugin to the JetBrains Marketplace, you need to supply your Personal Access Token, which you can find on your profile page, in My Tokens section.

To create a new token, provide its name and click the Generate Token button. A new token will be created and displayed right below.

This section describes two options to supply your Personal Access Token via Gradle using:

  • Environment variables,

  • Parameters to the Gradle task.

Using Environment Variables

Start by defining an environment variable such as:

export ORG_GRADLE_PROJECT_intellijPublishToken='YOUR_TOKEN'

Now provide the environment variable in the run configuration with which you run the publishPlugin task locally. To do so, create a Gradle run configuration (if not already done), choose your Gradle project, specify the publishPlugin task, and then add the environment variable.

publishPlugin { token.set(System.getenv("ORG_GRADLE_PROJECT_intellijPublishToken")) }
publishPlugin { token = System.getenv("ORG_GRADLE_PROJECT_intellijPublishToken") }

Note that you still need to put some default values (can be empty) in the Gradle properties because otherwise, you will get a compilation error.

Using Parameters for the Gradle Task

Like using environment variables, you can also pass your token as a parameter to the Gradle task. For example, you can provide the parameter


on the command line or by putting it in the arguments of your Gradle run configuration.

Note that also, in this case, you still need to put some default values in your Gradle properties.

Deploying a Plugin with Gradle

The first step when deploying a plugin is to confirm that it works correctly. You may wish to verify this by installing your plugin from disk on a fresh instance of your target IDE(s).

Signing a Plugin

The Marketplace signing is designed to ensure that plugins are not modified over the course of the publishing and delivery pipeline. In version 1.x, the Gradle IntelliJ Plugin provides the signPlugin task, which will be executed automatically right before the publishPlugin.

For more details on generating a proper certificate and configuring the signPlugin task, check the Plugin Signing article.

Publishing a Plugin

Once you are confident the plugin works as intended, make sure the plugin version is updated, as the JetBrains Marketplace won't accept multiple artifacts with the same version.

To deploy a new version of your plugin to the JetBrains Marketplace, invoke the publishPlugin Gradle task.

Now check the most recent version of your plugin on the JetBrains Marketplace. If successfully deployed, any users who currently have your plugin installed on an available version of the IntelliJ Platform are notified of a new update available as soon as the update has been verified.

Specifying a Release Channel

You may also deploy plugins to a release channel of your choosing, by configuring the publishPlugin.channels property. For example:

publishPlugin { channels.set(listOf("beta")) }
publishPlugin { channels = ['beta'] }

When empty, this uses the default plugin repository, available to all JetBrains Marketplace users. However, you can publish it to an arbitrarily-named channel. These non-default release channels are treated as separate repositories.

When using a non-default release channel, users need to configure a new custom plugin repository in their IDE to install your plugin. For example, if you specify publishPlugin.channels = ['canary'], then users need to add the repository to install the plugin and receive updates.

Popular channel names include:

  • alpha:

  • beta:

  • eap:

More information about the available configuration options is in the documentation of the IntelliJ Gradle Plugin.

Last modified: 08 August 2022