JetBrains’ Java-Kotlin Tool Hits 3 Editors at RC [2026]

JetBrains moved its Java and Kotlin by IntelliJ IDEA extension to release candidate status on October 15, 2026, bringing IntelliJ-grade language intelligence via the Language Server Protocol to Visual Studio Code, Cursor, and Google Antigravity, with wider coverage following on October 20, 2026. The extension, in public preview since August 2026, is distributed through the Open VSX Registry and was built with direct involvement from the Cursor team, a roughly two-month preview-to-RC run. Release candidate status locks the feature set while JetBrains hunts edge-case bugs, with rough corners still expected around large multi-module Gradle and Bazel projects before a stable 1.0 launch.

JetBrains has pushed its Java and Kotlin by IntelliJ IDEA extension to release candidate status, a milestone that hands IntelliJ-grade language intelligence to developers who never open the full IntelliJ IDEA desktop app. The extension, built on the Language Server Protocol, now runs inside Visual Studio Code, Cursor, and Google Antigravity, with JetBrains confirming it worked directly with the Cursor team on the integration. The move lands in the middle of an industry-wide scramble to put serious language tooling behind every AI coding agent, and it reframes a company long associated with its own standalone IDE as a plumbing provider for editors it doesn’t own. The extension had been in public preview since August 2026, and reports this week place it at release candidate on October 15, 2026, with wider coverage following on October 20. That is a roughly two-month run from preview to RC, a fast clip for a tool that has to replicate decades of IntelliJ IDEA’s static analysis, refactoring, and build-tool integration inside a completely different editor shell. Don't miss new tech stories on Google Add Shattered once in the Google app and our stories show up in your news suggestions. Add now https://www.google.com/preferences/source?hl=en&q=https%3A%2F%2Fshattered.io%2F What JetBrains Actually Shipped The core idea is simple to state and hard to build. JetBrains took the Java and Kotlin analysis engine that powers IntelliJ IDEA and wrapped it in a Language Server Protocol interface, the same open standard that lets a single backend serve completions, diagnostics, and navigation to any editor that speaks LSP. Instead of asking developers to switch to IntelliJ IDEA to get IntelliJ-level Java and Kotlin support, JetBrains is now shipping that intelligence as a plug-in layer for editors built on the VS Code shell. That shell matters more than it sounds. VS Code’s open-source core has become the default skeleton for a wide swath of the AI coding tool market https://shattered.io/software/ . Cursor, Google’s Antigravity, and a growing list of Open VSX-based editors all trace their interface and extension model back to that same codebase. By targeting the shell rather than a single branded product, JetBrains gets distribution across several competing editors with one engineering investment. JetBrains confirmed the extension is also distributed through the Open VSX Registry, the community-run alternative to Microsoft’s official VS Code Marketplace that most VS Code forks rely on because Microsoft’s marketplace terms restrict use to Microsoft’s own builds. That distribution choice is itself a signal: JetBrains built this for the forked-editor ecosystem, not just for Microsoft’s VS Code. From Preview to Release Candidate: The Two-Month Sprint JetBrains opened the preview in August 2026, giving developers roughly eight weeks to file bugs, request missing features, and stress-test the extension against real Java and Kotlin codebases before the company moved it to release candidate. For context, JetBrains’ own desktop IDEs typically spend months in early access before a stable release, so an eight-week preview-to-RC window for a brand-new LSP implementation reflects how much of the underlying engine JetBrains could reuse directly from IntelliJ IDEA rather than rewrite from scratch. Release candidate status is not the same as a finished 1.0 launch. It typically means the feature set is locked and JetBrains is now hunting for edge-case bugs rather than building new capability. Developers should expect the extension to still carry a few rough corners, particularly around large multi-module Gradle and Bazel projects, before JetBrains calls it fully stable. | Milestone | Date | Status | |---|---|---| | Public preview opens | August 2026 | Early access, feature set still in flux | | Release candidate announced | October 15, 2026 | Feature set locked, bug-fix phase | | Wider coverage and adoption push | October 20, 2026 | Reported across developer-tooling outlets | | Full stable release | Not yet announced | Pending JetBrains confirmation | How the Language Server Protocol Powers the Extension The Language Server Protocol was created by Microsoft in 2016 to solve a specific problem: editor makers were duplicating language-analysis work for every language in every editor. LSP splits that work into a client, the editor, and a server, the language engine, that talk over a standard JSON-RPC interface. Any editor that implements the client side can talk to any language server that implements the server side, which is exactly what lets a single JetBrains-built Java and Kotlin server plug into VS Code, Cursor, and Antigravity without three separate codebases. A typical settings entry for wiring up a secondary language server in a VS Code-based editor looks roughly like this, shown here only as an illustration of the general pattern rather than JetBrains’ exact configuration: { "java.kotlin.languageServer.enabled": true, "java.kotlin.languageServer.path": "auto", "java.kotlin.languageServer.trace.server": "off" } Debugging runs through a parallel standard, the Debug Adapter Protocol, which JetBrains has wired into the extension so breakpoints, stepping, and variable inspection work without a separate debugger plug-in. Pairing an LSP-based analysis engine with DAP-based debugging is becoming the default architecture for serious language tooling outside of a vendor’s own IDE, and JetBrains’ move puts Java and Kotlin squarely in that pattern alongside languages like Python and Go. Feature Breakdown: What Developers Actually Get The feature list JetBrains has published for the release candidate reads like a condensed version of IntelliJ IDEA’s own Java and Kotlin toolset, adapted for a lighter-weight editor shell. Code Intelligence Features - Smart code completion tuned to Java and Kotlin syntax and standard libraries - Code navigation, including jump-to-definition and find-usages across a project - Inspections and quick fixes that flag likely bugs and style issues as you type - Project-wide code analysis rather than single-file linting - Project-wide refactoring, so renaming a method or extracting an interface updates every call site Build System and Testing Support - Native support for Maven, Gradle, and Bazel build files - Built-in test running, so developers can trigger and read test results without leaving the editor - Interoperability with Spring tooling, a detail that matters given how much enterprise Java still runs on Spring Boot - DAP-based debugging with breakpoints, stepping, and variable inspection Bazel support is worth a second look. Bazel is the build system Google maintains for its own large-scale codebases, and it has a reputation for being poorly served by lightweight editor tooling compared with Maven and Gradle. JetBrains naming Bazel explicitly suggests the company is chasing large enterprise and platform teams, not just hobbyists running a single Gradle module. Why JetBrains Worked Directly With the Cursor Team JetBrains has said the release candidate was developed in close cooperation with the Cursor team, a detail that stands out because Cursor is, functionally, a competitor to JetBrains’ own AI-assisted IDE features. Cursor built its entire pitch around taking the VS Code interface developers already know and layering deep AI agent features on top of it. JetBrains, meanwhile, has spent years trying to convince developers that a purpose-built IDE beats a generic editor with a plug-in bolted on. The cooperation suggests JetBrains has concluded that fighting for editor market share and fighting for language-tooling relevance are two different battles, and it can win the second even if it loses ground in the first. If a developer is going to write Java or Kotlin in Cursor regardless of what JetBrains wants, JetBrains would rather be the engine quietly running underneath that session than be locked out of it. Google Antigravity and the Open VSX Factor JetBrains specifically named Google Antigravity as a compatible editor for the extension, alongside the broader claim that any Open VSX-based VS Code fork can pull the extension through that registry. Antigravity is Google’s own entry into the AI-assisted coding editor space, built on the same VS Code foundation as Cursor. Having JetBrains’ Java and Kotlin engine available there from day one gives Antigravity a credibility boost on a language pair that enterprise buyers care about deeply, since Java still anchors a large share of banking, telecom, and government backend systems. The Open VSX angle also matters for a less obvious reason: licensing. Microsoft’s official VS Code Marketplace terms restrict extensions to builds Microsoft directly controls, which is why most VS Code forks, including Cursor and Antigravity, pull extensions from Open VSX instead. By shipping there explicitly, JetBrains avoids a repeat of the friction that has periodically locked other popular extensions out of forked editors. The Bigger Picture: AI Agents Writing Java and Kotlin The most consequential line in JetBrains’ own roadmap commentary is forward-looking rather than descriptive. The company has said it wants AI agents running inside Cursor and VS Code to call the language server directly while generating code, rather than having the agent guess at Java or Kotlin syntax and structure from training data alone. JetBrains is also reportedly experimenting with exposing the same IntelliJ IDEA analysis to terminal-based coding agents such as Claude Code and Codex https://shattered.io/claude-code-codex-cli-opencode-update-4-days-2026/ . That framing matters because it reclassifies the extension. It is not just a convenience feature for human developers who prefer VS Code’s interface. It is infrastructure meant to make AI coding agents more reliable at a language pair where hallucinated method signatures and broken refactors are expensive to catch in code review. An agent that can query a real language server for Java and Kotlin, instead of pattern-matching from its training set, should in theory produce fewer compile errors and fewer subtly wrong refactors. Developer Sentiment: What the Data Says About AI Tooling Trust JetBrains is betting on AI-agent adoption at a moment when developer survey data shows both enthusiasm and skepticism running side by side. The 2025 Stack Overflow Developer Survey found that “84% of developers use or plan to use AI tools in their development process,” a figure that shows how far AI assistance has pushed into daily workflows Stack Overflow, 2025 Developer Survey https://survey.stackoverflow.co/2025/ai . Daily use is lower than overall adoption, but still a majority. The same survey reported that “51% of professional developers use AI tools daily,” which tells a different story than adoption numbers alone: more than half of developers aren’t just experimenting, they’ve folded AI tools into their regular routine Stack Overflow, 2025 Developer Survey . Agent-style tools specifically, the category JetBrains is targeting with direct language-server access, remain a minority practice. Stack Overflow found that “31% of developers reported using AI agents,” according to the company’s own breakdown of the 2025 results Stack Overflow Blog https://stackoverflow.blog/2025/08/01/diving-into-the-results-of-the-2025-developer-survey/ . That gap between general AI tool use and agent use is precisely the gap JetBrains is trying to narrow by making agents more accurate on Java and Kotlin specifically. Trust is the harder number for the industry to move. Stack Overflow reported that “only 29% of technologists trust the accuracy of the AI tools they use,” a figure the company shared directly Stack Overflow on X https://x.com/StackOverflow/status/1950542200690925678 . That’s the real market opening JetBrains is chasing: if plugging an AI agent into a verified language server instead of raw model output measurably cuts errors, it gives JetBrains a concrete argument for why its tooling deserves a seat at the table even in editors it doesn’t control. Model choice adds another layer to that picture. Stack Overflow’s survey also found that “82% of developers who used large language models for development work used OpenAI’s GPT models,” according to the technology section of the same survey Stack Overflow, 2025 Developer Survey . That dominance helps explain why JetBrains’ language-server strategy is model-agnostic. Rather than bet on one AI provider, JetBrains is building a layer that any agent, regardless of which model sits behind it, can query for ground truth about a Java or Kotlin codebase. Market Impact: What This Means for JetBrains’ Business JetBrains built its business on selling IntelliJ IDEA, PyCharm, WebStorm, and a stable of other paid, standalone IDEs. Giving away a free, LSP-based extension that replicates core IntelliJ IDEA functionality inside a competitor’s editor shell looks, on its face, like cannibalizing that business. The more plausible read is a defensive one: developers who were going to leave IntelliJ IDEA for Cursor or Antigravity anyway are going to do so regardless of what JetBrains offers. The extension is a way to keep those developers inside JetBrains’ tooling ecosystem, and therefore closer to upgrade paths toward the company’s paid products, rather than losing them entirely to a rival’s language support. There’s also a data and relevance argument. If AI coding agents increasingly route Java and Kotlin requests through JetBrains’ language server rather than a generic model guess, JetBrains becomes a quiet dependency for a large slice of enterprise AI coding activity, even in tools it never built and doesn’t brand. That position is valuable even without a direct subscription attached to it, because it keeps JetBrains relevant to decisions about which languages agent-based tools support well. Competitive Landscape: JetBrains vs. GitHub Copilot vs. the AI-IDE Pack JetBrains isn’t shipping this in a vacuum. GitHub Copilot https://shattered.io/benchmark-cursor-vs-github-copilot-2026/ has been making its own moves this October, rolling out support for VS Code 1.141, adding Claude Haiku 5.5 support, shipping multiple agent harnesses, enabling bring-your-own-key model access, and adding recurring automations and Dev Container support. Those are competing bets on the same underlying question JetBrains is answering: how much of the heavy language-understanding work should live in the editor versus in the model itself. GitHub Copilot’s October Counter-Moves Copilot’s strategy leans more heavily on model capability and agent orchestration than on a dedicated static-analysis engine for any single language. JetBrains’ approach is closer to the opposite bet: give the agent a real, deterministic language server to lean on for Java and Kotlin specifically, rather than asking a general-purpose model to carry the full analytical load. Neither approach has won outright, and the two are likely to converge, with agent harnesses from Copilot, Cursor, and others eventually calling out to specialized language servers like JetBrains’ for the languages where accuracy matters most. | Editor | Java/Kotlin Support Before This Release | Support After This Release | Distribution Channel | |---|---|---|---| | Visual Studio Code | Community extensions, varying quality | IntelliJ-grade LSP via JetBrains extension | VS Code Marketplace | | Cursor | Community extensions, varying quality | IntelliJ-grade LSP, built with JetBrains-Cursor cooperation | Open VSX Registry | | Google Antigravity | Limited, editor still maturing | IntelliJ-grade LSP, confirmed compatible at launch | Open VSX Registry | | Other Open VSX-based forks | Varies by fork | Available wherever Open VSX is supported | Open VSX Registry | Historical Context: JetBrains’ Long Road to Editor-Agnostic Tooling JetBrains spent most of its history betting that developers would pay for a dedicated, deeply integrated IDE rather than assemble their own setup from a general-purpose editor and plug-ins. That bet paid off for two decades. IntelliJ IDEA became the default for enterprise Java development, and Kotlin itself, which JetBrains created, found its biggest home inside JetBrains’ own tooling. The rise of VS Code changed the calculus. Microsoft’s editor became the default starting point for a huge share of new developers specifically because it was free, fast, and extensible, and that extensibility turned out to be the opening every other vendor needed. Once Cursor, Antigravity, and other forks proved developers would adopt a VS Code-shaped editor en masse for AI-assisted coding, JetBrains faced a choice: keep language intelligence locked inside its own IDEs and watch adoption drift elsewhere, or unbundle that intelligence and sell its relevance instead of its interface. The Java and Kotlin by IntelliJ IDEA extension is the clearest sign yet of JetBrains choosing the second path. Risks and Open Questions A release candidate is not a finished product, and several open questions will shape how developers judge this launch once it clears RC. Performance on very large, multi-module codebases is the most obvious one: IntelliJ IDEA’s desktop app has years of tuning behind its indexing and analysis engine, and compressing that into an LSP server that runs well inside a lighter editor shell is a nontrivial engineering problem. Memory use is a related concern, since LSP servers for feature-rich languages have historically been heavier than the simple linters developers are used to running in VS Code. There’s also a business-model question JetBrains hasn’t fully answered publicly: whether this extension stays free indefinitely, gets tiered features reserved for paying JetBrains customers, or eventually becomes a funnel toward IntelliJ IDEA Ultimate subscriptions. How that question resolves will determine whether competing editors keep full access to the tooling or see it scaled back over time. What Comes Next: Predictions Several outcomes look likely as this extension moves past release candidate and the broader coding-tools market keeps adjusting around it. - JetBrains will likely extend the same LSP-based approach to other languages in its portfolio, starting with the languages that already have strong IntelliJ-family IDE support, such as PHP and Ruby. - More AI coding agents, including terminal-based tools, will add the ability to query specialized language servers rather than relying solely on model-generated guesses for languages like Java and Kotlin. - Competing vendors will face pressure to either build or license comparable language-server depth for their own flagship languages, narrowing the gap between generic AI code generation and IDE-grade static analysis. - Enterprise Java and Kotlin shops currently locked into IntelliJ IDEA purely for its depth of tooling will start piloting AI-first editors like Cursor and Antigravity now that a credible language-intelligence gap has closed. - JetBrains will use adoption data from this extension to justify further investment in making its tooling editor-agnostic, likely accelerating similar unbundling for other parts of its IDE lineup. How This Compares With VS Code’s Own October Update JetBrains’ release candidate lands in the same month Microsoft shipped VS Code 1.137’s agent host and Dev Container support https://shattered.io/vs-code-1-137-agent-host-dev-containers-2026/ , a reminder that the editor layer and the language-intelligence layer are evolving on separate but intersecting tracks right now. Microsoft is building out where and how agents run, while JetBrains is building what those agents know about a specific language. Put together, the two updates point toward AI coding agents that run in isolated containers, as Microsoft has been pushing, while consulting a specialized language server like JetBrains’ for ground truth on Java and Kotlin syntax and structure. That same dynamic is playing out across the wider editor market, where head-to-head testing between Cursor and GitHub Copilot https://shattered.io/github-copilot-vs-cursor-4-models-8-days-2026/ has already become a recurring story in its own right, and where tools like Bugbot are being measured against Codex https://shattered.io/ai-code-review-tools-bugbot-vs-codex-2026/ for code review accuracy. JetBrains’ extension effectively adds a new variable to all of those comparisons: which editor gives an AI agent the best access to real, verified language analysis, not just a fast model. Frequently Asked Questions What is the Java and Kotlin by IntelliJ IDEA extension? It’s a JetBrains-built extension that brings IntelliJ IDEA’s Java and Kotlin language analysis to VS Code-based editors through the Language Server Protocol, rather than requiring developers to run the full IntelliJ IDEA desktop application. Which editors support it? JetBrains has confirmed Visual Studio Code, Cursor, and Google Antigravity, plus any other VS Code fork that pulls extensions from the Open VSX Registry. Is the extension out of preview yet? It moved from public preview, which started in August 2026, to release candidate status reported around October 15, 2026. Release candidate means the feature set is largely locked while JetBrains fixes remaining bugs, not a final stable 1.0 release. Does it replace IntelliJ IDEA? No. It brings a meaningful slice of IntelliJ IDEA’s Java and Kotlin intelligence, including completion, navigation, refactoring, and debugging, into other editors, but JetBrains has not positioned it as a full replacement for the desktop IDE’s complete feature set. What build systems does it support? JetBrains lists Maven, Gradle, and Bazel as supported build systems for the release candidate. Why did JetBrains work with Cursor specifically? JetBrains has said the release candidate was developed in close cooperation with the Cursor team, positioning the extension to work well inside an editor that, despite being a VS Code fork, has become a direct competitor to JetBrains’ own AI-assisted IDE features. Will AI coding agents use this extension? JetBrains has said it wants agents inside Cursor and VS Code to call the language server directly while generating code, and the company is reportedly experimenting with exposing the same analysis to terminal-based agents such as Claude Code and Codex. Is the extension free? It is currently available at no cost during preview and release candidate. JetBrains has not publicly detailed long-term pricing or whether any features will eventually be reserved for paying customers.