intellij-sdk-code-samples/topics/basics/getting_started/publishing_plugin.md

Publishing a Plugin

Publishing a plugin to JetBrains Marketplace manually or with Gradle IntelliJ Plugin.

When a plugin is ready, it can be published to the JetBrains Marketplace plugin repository so that other users can install it in their IDE.

The first plugin publication must always be uploaded manually.

Before publishing a plugin, make sure it:

• follows all recommendations from
• follows all requirements from Plugin Overview page

The Busy Plugin Developers. Episode 2 discusses 5 tips for optimizing JetBrains Marketplace plugin page in more detail.

See also about widgets and badges.

When publishing a plugin to a repository other than the JetBrains Marketplace, refer to the documentation.

If a plugin ships with additional libraries, do not repackage them into the main plugin archive. Otherwise, Plugin Verifier will yield false positives for unresolved classes and methods.

{style="warning"}

Uploading a Plugin to JetBrains Marketplace

Before publishing a plugin, make sure it is signed. For more details on generating a proper certificate and configuring the signing process, check the Plugin Signing article.

To upload a plugin to the JetBrains Marketplace, log in with your personal JetBrains Account.

1. Open the JetBrains Account Center and click Create Account.
2. Fill in all fields in the Create JetBrains Account form that opens and click Register.

To upload a plugin to JetBrains Marketplace:

1. Log in to JetBrains Marketplace with your personal JetBrains account.
2. On the Profile page that opens, click Add new plugin.
3. Fill in the Add new plugin form that opens and click the Add the plugin button to upload the plugin.

See also Marketplace Docs.

Uploading a New Version

New versions can be uploaded manually on the plugin's detail page, see Marketplace Docs for details.

Publishing Plugin With Gradle

Once Gradle support has been configured, and the plugin has been uploaded to the plugin repository at least once, it can be built and deployed to the JetBrains Marketplace automatically.

Building Distribution

For initial upload, manual distribution or local installation, invoke the buildPlugin Gradle task to create the plugin distribution. If the project is configured to rely on , use the signPlugin task instead.

The resulting ZIP file is located in build/distributions and can then be installed via Install Plugin from Disk... action or uploaded to a .

Providing Your Personal Access Token to Gradle

To deploy a plugin to the JetBrains Marketplace, supply the Personal Access Token which can be found 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.

Copy it before closing this page and keep it in a secure location. This is the only time the token is visible.

{style="warning"}

This section describes two options to supply the 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'

On macOS systems, environment variables set in .bash_profile are only visible to processes run from bash. Environment variables visible to all processes need to be defined in Environment.plist.

{style="note"}

Now provide the environment variable in the run configuration for running the publishPlugin task locally. To do so, create a Gradle run configuration (if not already done), select the 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 it's still required to put some default values (can be empty) in the Gradle properties. Otherwise, there can be a compilation error.

Using Parameters for the Gradle Task

Like using environment variables, the token can also be passed as a parameter to the Gradle task. For example, provide the parameter

-Dorg.gradle.project.intellijPublishToken=YOUR_TOKEN

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

Note that in this case also, it's still required to put some default values (can be empty) in the Gradle properties

Deploying a Plugin with Gradle

The first step when deploying a plugin is to confirm that it works correctly. Verify this by installing the plugin from disk in a fresh instance of the 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 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 the plugin to the JetBrains Marketplace, invoke the publishPlugin Gradle task.

Now check the most recent version of the plugin on the JetBrains Marketplace. If successfully deployed, any users who currently have this 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

It's possible to deploy plugins to a chosen release channel 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, it's possible to 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 the plugin. For example, when specifying publishPlugin.channels = ['canary'], then users will need to add the https://plugins.jetbrains.com/plugins/canary/list repository to install the plugin and receive updates.

Popular channel names include:

• alpha: https://plugins.jetbrains.com/plugins/alpha/list
• beta: https://plugins.jetbrains.com/plugins/beta/list
• eap: https://plugins.jetbrains.com/plugins/eap/list

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