The LSP API Is Now Available to All IntelliJ IDEA Users and Plugin Developers

Jakub Chrzanowski

The way developers create plugins implementing the Language Server Protocol (LSP) in JetBrains IDEs is undergoing a significant shift. With PyCharm and IntelliJ IDEA adopting a unified distribution model, we’re removing a key obstacle that has been limiting LSP adoption within the IntelliJ Platform ecosystem. Starting with IntelliJ IDEA Ultimate 2025.2, users can continue using a limited set of features, including the LSP API, even after their subscription expires. Community Edition (CE) will still be available in 2025.2 but will not include LSP support. See our other announcement to learn more.

Key changes in LSP availability

The most important update affects how LSP functionality is distributed in JetBrains IDEs:

Immediate impact (2025.2): The LSP API, which is already available to IntelliJ IDEA Ultimate users, will now be accessible for free within a limited feature set when their subscription expires. This change addresses long-standing feedback from plugin developers and smaller language communities, ensuring users no longer need to consider licensing restrictions when choosing between platforms.

Future changes (2025.3): With the new unified distribution, the traditional Community Edition will be sunset. All users will download a single IntelliJ IDEA installer, with IntelliJ IDEA Ultimate features requiring a subscription to be unlocked, but LSP support will remain available to everyone.

The LSP implementation itself stays closed-source and commercial, but we’ll keep it fully accessible for third-party plugins at no charge. This means plugin developers can now target a much broader user base without requiring their users to purchase the IntelliJ IDEA license.

What does this mean for plugin developers

This change addresses one of the most persistent complaints from the developer community. Previously, plugins using the LSP were essentially limited to IntelliJ IDEA Ultimate users, creating a significant barrier for:

• Open-source plugin developers who wanted to provide LSP-based language support without restricting their user base.
• Niche language communities, where requiring a paid subscription made adoption impractical, especially for small teams or individual contributors.
• Educational environments, where managing different IDE editions added unnecessary complexity and friction.

The unified approach means plugin developers can now:

• Build LSP-based plugins that work for users of all JetBrains IDEs.
• Reduce the complexity of explaining installation requirements to users.
• Compete more effectively with competitors’ extensions, which have had universal LSP support.

Current LSP capabilities and setup

The LSP API in the IntelliJ Platform has matured significantly since its introduction in 2023.2 and currently supports the following:

Core language features:

• Code completion with resolve support
• Go to definition and type definition
• Hover documentation
• Find references definition
• Semantic highlighting
• Diagnostics (both push and pull models)

Advanced features:

• Code actions and quick-fixes
• Document formatting
• Document links and color preview
• Intention actions
• Workspace commands

Plugin developers should target IntelliJ IDEA Ultimate 2025.2.1+ and include the optional dependency on the com.intellij.modules.lsp module in the plugin.xml file.

<idea-plugin>
  <depends optional=”true” config-file="lsp.xml">com.intellij.modules.lsp</depends>
</idea-plugin>

To ensure the plugin is only available for installation in 2025.2.1+ and later, specify the since-build property in your build.gradle.kts file with:

intellijPlatform {
    pluginConfiguration {
        ideaVersion {
            sinceBuild = "252.25557"
        }
    }
}

If your project is based on the Plugin Template, set the relevant build number in the gradle.properties file:

pluginSinceBuild=252.25557

1. To integrate the Kotlin LSP, two components are needed:
2. An LSP server descriptor that specifies supported files and offers a command line to launch the server as a standalone process.
3. An LSP support provider that ensures the server is accessible for a given file.

Server Descriptor

The following KotlinLspServerDescriptor creates an LSP support provider for the Language Server for Kotlin that handles Kotlin files (.kt extension). The provider will ensure that the language server runs in a separate process from the kotlin-lsp binary available in the PATH environment variable.

private class KotlinLspServerDescriptor(project: Project)
    : ProjectWideLspServerDescriptor(project, "KN Kotlin LSP") {

    override fun isSupportedFile(file: VirtualFile) =
        file.extension == "kt"

    override fun createCommandLine() =
        GeneralCommandLine("kotlin-lsp", "--stdio")
}

LSP Support Provider

Create an LSP support provider that initiates the LSP server when needed, using the appropriate server descriptor.

class KotlinLspServerSupportProvider : LspServerSupportProvider {

    override fun fileOpened(
        project: Project,
        file: VirtualFile,
        serverStarter: LspServerSupportProvider.LspServerStarter,
    ) {
        if (file.extension == "kt") {
            serverStarter.ensureServerStarted(
                KotlinLspServerDescriptor(project)
            )
        }
    }
}

The LSP support provider must be registered in the plugin descriptor, next to the main plugin.xml, within the existing lsp.xml file.

<idea-plugin>
  <extensions defaultExtensionNs="com.intellij">
    <platform.lsp.serverSupportProvider
      implementation="com.example.KotlinLspServerSupportProvider"/>
  </extensions>
</idea-plugin>

You can find the above LSP implementation as a Kotlin Notebook example here: https://github.com/Kotlin/kotlin-notebook-intellij-platform/blob/master/examples/lsp.ipynb

Trade-offs

The IntelliJ Platform documentation is clear about positioning: The LSP approach shouldn’t be considered as a replacement for the existing language API but rather as an added value. While LSP development offers significant advantages, such as reduced maintenance effort, faster development cycles, and cross-platform consistency, it is important to keep the following limitations in mind:

• Limited IDE integration: The LSP approach provides less access to the IntelliJ Platform’s robust native features, which are deeply integrated via the Program Structure Interface (PSI).
• Performance considerations: Using an LSP-based plugin introduces communication overhead compared to native implementations.
• Feature parity gaps: Some advanced IDE features may not currently have LSP equivalents, limiting the scope for certain plugin developers.

The LSP serves as a practical, lightweight solution for plugin developers seeking to reduce complexity and expand their reach while delivering consistent language support. For those who need deeper integration with IntelliJ Platform features, native APIs like the PSI remain the preferred choice.

Getting started with LSP development

To explore LSP integration, plugin developers should:

1. Review the comprehensive documentation available in the IntelliJ Platform Plugin SDK.
2. Examine existing implementations like the open-source Prisma ORM plugin.
3. Start with basic features and gradually add more sophisticated capabilities.
4. Plan for the 2025.2 release to leverage universal LSP support.

Wrapping up and looking ahead

Removing commercial licensing for LSP integration on the IntelliJ Platform eliminates a significant problem for plugin developers, allowing them to prioritize efficiency and feature work.

More importantly, this shift represents more than a purely technical change; it underscores JetBrains’ recognition that language server development should be accessible to the broader developer community, not just those building commercial products.

While LSP integration won’t replace every native API, it provides a practical, lightweight solution for delivering consistent language support across all JetBrains IDEs. This fosters competition and presents an opportunity for plugin creators to target a broader audience. With the 2025.2 release, plugin authors can now evaluate and adopt the LSP on its technical merits, free from licensing constraints.

Subscribe to JetBrains Platform updates

Subscribe form

By submitting this form, I agree to the JetBrains Privacy Policy Notification icon

By submitting this form, I agree that JetBrains s.r.o. ("JetBrains") may use my name, email address, and location data to send me newsletters, including commercial communications, and to process my personal data for this purpose. I agree that JetBrains may process said data using third-party services for this purpose in accordance with the JetBrains Privacy Policy. I understand that I can revoke this consent at any time in my profile. In addition, an unsubscribe link is included in each email.

Submit

Thanks, we've got you!