> ## Documentation Index
> Fetch the complete documentation index at: https://openidea.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# Publish to the marketplace

> How the default marketplace is built, official versus community plugins, and how to list your plugin through the community registry.

The IDE's default marketplace is the `plugins-index.json` attached to the latest OpenIDEA release. Users browse it in **Settings › Plugins › Available**, filter by category, and install with one click. It lists two kinds of plugins.

| | Official | Community |
| - | - | - |
| Ids | `openidea.*` | The author's publisher prefix, for example `alice.*` |
| Source | [`plugins/official/`](https://github.com/l0ng-ai/openidea/tree/main/plugins/official) in the OpenIDEA repository | The author's own repository |
| Built and signed by | The OpenIDEA release workflow, with the official key | The author, with their own key |
| Listed through | Each release | The registry, [l0ng-ai/openidea-plugins](https://github.com/l0ng-ai/openidea-plugins) |
| Purpose | Examples of the plugin API, kept working as it changes | Plugins for real use |

New official plugins are proposed in an issue first; they cover general needs or show how to use part of the API. A plugin that needs a new extension point brings the extension point to the OpenIDEA repository as its own pull request, and the plugin itself to the registry.

## How the community index reaches users

1. You open a pull request in the registry that adds or updates your plugin.
2. The registry's CI downloads the package, checks its SHA-256, runs `openidea-plugin check` against the latest OpenIDEA release, verifies the signature against your publisher keys, and publishes its own `index.json`.
3. OpenIDEA's `plugins-index.yml` workflow merges that index into the release's `plugins-index.json` within the hour.
4. IDEs read the index daily (or right away with **Rescan Plugins** in the gear menu of **Settings › Plugins**), and offer the newest version of each plugin they can load.

## List a plugin

**1. Get the tool and a key**

Install `openidea-plugin` (see [Quickstart](https://openidea.sh/en/plugins/quickstart.md)) and create your publisher key once:

```sh theme={null}
openidea-plugin keygen alice.key
```

It prints your public key. Keep `alice.key` secret.

**2. Name, categorize and sign the plugin**

Name the plugin `<publisher>.<name>` in `plugin.toml`, set its `categories`, then build and sign it:

```sh theme={null}
openidea-plugin build
openidea-plugin pack . --key alice.key --publisher alice
```

**3. Publish the package**

Attach `alice.arthas-0.1.0.oiplugin` to a release of your repository and note its SHA-256:

```sh theme={null}
shasum -a 256 alice.arthas-0.1.0.oiplugin
```

**4. Open a pull request in the registry**

The first time, add your publisher in `publishers/alice.toml`:

```toml theme={null}
name = "Alice"
owners = ["alice"]                 # GitHub accounts that may change these entries
keys = ["<public key>"]            # add new keys here; older ones stay valid
revoked-keys = []                  # keys whose packages must no longer install
```

and the plugin in `plugins/alice.arthas.toml`:

```toml theme={null}
repository = "https://github.com/alice/openidea-arthas"

[[versions]]
version = "0.1.0"
package = "https://github.com/alice/openidea-arthas/releases/download/v0.1.0/alice.arthas-0.1.0.oiplugin"
sha256 = "<sha-256 of the package file>"
```

A new version is a pull request that adds another `[[versions]]` table. Keep the earlier ones while older IDEs need them: each version records the plugin API it needs, and an IDE installs the newest version it can load. The index keeps only the newest version per API requirement. Removing the plugin file delists the plugin; installed copies keep working.

The registry's [README](https://github.com/l0ng-ai/openidea-plugins#readme) is the source of truth for these files and its rules. Those rules are summarized in [Policy and security](https://openidea.sh/en/plugins/publishing/policy.md#community-registry).

## Categories

Set up to three in `plugin.toml`:

| Category | For |
| - | - |
| `languages` | Language support |
| `themes` | Colour themes |
| `icon-themes` | File icon themes |
| `linters` | Linters and formatters |
| `vcs` | Version control |
| `ai` | AI features |
| `frameworks` | Framework support |
| `tools` | Other tools |
| `other` | Anything else |

Without `categories`, a plugin that contributes themes, icon themes or languages is filed under those, any other under `other`.

## Icon

Give the plugin an `icon` (and optionally `icon-dark`) in `plugin.toml`: an SVG of at most 16 KiB, shown in **Settings › Plugins** and the marketplace. It is sanitised (no scripts, external references or `foreignObject`) when you build the index and again in the IDE. An icon needs `engines.openidea = "^1.2"`. Without one, the plugin gets the generic plugin icon.

## Updates for users

When the daily check finds newer versions of installed plugins, the IDE says so once, with **Update All**. An update that asks for no new capabilities and is signed with the same key (or one that key endorsed) installs with the existing grants; otherwise the user reviews it first.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.