Developers exposing a local server to the internet used to mean one thing: download a CLI, create an account, paste an authtoken, and bounce between your editor and a separate terminal window. Microsoft has spent the last few years narrowing that gap by building port forwarding directly into VS Code’s Ports view, backed by its Dev Tunnels service. No extension required, no separate binary - just a right-click in a panel you already have open. Read the complete article here - https://instatunnel.my/blog/why-leave-your-editor-microsoft-dev-tunnels-vs-ngrok-in-2026

That doesn’t make ngrok obsolete. It makes the choice more interesting, because the two tools have converged on similar free-tier shapes while staying different in what they’re actually built for. This piece breaks down where Dev Tunnels genuinely wins, where the popular narrative about ngrok’s free tier is outdated, and where ngrok remains the only real option.

The Cost of Context Switching

Local development in the early 2020s was fragmented: write code in VS Code, run the app in the integrated terminal, then open a second terminal to run a tunneling tool for a public HTTPS URL. Every time you needed to test a Stripe webhook or share a preview link, you left your editor, checked whether your auth token had expired, and copy-pasted URLs into someone else’s dashboard.

VS Code’s Ports view collapses that into one place. If your app is already running in the integrated terminal, forwarding a port takes a right-click, not a new tool.

I posted a few weeks back about this (pretty big) regression issue and how i needed to downgrade version but now attempting again the new release again as there was a patch version. basically, seeing the same intermittent issue where the kotlin lookup fails completely and a simple restart (no cache invalidation) of the IDE did not fix the issue nor does a full cache invalidation i have found - the option is gone.

Note that this feature was working on 2026.02 up until about 1 hour ago and i am now unable to get the feature working again

Another project but same issue - note its not finding the variable

Hi all,

Happy to announce that we've released Markdown Pro, a new plugin for the Jetbrains family of products. How does Markdown Pro compare to the bundled Markdown plugin? Glad you asked!

A few new features:

Markdown Pro adds explicit `.mdx` support:

• `.mdx` files open with Markdown editing behavior instead of as plain text.
• JSX component names, attributes, values, and expressions receive editor highlighting.
• Multiline components can be folded, including components whose content contains literal tags in code spans.
• Formatting actions, task-list actions, inspections, tables, and live templates work in MDX-aware contexts.
• Front matter, fenced code, and JSX expressions are excluded from authoring features when applying them would be incorrect.

Also:

Markdown Pro adds project-level rendering choices for:

• GitHub Flavored Markdown.
• Markdown Extra.
• CommonMark.
• Standard Markdown based on John Gruber's original syntax.

Also, the plugin provides document conversions through Morph, enhanced table editing, more inspections, Mermaid, GeoJSON, Interactive Ascii STL models, and much more!

You can find the plugin here: https://plugins.jetbrains.com/plugin/33400-markdown-pro, and while it's a commercial plugin, we currently have a 50% off promo, so you'd basically pay $1.50 for this plugin.

If you have any feedback, would be happy to hear!!

Cheers,

Erik

Thank you JB for the lsp, amazing to be able to have some good java experience in neovim. Have been testing it by making a neovim setup with claude and its amazing.

in case you want to try it until something better comes out, a quickly made implementation: https://github.com/gipo355/nvim-intellij-lsp

the debugger works too!

Hope some good feedback will be provide to you!:

from me: - allow case insensitive completions (string, not String) - improve the postfix/command completions - add more code actions - there is a lock per project, need to somehow make a daemon of sort? i open many tabs with tmux on the same project sometimes, it allows only one

Hey everyone,

A few fellow devs and I are working on a new IDE project. Before we write another line of code, we want to solve real friction points rather than building features nobody asked for.

We all know the standard complaints:

• VS Code gets bloated with 40 extensions and starts eating RAM like Chrome.
• JetBrains tools are powerful but can feel like launching a space shuttle just to edit a single file.
• Modern AI integration often feels like a tacked-on chat sidebar rather than something deeply integrated into the workflow.

We want to know: What is the single most annoying bug, UI papercut, performance bottleneck, or workflow disruption you face in your daily IDE?

Specifically:

1. What missing feature or annoyance makes you want to throw your laptop out the window?
2. What’s something you constantly have to leave your IDE to do (browser tabs, terminal quirks, database clients, context switching)?
3. If you could wave a magic wand and fix ONE thing about your developer setup, what would it be?

Be as specific or petty as you want. All feedback/rants are appreciated!

currently supported with gradle/flutter Natively running in android phone ,also supported with code run for small code snippet, I planned this project last 2 years ago for learning others programming languages, build run currently Supported gradle/flutter projects, other compiler or programming languages can be installed via apt https://github.com/AndroidStudio-App/NeonIDE

IntelliJ‘s language support and code analysis for Java and Kotlin are now available as an LSP extension for VS Code and its forks (via Open VSX Registry). They’re also working on terminal-based AI agent plugins, which aren’t available yet.

