Kotlin/kotlin-lsp: JetBrains' Kotlin Language Server for VS Code and Other LSP Editors

The gap kotlin-lsp fills for Kotlin developers outside IntelliJ

Kotlin tooling has long been strongest inside IntelliJ IDEA, where the Kotlin plugin lives. Developers who prefer VS Code, Neovim, Zed or another editor have had to assemble a Kotlin experience from community servers or accept weaker completion and diagnostics. kotlin-lsp is JetBrains' answer: an official Language Server Protocol implementation for Kotlin, described in the README as "Official Kotlin support for Visual Studio Code and an implementation of the Language Server Protocol for the Kotlin language." The audience is anyone who wants IntelliJ-powered Kotlin intelligence in an editor that is not IntelliJ. The repository is a read-only mirror, so direct contributions are not supported; documentation pull requests can be opened and are integrated manually by maintainers. That detail matters if you were planning to fork and extend the server yourself.

How the server is built and where the language intelligence comes from

The README is explicit about the architecture: the server is based on IntelliJ IDEA and the IntelliJ IDEA Kotlin Plugin implementation. That is the reason completion, diagnostics and quick fixes feel like IntelliJ rather than a reimplementation. It is also the reason the project carries a caveat: the README states the language server is based on the most recent IntelliJ IDEA version and proprietary parts of JetBrains Air and Fleet products, making it partially closed-source. So the protocol surface is open and the repository is Apache-2.0, but the engine underneath is not fully readable. On the editor side, the design is standard LSP: one server process, many clients. The README says kotlin-lsp is designed to work with any editor that supports LSP, that releases are generally tested with Visual Studio Code, and that a community-maintained list of scripts for other editors lives in the scripts folder. Build-system integration is handled inside the server for JVM projects: Gradle, Maven, and experimental Android Gradle Plugin support. Kotlin Multiplatform is named as future work, not current capability.

Installing the VS Code extension and the kotlin-lsp CLI

There are two install paths. For VS Code, the README points to the official Marketplace listing and notes that the extension activates automatically when you open a Kotlin file in a workspace. The Marketplace ID changed, which trips up existing users. The old ID was `jetbrains.kotlin`; the new one is `jetbrains.kotlin-server`. Installing the newer extension triggers a dialog offering to uninstall the old one, and the README says to accept it and reload the window, because the new extension cannot properly activate while the old `jetbrains.kotlin` extension is present. If you prefer a manually downloaded build, grab the VSIX from the release page and install it through `Extensions | More Actions | Install from VSIX`, or drag the VSIX into the Extensions tool window.

For the standalone CLI, Homebrew users have a one-liner. The README gives it as:

brew install JetBrains/utils/kotlin-lsp

Manual installation is a four-step sequence: download the standalone zip from the Releases Page, unpack it, make the launcher executable, and put it on your PATH. The README's commands, with `$KOTLIN_LSP_DIR` standing in for the unpack directory:

chmod +x $KOTLIN_LSP_DIR/kotlin-lsp.sh
ln -s $KOTLIN_LSP_DIR/kotlin-lsp.sh $HOME/.local/bin/kotlin-lsp

After that, `kotlin-lsp` resolves on your PATH. The README also points to `./kotlin-lsp.sh --help` for the available options, which is the first thing to run if you are wiring the server into an editor that is not VS Code.

What you actually get: completion, diagnostics, refactoring and build support

The feature list in the README is the honest scope of the alpha. Code completion and diagnostics with quick fixes are IntelliJ-powered, and the diagnostics extend to kotlinx libraries. Semantic highlighting, organize imports, rename refactoring, code formatting, documentation navigation and hover, call hierarchy and code folding are all listed. Build-system support covers JVM projects through Gradle and Maven, with Android Gradle Plugin support marked experimental. Kotlin Multiplatform support is explicitly not in this release; the README says it is coming in future releases. The README also notes up-to-date Kotlin language versions support, which is the payoff of tracking IntelliJ IDEA releases rather than maintaining a separate parser. If your daily work is a Gradle or Maven JVM project and you want rename, formatting and call hierarchy in a non-JetBrains editor, this is the list that matters.

Alpha status, partial closed source and the KMP gap

The README marks the project with an alpha badge and says plainly that it is currently in the Alpha state. It also says the core implementation details and general architecture are mostly settled and stable, with upcoming releases focusing on feature completeness and stability of existing functionality. Read that as: the shape will not change much, but edges will. The partially closed-source nature is a real limitation for anyone who needs to audit, patch or vendor the language engine; the repository is Apache-2.0, but the README attributes part of the server to proprietary JetBrains Air and Fleet code. The read-only mirror means you cannot send a fix for a server bug, only a documentation change. And Kotlin Multiplatform projects are the clearest wrong-tool case: the README lists KMP support as future work, so a KMP codebase will not get the build-system integration it needs. Android users should also note the experimental label on AGP support, which is a weaker guarantee than the Gradle and Maven paths.

How it differs from the community Kotlin language server

The alternative most Kotlin developers will weigh is the community Kotlin language server, a separate project that implements Kotlin analysis without IntelliJ's engine. The difference in approach is the engine, and it shows up in behaviour. kotlin-lsp reuses the IntelliJ IDEA Kotlin Plugin, so its completion and quick fixes track what IntelliJ ships, and its build-system support for Gradle, Maven and Android Gradle Plugin comes from that same lineage. A community server typically implements its own analysis and has to catch up with Kotlin language versions on its own schedule. The README claims up-to-date Kotlin language versions support as a feature, which is the concrete advantage of the IntelliJ base. The trade is the one described above: kotlin-lsp is partially closed-source and read-only, while a community server is open to contribution. If you need to modify the language engine, the community route is the one that lets you.

Licence and what upgrading costs you

The repository ships under Apache-2.0, per the LICENSE.txt entry at the top level and the licence badge in the README. That covers the repository contents, but the README's statement that the server includes proprietary parts of JetBrains Air and Fleet means the licence on the repository is not the whole story for the running binary. If your organisation has rules about closed-source components in the developer toolchain, that sentence is the one to read carefully; this is a factual description of what the README says, not legal advice. On upgrade cost, the release cadence visible in the repository is roughly every six to eight weeks, with the most recent release dated 2026-09-13 and the last push to the repository on 2026-09-23. Because the server tracks the most recent IntelliJ IDEA version, upgrades are how you get new Kotlin language versions. The VS Code extension updates through the Marketplace; the CLI updates through Homebrew or by downloading a new standalone zip. The Marketplace ID change from `jetbrains.kotlin` to `jetbrains.kotlin-server` is the one migration that has already bitten users, and the README's dialog-and-reload instruction is the fix.

Editorial conclusion

Adopt kotlin-lsp if you write Kotlin in VS Code or another LSP-capable editor and want IntelliJ-grade completion and diagnostics without leaving that editor, and you can live with alpha stability and a partially closed-source server. Do not adopt it for Kotlin Multiplatform work, since the README says KMP support is coming in future releases, or if you need to read or patch the server's full source. Before committing, verify that your editor loads the server through the scripts folder or `./kotlin-lsp.sh --help`, and confirm that the old `jetbrains.kotlin` extension is uninstalled, because the README says the new extension cannot properly activate while it is present.

Frequently asked questions

Official sources

1. Issues
2. Kotlin/kotlin-lsp on GitHub
3. License: Apache-2.0
4. README
5. Releases