Kotlin-Lsp: Kotlin Language Server and Plugin for Visual Studio Code
github.com167 points by todsacerdoti 2 days ago
167 points by todsacerdoti 2 days ago
Great!
As much as I love Kotlin and have a great deal of respect for JetBrains, I’ve always preferred the other Java IDEs over IntelliJ. The fact that choosing Kotlin—which I genuinely do prefer—effectively locks you into IntelliJ for the foreseeable future has been one of the main reasons I’ve hesitated to recommend it unreservedly for every project.
Just to be clear: I think IntelliJ and the rest of JetBrains’ tools are excellent and absolutely worth the price. I simply happen to prefer the alternatives—and they happen to be free. That said, I realise this is very much a personal preference, and one that most others don’t seem to share.
Kotlin does not lock you in and has not locked you in to IntelliJ. About a year ago, I coded up a Kotlin service using VS Code. See https://glennengstrand.info/software/coding/csharp/kotlin for my description of that including how nice the developer experience was under VS Code. The plugin I used was https://github.com/mathiasfrohlich/vscode-kotlin which works like a charm.
What are the IntelliJ alternatives you prefer?
NetBeans was my go-to IDE until I started working with Kotlin, which more or less forced me over to IntelliJ. I’ve also tried VSCode on some pure Java/Maven projects since then, and found that it shares some of that same feel—more lightweight and direct, which I’ve always quite liked.
No offense. Has been years I don't see people using NetBeans. Made me check the website, surprised that the latest release is like just yesterday.
I think it’s admirable that there’s a generic language server for Kotlin. Others, such as zed can benefit from this as well.
That said, I would much rather use AndroidStudio for Kotlin. Hands down. I use VSCode only when I can’t find something better. I recently switched my Elixir dev to Zed and am happy with that. Pretty much only thing I choose to use VSCode for these days is my ansible setups. Otherwise:
- Pycharm -> Python
- Xcode -> Swift
- Android Studio -> Kotlin
- Zed for Elixir/Phoenix
- Nova for embedded C code
- vim for scripts and quick edits of any of the above
VSCode for everything is like using a multitool to do woodworking in a garage. When you’re hiking or on a trip, a lightweight do it all tool has advantages. But I think it’s important to remember what IDE stands for.
On a different perspective, I love that VS Code supports so many things. As full stack dev I have to work with Python/TypeScript/C# interchangeably, often in the same project. I can easily switch between projects with the same editor window, and I get to use the same keybinds.
That is nice, but not much different from jetbrains IDEs that can do this as well?
The issue with the VSCode ecosystem is that extensions can conflict, die, etc, and that is very annoying when setting up environments takes a long time, IMO.
I've been using CLion since 2017. I recently switched to Helix, and one of the refreshing things about this has been that I'm now in an editor that can seamlessly handle every language or text file type. I think switching between editors was slowing me down and causing friction.
With Jetbrains, while there are plugins for other languages, it's hit and miss in my experience. Managing multiple IDE's was simply annoying, even things such as ensuring your settings are synced across everything was an issue. A different editor per language feels like a decision made for business needs and not user needs.
Which isn't to say that their IDE's are bad or anything, they are good. But they would be a lot better if they didn't take their product and split it up for each mainstream language.
I am currently circulating between Helix (for doing stuff myself) and Cursor (for doing stuff via agents).
Helix is awesome! I mostly love how fast it is. The world of JS editors is driving me crazy with lag.
Not to mention, VSCode's story on debugging/profiling is an order of magnitude worse and clunkier than JetBrains'
Such as IntelliJ Ultimate that doesn’t have C++ integration, or CLion that can’t have Ruby integration or dozens of other combinations that happen in the field but not possible in IntelliJ.
Truly not that different from IntelliJ!
Neither does VSCode. They are extensions, which are analogous to plugins in the JetBrains ecosystem. Although, it seems like there used to be way more plugin authors for language support pre-vscode/atom/sublime-text.
You can use the JetBrains launcher to switch between projects in another JetBrains IDE though. Also, I think you can do single window mode in Ultimate to do a lot.
I can combine every possible language on earth that has LSP in one VSCode instance. You can’t do that in IntelliJ.
a)
> The integration with the Language Server Protocol is created as an extension to the commercial IntelliJ-based IDEs. Therefore, plugins using Language Server integration are not available in JetBrains products like IntelliJ IDEA Community Edition and Android Studio from Google.
b) I thought IntelliJ code analysis is so much more superior? If you’re using LSP, what’s the point of IntelliJ anyway? Sluggish ui?
It's so that you can do the "all languages in one IDE" thing you just described by using the LSP for languages IntelliJ Ultimate doesn't support. The experience will be more or less identical to VSCode for LSP languages, but for those supported by IntelliJ, it'll be better.
I’m interested in hearing more about Nova for embedded C, what makes it more suitable? Looking for an excuse to try it.
I on the other hand rather go with use the best tool for the job, this applies to IDEs as well as programming languages.
The vertical integration from an Apple product tailored for a specific experience, versus the jigsaw from Linux desktop distributions.
I've pretty much replaced my Sublime Text usage with Zed as a general purpose editor, which handles any edits that last longer than i can be bothered to edit stuff in Vim. I've used Vi(m) for decades, and know my way around, and while it's a decent editor, it is NOT and IDE, and modern features feels like they're tacked on.
How is Zed for refactoring Elixir stuff? I use VS code for it but I find the options for even just renaming variables quite poor.
I don't think any of the three LSP projects have good support for it. Usually I just do it from the terminal per file or directory.
Igniter is supposed to be able to but I haven't tried it: https://github.com/ash-project/igniter?tab=readme-ov-file#re...
This is amazing news. The inability to write Kotlin in emacs was the only thing stopping me from using the language.
I really hope that this means that we can some day get a Jetbrains Java LSP. I would pay for an Intellij Ultimate subscription just to get access to such a thing.
i love emacs, but nowadays i would argue most languages are far better supported outside emacs, with few exception like lisps
so being strictly emacs, will really limit your choices, and honestly waste your time
I currently rock a setup, as a Java dev, where I do as much as I can in emacs but have a binding to jump to the current line in Intellij. I find myself switching between the 2 without too much friction. It's mostly just committing in Intellij and having pre-commit checks analyze my changes.
Perhaps its better to say there is very little "out of the box" wrt language support, but otherwise I am not quite sure what you mean for >90% of situations. Eglot + the right lsp server gets you really far these days.
What do you love about emacs, if I may ask? Bit hard to guess what you could mean, given your subsequent claims there.
Not original poster, but I will say that I specifically love Doom emacs.
It is really easy to navigate only from the keyboard. It uses vim-style keybindings for everything, so you don't have to do all the weird hand contortions that happen a more traditional emacs-style interface. When you do access functions, they are handled with multi-keystroke gestures while you're in command mode. The keystrokes are effectively navigating through a menu tree. There's a minibuffer at the bottom of the screen to help you navigate, so you don't have to rote memorize everything, but anything you do use often enough to memorize can be accessed in 2-4 keystrokes.
Some of the plugins are just amazing. Projectile - a project management and navigation sidebar - has really good ergonomics compared to what I'm used to with graphical IDEs. Magit is a fantastic and powerful git interface, and the only in-editor git interface I'll actually use; in any other IDE I'll just use git from the command line.
I've got to mention orgmode, of course. I'm not sure I can articulate why I like it so much; it's kind of like a vi-style editor interface where it's hard to grok without putting in some time, but those who do put in the time tend to fall in love.
I will agree that emacs's language support is spotty compared to vscode, but in this day and age that's true of any editor that isn't vscode. And it also lacks that really deep melding with the language that you get with IDEs that are all-in on one platform like IntelliJ IDEA and Visual Studio. But in general it's kind of an outlier in terms of popularity-to-polish ratio.
I wonder what triggered the sudden change of mind.
They have been pretty firm on wanting keeping it closed for the purpose of giving an edge to the Jetbrain IDE's
Kotlin adoption has been stagnating recently (subjectively) and VSCode + forks have massive market share.
It was extremely shortsighted to think that a single language would sway people to IntelliJ instead of just limiting Kotlin’s growth.
Kotlin dominates Android development, but Android Studio is free. Google has become more and more hostile towards indie Play Store developers, so in 2025 it is more risky and less lucrative. Kotlin's "home turf" (Android) may be losing developers faster faster than Jetbrains can gain them on other platforms.
I assume its will be a polyglot world for some time to come, and devs that decide to retool into another stack could use anything else, leaving Kotlin behind.
Hardly shortsighted. IntelliJ has a business model, Kotlin doesn't. Maximizing Kotlin usage does nothing for Jetbrains directly, just creates costs. And sure it brings people to IntelliJ, more importantly, it keeps them there.
It's kinda like describing Apple as short sighted for not giving away the source code to all their frameworks. Doing so would maximise usage but that's not their goal.
> Maximizing Kotlin usage does nothing for Jetbrains directly, just creates costs.
It brings mindshare and brand value. And it brings direct revenue in business contracts (I hope they get a hefty fee for supporting Google with Android Studio).
It is also investment in the future. How many student curriculums, courses, tutorials use IntelliJ over VSCode? And how many of them convert to IntelliJ later? IntelliJ is always seen as that heavy industrial combiner for professional workers compared to nimble and hype VSCode.
> And sure it brings people to IntelliJ, more importantly, it keeps them there.
I might be a vocal minority here, but it keeps nothing but resentment in me.
> It's kinda like describing Apple as short sighted for not giving away the source code to all their frameworks. Doing so would maximise usage but that's not their goal.
Apple is trillion dollar hardware company with completely locked down ecosystem with millions (billion?) of people using their products. They can do whatever the f*k they want and developers will dance to their tune.
The comparison you’re looking for is Borland. Delphi was once far more popular than Kotlin right now, and look how it ended up.
Google pay JetBrains nothing for Android Studio. Source: I talked to them at KotlinConf about it. Why would they? Do you see Google taking out huge contracts with Oracle for Java, or Red Hat for Linux? Google hardly even contributes to upstream projects, let alone funds them via fat support contracts. They prefer to develop everything in house, acquire outright or maintain their own forks if that isn't viable.
Google are members of the Kotlin Foundation. I guess as part of that they contribute towards the cost of the yearly conference. They've also generously open sourced some of the frameworks they built for Android. But go review the commit logs for IntelliJ or Kotlin and you'll see they're nearly all JB employees.
As for the rest, words have meaning. "Brand value" means people are willing to pay for things associated with that brand. "Investment" means something that can potentially yield ROI. Something given away for free with no supporting business model isn't an investment, it's charity.
The internet is littered with bitrotting projects that were treated as charity and then abandoned when the authors got tired of it. Apache fills up with more every year. The right comparison is thus not with Delphi (which made Borland a ton of money and is still on sale today via Embarcadero), but with NetBeans and Eclipse, both codebases abandoned by their former sponsors when the novelty value of having lots of users wore off.
> I might be a vocal minority here, but it keeps nothing but resentment in me.
OK, so don't use it then. Kotlin, at least in the JVM or JS variants, isn't the sort of language that requires a huge level of buy-in. I started using it before Kotlin 1.0 even came out, used it for the next decade after that, and was happy with it at every point. Back in those days the community was tiny but that doesn't matter due to its excellent JVM interop. At no point did I ever have any fear other than JetBrains not making enough money with it and defunding it. Fortunately, being a smart company, they haven't fallen into that trap.
Eclipse is relevant enough in big corporations that Microsoft has had to change their Java tooling offerings to support it just as well, regardless of the coolness factor in coffee shops coding.
One of the reasons might be that they realized that the absense of an official LSP for Kotlin will hinder its wide adoption by new developers who want to try Kotlin but don't want to move away from their favorite IDEs.
Most LLM based code-gen are VSCode forks. This reason would have certainly been on the list.
Supposedly Kotlin usage has gone down a little bit in the last TIOBE Index. So I think they are trying to get Kotlin usage up.
TIOBE is a famous benchmark, but it is also completely useless.
There is a lot of legacy code out there that skews the benchmark, making the index an unreliable indicator of a programming language’s current popularity or the volume of active development in that language.
You'd be hard-pressed to find a job where you can program Fortran or Assembly Language all day. It's a lot easier to find one where you can do Kotlin or Rust.
Kotlin might not be as popular as one would hope, but that is not something you should conclude from the TIOBE Index.
The TIOBE index is just reflecting search queries. If someone is familiar with a language, they would be searching about a specific framework, using LLMs/AI agents, and working on projects in that language. Those won't be reflected in the TIOBE index.
Nit: TIOBE measures search results, not searches, specifically results for "Kotlin programming". But you're correct that it's a terrible metric for many reasons.
https://www.tiobe.com/tiobe-index/programminglanguages_defin...
Thanks for sharing.
This probably means that search results that state "<language> programming sucks" or "<language> programming blows" both increase the relevant score in the TIOBE Index.
I (and countless others I know) simply refuse to learn/use a language that locks you in an ecosystem. I haven’t taken Kotlin, C# or any of the Apple proprietary tech jobs and never will.
Kotlin may have been relatively IDE-locked without a proper LSP being available, but C# is cross-platform in terms of both editors and runtimes (assuming you're not targeting Windows' .NET stack).
At this point I wouldn't consider it any more or less proprietary than any other Microsoft language, like TypeScript for instance.
Kotlin did not have open LSP, C# still does not have an open debugger.
The C# VSCode extension works in Microsoft's build of VSCode, not when someone else forks it and builds it themselves.
The debugger is proprietary but still works cross-platform. I don't know how Jetbrains does C# debugging in Rider exactly, but that shows that you don't have to use VS (Code) to do C# development if you don't want to.
Thanks to Samsung of all companies, there's an open source C# debugger on GitHub (https://github.com/Samsung/netcoredbg). That seems to be the basis of the open source C# extension's debugging capabilities: https://open-vsx.org/extension/muhammad-sammy/csharp
The VSCodium C# community wants Microsoft to open source their debugger instead of having to maintain an open source version themselves, but that doesn't mean you need to use Microsoft's open source version. If anything, this forceful separation makes it so that there never will be only one implementation (like there is for languages like Rust which have always been open and therefore only have one way of doing things).
I know about netcoredbg, but I did not have much success using it. If we count this as the C# debugger, then the tooling quality is not comparable to other mainstream languages like Scala, D or Julia.
JetBrains have their own closed debugger, which doesn't really help.
Since Rust is native code, you can use pretty much any debugger for it, there is definitely not a single implementation. Yes, Rust has a single compiler, but does C# have any other compiler than Microsoft's Roslyn? (I don't think this is a problem, though)
Kotlin has had an OSS (MIT) Language Server for years. It's written and maintained by the community - but isn't that exactly the point of open source?
C# is partially cross-platform. Might be fine for web applications, but e.g. GUI frameworks aren't as cross in practice as they make it out to be, which I've wasted tens of hours figuring out before going back to Java and Racket.
The nice language on the CLR, F#, also doesn't seem to be very well liked by MICROS~1 anymore.
MAUI is cross platform for every platform most businesses care about (mobile+Windows+macOS). For the rest, there's Avalonia (and a bunch of alternatives, but Avalonia comes closest to Microsoft's systems I think).
You won't be writing visual bootloaders in plain C# any time soon, but the GUI side of C# is fine
Every language has its ecosystem. I don't know why being locked into the Java or C# ecosystem is any worse than, say Python or Go. And I say that as someone who has used all of these languages.
Moreover, every programming language has its own community. With conventions, rules, style guides, code of conduct, roadmaps and mentality. With some "weird" takes and with some "pragmatic insights", with their own "rock stars" and "graybeards" to respect and follow. Each with its own unique landscape of hills to choose to die on. "Nothing's wrong with XML", "Give me JSON or death", "Fuck that, YAML all the way for me", ".yaml is dead, long live .toml!", "pfff, you mortals have no idea but EDN is way better..." — and that's just some data-representation disagreements. Once you get to actually processing the data, it gets even worse: "object-orientation is bullcrap", "oh, no, this FP shit is so hard to read for me, what's wrong with good-old 'for' loops?", "if you're not using static types, you're a bad, bad person...", "yes, these 35 libraries to run our 3-liner script are really necessary", etc. Every single programming language has its own pain points and joyful bits. That's why programming is both an amazingly gratifying and a heinously crappy trade.
Do you want to age into an old, happy programmer? Avoid emotional attachment to any single programming language. Borrow good ideas from different sources, but don’t settle on a single PL, paradigm, or convention. Sure, you’ll probably end up hating each of them for different reasons, but you may find some that you don’t loathe so badly.
what job do you currently take?
I work on backend (distributed systems) leveraging languages like Java, Python, Go, Ruby and TypeScript.
What ecosystem does C# lock you in compared to Java, Python, Go, Ruby and TypeScript?
Microsoft/Windows’s ecosystem. As an example, any general guide on the Internet or on Microsoft’s end is written assuming you are developing on and for Windows. I want to stay away from Windows as much as I possibly can but it just isn’t possible. That’s not the case with the other languages/ecosystems I mentioned.
After college I didn't do a lot of programming for some years. But then jumped into .Net with gusto, because I carried huge respect for Anders Hejlsberg. Back in college they taught us Pascal. It's not that I'm that old, it's just because I grew up in former Soviet Union, which has been lagging for decades behind American computer landscape, some curriculums ran with a huge delay. So, because I knew Pascal well, of course I was following Anders (creator of Turbo Pascal and Delphi). Anders worked for Borland. So, just so you know, Borland was huge back in the day, they made IDEs like Borland C++Builder and such. In fact, Borland was so big, my classmate one day has shocked me by telling me that he thought that the last name of Pascal (the mathematician) was "Borland", that's how (he thought) the company got its name.
Anyway, Anders left Borland and joined Microsoft and then .NET with VB and C# came out. In the beginning I was elated. After a few years building .NET apps, websites and services, I started digging for other things. Without even realizing, I slowly left the .NET behind me. Getting out, I recognized that the entire .NET stinked with an aura of some kind of "mental prison". I can't really describe the feeling now, but the entire community felt to me like needing some kind of approval all the time — from mothership company, from influencers like Scott Hanselman, from the Stack Overflow team, or some others like Pluralsight (which in the beginning was very .NET-centric).
I'm sure things perhaps have changed since then for the better — Satya has implemented some company-wide revolutionary changes, yet for me personally, the appeal of writing code targeting .NET has completely dissipated. I'm honestly not missing it a bit. Just a few months of coding something different taught me far more, improved my skills, and gave me invaluable perspective that I wouldn't find if I've stayed.
https://learn.microsoft.com/en-us/training/modules/dotnet-de...
Like first result searching for .net brings you to this microsoft tutorial. Instruction for local development start with installing sdk that immediately offers linux install instructions and vscode also with direct links to .deb or .rpm packages
With the proliferation of JS, TS, Python, Go, etc, Kotlin is probably not even a thought for many young developers. Any efforts by JetBrains to bring Kotlin to where the people are at (as opposed to expecting people to come to IntelliJ) is welcomed. Call me a stan, whatever, but Kotlin is the best, most productive language I've ever used, by far. Yes, it takes some effort to understand how to effectively utilize some of its features, but once you do, productivity (and enjoyment) elevates tremendously.
It's great jetbrains finally taking some babysteps to support an official language server for VSCode after some great resilience from them.
I know it's a difficult spot because such effort will also indirectly compete with their main product which is an IDE, so I'm not very optimistic it'll last.
>I know it's a difficult spot because such effort will also indirectly compete with their main product which is an IDE, so I'm not very optimistic it'll last.
I would say this if this step was taking early while Kotlin is still a new language in the market, but I think their late decision to develop an official LSP for Kotlin is because of reasons you just mentioned, but maybe they changed their minds because they saw other benifits including a wide adoption of Kotlin.
It also helped that whenever JB posted a Kotlin questionnaire there would be dozens of people asking “LSP?”.
Does Fleet not use LSP?
Considering how non-mature this LSP server is, probably not, Fleet probably uses whatever internal protocols JetBrains use inside their IDEs
> Backend – a headless service that does the heavy lifting: indexing, static analysis, advanced search, navigation, and the like. Every such operation is initiated by a request from the workspace, which then processes the response and dispatches the data to the components that require it.
> As a backend, you can use a headless IntelliJ IDEA or a language server.
https://www.jetbrains.com/help/fleet/architecture-overview.h...
Last time I checked it was only for Rust, specifically you couldn't use the LSP feature for arbitrary languages that aren't supported by Fleet yet.
Java and Kotlin are definitely not using the LSP but their proprietary backend.
Are they going to kill it in one year, as they did with the Eclipse plugin, after going big on Android?
Based on the commit dates, it seems like their Eclipse plugin had at least four years of activity: https://github.com/Kotlin/kotlin-eclipse
I think the overlap between "people who use Eclipse" and "people interested in Kotlin" is pretty small, though. I've only seen Eclipse in use with companies and teams stuck working on legacy applications.
Not everyone worships InteliJ.
As for the one year, last release was on 2018, Kotlin was announced as main Android language in May 2017.
Now re-read my comment.
The three years predating it was JetBrains trying to find a way to sell Kotlin adoption, then they went big and closed shop.
Now they are stuck with Kotlin being seen as an Android language for the most part, and Fleet isn't taking off.
> Now they are stuck with Kotlin being seen as an Android language for the most part
Perhaps it’s different elsewhere, but here in Norway I’ve seen Kotlin used quite extensively in large backend codebases. It also comes up frequently in job postings—employers seem to actively ask for it when hiring.
Also at a company where I write backend Kotlin and we don't have any mobile apps or any other JVM products at all.
We wanted the JVM for the JDBC ecosystem due to being a data tool, and Kotlin seemed like the "least bad" flavor.
No regrets.
Same in Germany, there are a lot of major companies using Kotlin for backend code.
It is certainly different, given that Kotlin is about 10% of the JVM market.
https://trends.google.com/trends/explore?q=java,kotlin,scala...
https://senacor.blog/in-praise-of-kotlin-a-modern-programmin...
Most shops that use Kotlin on the backend also do Android development, as means to do core sharing between backend and Android, and there is the whole ART is not a JVM implementation anyway.
I have never seen Kotlin code sharing between Android and backend, it never was even remotely a topic in my client projects that used Kotlin for both.
> Most shops that use Kotlin on the backend also do Android development, as means to do core sharing between backend and Android
None of the companies that I wrote Kotlin for or that I applied to used Kotlin for code sharing between backend and Android. It seems as if you're making a lot of assumptions in this comment thread.
Doesn't change the size of the market share anyway, an assumption done on links I shared, because this is the Internet and we have to prove every little word we write.
Can share more market research reports if you feel like, with similar numbers.
I don't care about the market size as long as it's big enough that I can find jobs, which I can.
Also no idea how the links you posted are supposed to support your assertion that Kotlin is chosen due to code sharing considerations.
Being able to find jobs in a specic technology is a very regional thing, given the market size.
The links I posted, and others I can reach out for, support my assertions of 10% Kotlin market size in JVM deployments.
What you call my assertion, is my assumption about where those 10% are coming from.