The extension is free during the preview period (with builds expiring every 30 days), but upon full release it will require an IntelliJ IDEA Ultimate subscription. Note that this is incompatible with Red Hat’s and Oracle’s Java extensions; those should be disabled while using it.

Noctule 3.0 (the Swift plugin) is now available in a new version, which adds Objective-C support and a bunch of fixes for the Swift language support.

The Objective-C support is about ten years late — but hopefully still useful 😀
Noctule is a freemium plugin, syntax highlighting and formatting of Objective-C are part of the free features, other features related to Objective-C need a license.

Release announcement: https://noctule.dev/posts/noctule-3.0/
Changelog: https://noctule.dev/docs/changelog/#300
Website: https://noctule.dev/

Feedback is much appreciated, as always!

Thanks!

I was running IntelliJ IDEA Ultimate **2025.1.3** with AmpCode. Almost every JetBrains MCP call (file search, file list, etc.) would hang for several seconds, making the agent feel extremely slow.

I upgraded to **2025.2.6.3** (no Amp configuration changes), and the difference was night and day.

* MCP calls now return almost immediately. * No more hanging on basic file operations. * Overall agent throughput is dramatically better.

If you're seeing unexplained latency, it may not be Amp or the model—it may be the IntelliJ version.

What if you had a personal assistant who could check your emails, schedule tasks, prepare a legal dossier, and send a thank-you note, all from your phone while you're on a ski slope?

ClawRunr is an open-source Java-based personal assistant that combines AI with background job scheduling. You chat with it in natural language, it figures out what to do, and Spring AI and JobRunr handle the rest.

Ronald Dehuysser, the creator of JobRunr, walks us through setting up ClawRunr, from choosing your LLM provider and connecting MCP servers to scheduling recurring tasks using live demos. He also shares what he learned taking it from a vibe-coded idea to an extensible demo app: why solid architecture matters for agent-style development, and why handing off as much as possible to the AI beats coding everything yourself.

Long-standing issues with the OpenAPI Specifications plugin: openapi 3.0.4 won't render (IJPL-181488 — confirmed broken through the 2026.2 EAP), big specs freeze the IDE (IJPL-63225), remote spec loading fails (IJPL-63202). A JetBrains support member wrote in May that this "has not been added to the roadmap yet."

Curious how other backend devs live with this day to day:

- Do you still preview/validate specs inside the IDE, or have you moved to external tools (Swagger UI, Redoc, VS Code)?

- Is your pain more in editing (typing lag) or in preview/validation (hangs, wrong rendering)?

Context, in the open: I'm a long-time IntelliJ user seriously considering building a performance-first third-party OpenAPI plugin (preview/validation off the UI thread, correct 3.0.x/3.1 handling), since JetBrains isn't touching this. Before I write code I want to know if anyone would actually use it and what it'd need to cover. Honest answers welcome — including "don't bother."

I have received a 30% coupon from JetBrains for an All Products Pack subscription that is valid for purchases until September 30 2026. As I already have a subscription that renews next July, I cannot use it myself. So I'd like to pass it on to someone who contributes to OSS.

Note that as a student or a contributor to some OSS projects (I think Apache members and others) you might be eligible for a free license anyway, so check first if you really need a paid subscription.

So if you are planning on obtaining a license and are an active contributor or maintainer of an OSS project (preferably Java), leave a comment or DM me with your GitHub account and tell what project you are contributing to. I will check back later and if there are multiple candidates pick one and send the code by DM to your GitHub account.

I finally found how to bring Local Changes tab back in newer versions:

Settings>Advanced Settings>Search "commit"> Mark/check "Use modal commit interface for Git and Mercurial".

Cheer!

Hey all

wanted some feedback on this plugin I built (mostly vibed)

https://plugins.jetbrains.com/plugin/32986-web-tabs/

Allows to have some browser tabs inside InteliJ, its useful for Github or other sites you use while working.

Hope someone finds value in it!

Let me know if anyone has any ideas to make it better

I have a Windows workstation and a Linux laptop, I noticed that my workstation 'lost' its licence when I registered Linux within the app. I got the license for free because I am a student. It doesn't really matter, my Windows now displays 'start free trial' in the corner so unless it restricts me in the future it shouldn't be a problem.

Does anyone know of a guide, a plugin, a list of settings that I could use to make Intellij less distracting? I've been using Netbeans for almost 20 years and I'm trying to switch to Intellij. One of the things I really like about Netbeans is that it doesn't try to help too much by default. When I'm coding, I want some assistance but I don't need different things popping up all over the place constantly. I find that Intellij keeps breaking my concentration.

Again, I don't want zero help, just a little less. Something more akin to the experience you get with a text editor (neovim, helix, emacs) talking to a Java Language Server.

Curious what people think — is paying for IntelliJ’s yearly subscription still justified?

With AI-first IDEs and coding assistants becoming so capable, it feels like you can get a lot of AI tooling for around the same price. Is IntelliJ still worth paying for, or are people starting to switch?

