Extensions
Extensions are the most common way for a plugin to extend the IntelliJ Platform's functionality in a way that is not as straightforward as adding an action to a menu or toolbar.
The following are some of the most common tasks achieved using extensions:
The
com.intellij.toolWindow
extension point allows plugins to add tool windows (panels displayed at the sides of the IDE user interface);The
com.intellij.applicationConfigurable
andcom.intellij.projectConfigurable
extension points allow plugins to add pages to the Settings dialog;Custom language plugins use many extension points to extend various language support features in the IDE.
There are more than 1500 extension points available in the platform and the bundled plugins, allowing customizing different parts of the IDE behavior.
Exploring Available Extensions
IntelliJ Platform Extension Point and Listener List and IntelliJ Community Plugins Extension Point and Listener List list all available extension points in IntelliJ Platform and from bundled plugins in IntelliJ IDEA. Additionally, dedicated Extension Point and Listener Lists specific to IDEs are available under Product Specific. Browse usages inside existing implementations of open-source IntelliJ Platform plugins via IntelliJ Platform Explorer.
Alternatively (or when using 3rd party extension points), all available extension points for the specified namespace (defaultExtensionNs
) can be listed using auto-completion inside the <extensions>
block in plugin.xml. Use in the lookup list to access more information about the extension point and implementation (if applicable). See Explore the IntelliJ Platform API for more information and strategies.
Declaring Extensions
Declaring Extension
Add an
<extensions>
element to your plugin.xml if it's not yet present there. Set thedefaultExtensionNs
attribute to one of the following values:com.intellij
if your plugin extends the IntelliJ Platform core functionality.{ID of a plugin}
if your plugin extends the functionality of another plugin (must configure Plugin Dependencies).
Add a new child element to the
<extensions>
element. The child element's name must match the name of the extension point you want the extension to access.Depending on the type of the extension point, do one of the following:
If the extension point was declared using the
interface
attribute, set theimplementation
attribute to the name of the class that implements the specified interface.If the extension point was declared using the
beanClass
attribute, set all properties annotated with the@Attribute
andTag
annotations in the specified bean class.
See the Declaring Extension Points section for details.
Implement the extension API as required (see Implementing Extension).
To clarify this procedure, consider the following sample section of the plugin.xml file that defines two extensions designed to access the com.intellij.appStarter
and com.intellij.projectTemplatesFactory
extension points in the IntelliJ Platform, and one extension to access the another.plugin.myExtensionPoint
extension point in another plugin another.plugin
:
Implementing Extension
Please note the following important points:
Extension implementation must be stateless. Use explicit services for managing (runtime) data.
Avoid any initialization in the constructor, see also notes for services.
Do not perform any static initialization. Use inspection Plugin DevKit | Code | Static initialization in extension point implementations (2023.3).
An extension implementation must not be registered as a service additionally. Use inspection Plugin DevKit | Code | Extension registered as service/component (2023.3).
When using Kotlin:
Do not use
object
butclass
for implementation. More detailsDo not use
companion object
to avoid excessive classloading/initialization when the extension class is loaded. Use top-level declarations or objects instead. More details
Extension Default Properties
id
Unique ID. Consider prepending ID with the prefix related to the plugin name or ID to not clash with other plugins defining extensions with the same ID, for example,
com.example.myplugin.myExtension
.order
Allows ordering all defined extensions using
first
,last
orbefore|after [id]
respectively.os
Allows restricting an extension to a given OS, for example,
os="windows"
registers the extension on Windows only
If an extension instance needs to "opt out" in certain scenarios, it can throw ExtensionNotApplicableException
in its constructor.
Extension Properties Code Insight
Several tooling features are available to help configure bean class extension points in plugin.xml.
Required Properties
Properties annotated with RequiredElement
are inserted automatically and validated.
If the given property is allowed to have an explicit empty value, set allowEmpty
to true
(2020.3+).
Class names
Property names matching the following list will resolve to a fully qualified class name:
implementation
className
ending with
Class
(case-sensitive)serviceInterface
/serviceImplementation
A required parent type can be specified in the extension point declaration via <with>
:
Custom resolve
Property name language
(or ending in *Language
, 2020.2+) resolves to all present Language
IDs.
Similarly, action
and actionId
(2024.3+) resolve to all registered <action>
IDs.
Deprecation/ApiStatus
Properties marked as @Deprecated
or annotated with any of ApiStatus
@Internal
, @Experimental
, @ScheduledForRemoval
, or @Obsolete
will be highlighted accordingly.
Enum properties
Attributes with Enum
type support code insight with lowerCamelCased notation. Note: Enum implementation must not override toString()
.
I18n
Annotating with @Nls
validates a UI String
capitalization according to the text property Capitalization
enum value.