HN Debrief

Escape IntelliJ: Scala and Kotlin LSPs on Emacs Eglot

  • Developer Tools
  • Programming
  • Open Source
  • AI

The post is a practical guide for getting Scala and Kotlin development working in Emacs with Eglot, mainly through Metals for Scala and Kotlin LSP for Kotlin. The pitch is escape velocity from IntelliJ: keep code intelligence, drop the heavyweight IDE, and get back to a more composable editor setup.

If you run JVM-heavy teams, treat editor choice as a trade between polish and openness, not a simple win for “lighter” tools. IntelliJ still owns deep refactoring and debugging, while LSP setups are now credible for smaller edits, mixed workflows, and developers willing to trade convenience for control.

Discussion mood

Mixed but pragmatic. People respect IntelliJ as the best-in-class JVM IDE for refactoring, navigation, and debugging, while being increasingly annoyed by performance, memory use, and AI-driven product clutter. Emacs and other editor-plus-LSP setups drew interest, but mostly as good-enough alternatives for lighter workflows rather than full replacements.

Key insights

  1. 01

    Scala tooling is on a different track

    Scala support looks healthier because Metals was built as a real language server stack, not just an IDE engine stuffed behind the LSP protocol. That architectural split matters. It explains why Scala users are more optimistic about Emacs and VS Code than Java and Kotlin users, where the tooling is still largely headless IntelliJ, Eclipse JDT, or NetBeans.

    Do not treat “JVM tooling” as one bucket. If your team is Scala-heavy, a non-IntelliJ workflow is much more credible today than it is for Java or Kotlin-heavy codebases.

      Attribution:
    • sgt #1
    • pjmlp #1
    • hocuspocus #1
  2. 02

    Kotlin LSP still depends on JetBrains internals

    Kotlin LSP is not an independent clean-room implementation. It is based on recent IntelliJ IDEA code and JetBrains Air and Fleet components, which means the language intelligence still inherits JetBrains’ architecture and some of its licensing and coupling issues. Swapping editors does not really free Kotlin users from that stack.

    If your goal is strategic independence from JetBrains, Kotlin LSP does not buy much of it. It helps with workflow flexibility, but not with reducing dependence on JetBrains’ language tooling.

      Attribution:
    • tsvetkov #1
    • vanyaland #1
    • andylynch #1
  3. 03

    Refactoring remains the real moat

    The repeated defense of IntelliJ was not nostalgia or brand loyalty. It was trust in semantics during invasive changes. Several people said other editors are acceptable until the job becomes a nontrivial refactor, at which point IntelliJ is still the only tool they trust to update call sites, signatures, and project-wide references without guesswork.

    If your engineers routinely reshape large JVM codebases, keep at least some JetBrains seats available even if the daily editor standard shifts elsewhere. Refactoring risk is where false savings show up.

      Attribution:
    • laszlojamf #1
    • f3408fh #1
    • sdf4j #1
    • microflash #1
  4. 04

    Java LSP is blocked by compiler reality

    The weakness of Java language servers was framed as a tooling substrate problem, not just a missing product. Live editor features need incremental compilation, semantic databases, and robust classpath handling. Existing foundations like javac and older bytecode libraries make that awkward, which is why many Java LSPs end up as wrappers around full IDE engines instead of lean native implementations.

    Expect Java editor tooling outside full IDEs to improve slowly unless someone funds a deeper rebuild of the compiler and analysis layer. For planning purposes, this is an ecosystem constraint, not a temporary packaging issue.

      Attribution:
    • dtech #1
    • mechanicum #1
    • marginalia_nu #1
  5. 05

    Emacs adoption is easier with LLM help

    A surprising pro-Emacs point was that LLMs now smooth over the traditional onboarding pain. People described using them to debug Magit, TRAMP, package behavior, and custom config, making an otherwise obscure and legacy-heavy ecosystem much more approachable. That does not remove the tinkering cost, but it lowers the barrier enough to make migration plausible for motivated users.

    If you want to standardize on more hackable tools, pair them with strong internal docs and LLM-friendly configuration patterns. The setup burden is no longer fixed at “weeks of yak shaving” for every developer.

      Attribution:
    • KallDrexx #1
    • isityettime #1 #2

Against the grain

  1. 01

    Some JetBrains performance failures are just heap limits

    One pushback on the bloat narrative was that at least some catastrophic JetBrains behavior looks like the IDE running out of heap and the garbage collector thrashing, not an inherently broken product. The suggested fix was simply increasing the IDE heap size, which is now exposed in the UI instead of hidden in config files.

    Before forcing a tooling migration over performance complaints, check whether teams are hitting default memory settings on large projects. A few environment-level fixes may recover a lot of the lost experience.

      Attribution:
    • affenape #1
    • jyounker #1
  2. 02

    Maybe the market for Java LSP is tiny

    The sharpest counterpoint to the “why is Java LSP still bad” complaint was that the demand may be overstated. Most Java developers already sit inside IntelliJ or another full IDE. Everyone else can tolerate jdtls for occasional work. If that is true, the lack of a great standalone Java LSP says less about technical impossibility and more about weak commercial pull.

    Do not assume every missing developer tool is a greenfield startup opportunity. In mature ecosystems, incumbents can satisfy most of the market even when the alternative remains obviously weaker.

      Attribution:
    • dtech #1 #2

In plain english

AI
Artificial intelligence, here mainly referring to software systems and crawlers associated with large language models.
Eglot
An Emacs package that connects Emacs to language servers using the Language Server Protocol.
Emacs
A highly customizable text editor and computing environment that users often extend with their own scripts and packages.
Gradle
A build automation system commonly used in Java, Kotlin, and Android projects.
GUI
Graphical User Interface, the visual desktop application layer of a tool.
IDE
Integrated Development Environment, a software application programmers use to write and test code.
IntelliJ
JetBrains’ flagship integrated development environment for Java and other languages, known for deep code analysis and refactoring tools.
javac
The standard Java compiler provided with the Java Development Kit.
jdtls
Java Development Tools Language Server, a Java language server built on Eclipse tooling.
JVM
Java Virtual Machine, the runtime platform used by Java and other languages such as Kotlin and Scala.
Kotlin LSP
A language server for the Kotlin programming language, in this case based on JetBrains tooling.
LSP
Language Server Protocol, a standard way for editors to talk to language-specific tools that provide features like autocomplete, go-to-definition, and diagnostics.
Magit
A popular Git interface for Emacs.
Metals
A language server and tooling suite for Scala that provides editor features like navigation, errors, and code actions.
Neovim
A modern fork of Vim focused on extensibility and integration with external tools like language servers.
TRAMP
Transparent Remote Access, Multiple Protocol, an Emacs feature for editing files on remote machines as if they were local.
VS Code
Visual Studio Code, a popular code editor from Microsoft with extensions for many languages and tools.
Zed
A newer code editor focused on speed and collaborative features.

Reference links

Language servers and editor tooling

JetBrains background and security context

Build tools and platform docs

Git tools

  • Fork
    Recommended as an alternative GUI Git client to IntelliJ’s built-in integration on macOS and Windows.
  • SourceGit
    Recommended as an alternative GUI Git client to IntelliJ’s built-in integration on Linux.