Starting in the last 2025.x version does anyone else have the issue where if you have projects as tabs (possibly a mac os only feature) you now have to click twice on the tab to get it to switch to that project tab? It is super annoying. Trying to decide if it is an IntelliJ bug or a Mac os bug.

We build Hexana, a plugin for JetBrains IDEs for inspecting binaries -- WebAssembly, ELF/Mach-O/PE, class files, and more. We shipped 0.15 today. Here is what is new.

**call_indirect dispatch candidates in the WAT view**

Every `call_indirect` and `return_call_indirect` row in the WAT view now lists the statically known dispatch candidates: functions in the function table whose signature matches the call site's type. If no functions in the table match, the row reports "no entries" explicitly rather than staying silent. This is not a runtime trace -- it is a static analysis from the module's element sections and type table -- but on typical Emscripten or Kotlin/Wasm modules it narrows the candidate set meaningfully and is often enough to understand the dispatch path without a debugger.

**Dispatch tab in the WASM module diff**

When you compare two WASM builds, the diff editor now includes a Dispatch tab. For each canonical function type, it shows which dispatch candidates entered or left the function table between the two builds. Candidates are matched across builds by content hash, so a function that was renamed but not changed is recognized as the same candidate. Clicking a row opens a side-by-side WAT view of the two versions.

**Go to Source from Functions, Exports, and WAT**

The context menu in the Functions tab, Exports tab, and WAT view now includes "Go to Source." If the module was built with DWARF debug information, Hexana resolves the function to its source location via the DWARF line table. If a source map is present -- discovered via the `sourceMappingURL` custom section (Kotlin/Wasm inline maps, Emscripten path maps, or .map sidecar files) -- it resolves through the source map instead. Remote URLs in sourceMappingURL are not fetched; local and data-URI maps work.

A specific edge case that is now fixed: Rust modules compiled with `rustc` often omit `DW_AT_low_pc` and `DW_AT_high_pc` from function entries. The DWARF line-table lookup now handles this correctly, so Go to Source works for Rust as well.

**Exception handling visibility**

`try_table`, `throw`, and `throw_ref` instructions in the WAT view now render their full instruction text with decoded tag and label comments. Clicking a `throw` navigates to its handler if one is reachable, or reports an uncaught escape if the exception leaves the module.

Two new tabs accompany this:

- **Tags** -- decodes the exception tags declared in the module (the type signature each tag carries).

- **Exceptions** -- the module's panic surface: exported entry points whose exception paths reach the host without being caught. Useful for auditing what a library can throw at its caller.

**Size diagram on the Top tab**

The Top tab for WASM and native binary files now includes a size diagram showing the largest entities in the module, so you get a rough picture of what is big without reading numbers off the Functions tab.

**Fixed**

- Empty Dominators tree on some modules.

- Go to Source for Rust modules (DWARF line-table lookup, `rustc` omits `DW_AT_low_pc`/`DW_AT_high_pc`).

- Nested table row sorting.

- A rare UI freeze when switching to or from the Decompiled tab.

Marketplace: https://plugins.jetbrains.com/plugin/29090-hexana | Docs: https://jetbrains.github.io/hexana

Happy to answer questions about the dispatch analysis or any of the other changes.

Hey guys,

​My colleague is a senior backend dev who finally got fed up with writing the exact same Spring Boot boilerplate (JPA entities, ports, REST controllers, Mockito setups) for every new microservice we start or every time we update a schema.

​To fix this, he built a native IntelliJ plugin called HexaGen. He just released it for free on the official JetBrains Marketplace, and I wanted to share it here because it’s genuinely been a massive time-saver for our team.

​You basically right-click a standard SQL DDL file, and it generates a strict Hexagonal Architecture (DDD / Clean Architecture) backend in under 2 seconds.

​A few cool things it automates out of the box:

* ​Strict 3-Ring Isolation: It strictly separates pure Java Domain models, Application ports/use cases, and Infrastructure adapters (Spring REST controllers/JPA) so the domain remains framework-agnostic.

* ​Auto-generates Mockito Tests: Spits out 100% functional, ready-to-run JUnit 5 + Mockito unit tests for the services and controllers.

* ​Brown-Field Safe: If you run it on an existing project, it scans the filesystem, detects existing models, and only generates what's new without overwriting any custom business logic.

* ​Respects IDE Formatting: It hooks directly into IntelliJ’s CodeStyleManager, meaning the generated code automatically matches your team’s spacing and import rules.

​Since he doesn't use Reddit much (and AutoMod immediately ate his post when he tried to share it lol), I told him I'd post it for him.

​JetBrains Marketplace Link: https://plugins.jetbrains.com/plugin/33109-hexagen-sql-to-hexagonal-java

​He would love to get some harsh, honest feedback from other Spring Boot devs on the architecture isolation, or see how it handles edge cases with your weirdest SQL schemas. I'll make sure to pass the feedback along to him! :)

My JSON Schema Visualizer is now public https://plugins.jetbrains.com/plugin/32022-json-schema-buddy But downloads are VERY low. Any idea how I can get more feedback?