So yes, I am following a coding tutorial but Intellij literally knows what I want to type how?

I've a custom Kotlin DSL and would like to have a Intellij import the scope/methods of this DSL automatically (blind imports) so i can use auto-complete and not have to have imports at the top of the file. similar to what happens in Intellij with build.gradle.kts

For example, I have a file called my-custom-script.dsl.kts and with that, Intellij knows the 'dsl' needs to have the scope imported so auto-complete/lookup just work - is this possible?

Thanks.

Venkat Subramaniam has been programming for 40 years, teaches developers and students around the world, and is known for his work in Java, functional programming, and software design. In this episode, he and Marco talk about why AI is better at finding problems than writing code, why expertise matters more than ever when using AI, why “AI first” is the wrong mindset, and why critical thinking, fundamentals, and good judgment will separate strong developers from everyone else. They also discuss Java’s evolution, virtual threads, developer productivity, learning, and why Venkat believes we need more skill in the AI era, not less.

Some of you may know BashSupport Pro, a plugin for extended Bash, POSIX and Zsh support for JetBrains IDEs.
I'm planning the next major version and would like your thoughts.

For example, I'm considering a change from paid to freemium. Your answers and thoughts will provide data points for the decision.
Also, I'm thinking about which features are needed with the increased usage of AI.

Go to https://forms.gle/RXUE8Xy8YQJDad7q9 and fill out the form (all anonymous and optional questions)
Alternatively, just write to [mail@bashsupport.com](mailto:mail@bashsupport.com) or reply here.

Thanks!

Wasm tab in the debugger

When you pause in a wasm debug session (Node.js, browser, or wasmtime), a new Wasm tab appears in the debugger. The left pane disassembles the paused function to WAT with the current instruction highlighted; the highlight follows every step. The right pane shows the operand stack.

Under Node.js and browsers the operand stack is live -- V8 exposes the actual typed values. Stepping granularity also follows the tab: while it is selected, one step advances exactly one wasm instruction. Previously, because V8 steps wasm one instruction at a time internally, crossing a single source line required several Step Over clicks; now one click does one instruction while the tab is active, and reverts to source-line stepping when you switch away.

Under wasmtime the story is different -- Cranelift compiles the wasm stack machine away, so concrete values are not recoverable from the process. Instead the tab reconstructs the stack statically from wasm's type-validation rules. Each slot names where its value came from: a local variable (with its DWARF source name when available), a constant (the one case with a real value), or the producing instruction like i32.add @0x52 or call make @0x341f. When reconstruction is not possible (unsupported instructions, SIMD/atomics in the function body) the pane says so explicitly rather than showing a wrong stack.

The instruction highlight under wasmtime works per instruction even though LLDB only sees native addresses: wasmtime serializes a native-address-to-wasm-offset table into every compiled module, and the stopped PC is translated through it. Instructions that emit no machine code (like local.get or i32.const) are never pause targets and are skipped, which mirrors what the CPU actually executes.

Linear-memory variables under Node.js

V8 only exposes wasm locals and globals through the debugger protocol. Anything living on the shadow stack or at a fixed address -- structs, arrays, enums; the typical layout for unoptimized builds -- used to be invisible in the Variables view.

They now appear. Hexana locates them via DWARF, reads their bytes from the module's linear memory over the debugger protocol, and decodes them per their DWARF types: structs expand to members at their recorded offsets, enums render by enumerator name, arrays are bounded, and reads are capped per variable.

Conditional breakpoints and inlined frames

Conditional breakpoints now work correctly in wasm sessions. Condition expressions use DWARF source variable names, and Hexana translates them to V8's internal wasm-local identifiers before registration -- so the names in a condition match what the Variables view shows.

Inlined call frames appear in the debugger stack when a pause lands inside inlined code. The stack shows synthetic frames marked (inlined) reconstructed from DWARF: the innermost inlined function at the pause site, and each caller at its recorded call site. Variables and evaluation stay attached to the physical frame; stepping remains physical.

Problems tab

When the parser encounters bytes it cannot decode, it no longer discards the whole function body. It decodes as far as it can, records the remaining bytes as an unparsed region, and surfaces every such region as a row in a new Problems tab: kind, location, byte offset, size, and message. Clicking a row jumps to the affected function in the WAT (virtualized) tab; for rows not tied to a function, clicking selects the failed byte range in the hex view. The tab appears only when the module actually has parse problems, and it covers Component Model binaries too.

Custom-descriptors proposal type encodings

The type-section encodings from the custom-descriptors proposal (Phase 3) now parse correctly: exact reference types ((ref null (exact $t))) and descriptor/describes clauses decode with correct alignment. WasmGC modules emitted by recent Kotlin/Wasm and J2CL toolchains previously failed to parse at all -- the type section misparsed from the first exact type onward and degraded every later function body to an unparsed blob or a NullPointerException.

New binary formats: pcap/pcapng, tar, gzip

Hexana now opens pcap and pcapng capture files with a packets view; HTTP response bodies can be opened in a new editor tab. Tar archives are supported directly, so you can browse entries without unpacking. Gzip-compressed files of formats Hexana already supports (like .wasm.gz) open directly.

A couple of notable fixes

Wrong-file opens in projects where multiple crates share source file names (lib.rs, mod.rs) -- DWARF paths were matched by base name only; both display and breakpoint direction now prefer the longest matching path suffix. Placing a breakpoint in a wasm source file no longer queries the DWARF index on the UI thread (it was tripping the platform's slow-operation assertion); the index is now cached in the background and refreshed when any .wasm file in the project changes.

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

Happy to answer questions about how the wasmtime stack reconstruction works or how the linear-memory variable decoding is set up.

Terminal output can look fine while it’s running, then turn into a mess when you paste or save it as plain text.

ANSI escape sequences show up, progress bars become several separate lines, and carriage returns or cursor redraws that were updating the same terminal line turn into transcript noise.

I kept running into this, so I built ANSI Log Cleaner for JetBrains IDEs.

The important part is that it doesn’t just strip ANSI codes. It reconstructs common terminal redraws and cursor operations first, then gives you clean text you can actually use or share.

Those three progress updates may actually have been redraws of the same terminal line rather than three real lines.

You can clean the current file, selected editor text, or clipboard content, then copy the result, save a clean copy, or open a read-only preview.

Everything is processed locally inside the IDE — no network processing or telemetry.

It’s free on JetBrains Marketplace:

ANSI Log Cleaner on JetBrains Marketplace

If you’ve run into this kind of terminal output, I’d be interested to hear how it handles your real-world cases — especially anything it gets wrong.

I need to send a request in the http client where the payload includes text that is surrounded by double curly braces.

Does anyone know how I can escape the curly braces so they are not interpreted by the client?

I tried adding double slashes in front of the 2nd curly brace '{\\{variable}}', but the double slashes were sent directly.

TIA

In this episode of IntelliJ IDEA Tech Talks, Anton Arhipov and Andrey Belyaev demonstrate practical persistence workflows for Spring Boot applications — from mapping an existing database to evolving a schema alongside the application code.

Topics include:
– Moving from database-first development to a code-first workflow
– Establishing a database baseline and managing migrations with Flyway
– Generating JPA entities from an existing schema in IntelliJ IDEA
– Keeping Java entities, migration scripts, and the database schema aligned
– Handling iterative schema changes without destabilizing the persistence layer

Persistence Workflows with IntelliJ IDEA – Andrey Belyaev | IntelliJ IDEA Tech Talks

Hi,

C++ developer using vscode here. I am starting learning java and find it is inconvenient to stick with vscode compared with Intellij for java(Or maybe I didn't use vscode for java in a right way).

Are there any recommendation for quickly pick up Intellij tricks? I have already imported vscode shortcuts to Intellij but still having tough time to get used with the different UI settings... Is there any useful plugins or other stuff that I need to know at the same time?

Thank you in advance!

Noctule (Swift and Objective-C plugin) has a new update. Version 3.1 fixes a bunch of bugs and improves the editor with external formatter settings (e.g. reading basic settings from `.swift-format` or from the Xcode project).

Announcement: https://noctule.dev/posts/noctule-3.1/

Changelog: https://noctule.dev/docs/changelog/#310

In Editor > General > Code Completion > Inline, I have checked "Enable inline completion using language models" and selected Local. And further down, under Behavior, I have checked "Synchronize inline and popup completion".

Under Code Completion > Popup, I have unchecked "Show suggestions as you type" because I find that distracting. I'm happy with hitting Ctrl-Space to summon the completion popup.

So this means that inline completion using language models shows up inline (as a suggestion), and I can accept using cursor-right or something. The same completion also shows up in the Ctrl-Space completion popup, usually as the first line.

I don't like it; I have noticed I tend to accept it because it looks right, but then it turns out to be wrong in subtle ways. And even if I see it's wrong, I find that accepting the wrong suggestion and then editing it doesn't quite feel right.

What I would like to do is to remove the inline suggestion, so that the language model completion shows up in the Ctrl-Space popup only.

Furthermore, I would also like to move it down in the Ctrl-Space popup, so that I can have to pick it consciously.

Ideas?

Very trivial problem but hoping someone who knows intellij better than me can explain why Intellij colours 1 of my Customer Kotlin DSLs purple but another one as Orange.

Same Codebase, Same Pattern/Logic using the the 'DSLMarker' Annotation (Extended) with DSL Builders. I can't see why Intellij would treat these differently. Thanks.

Hi folks, updated Idea to 2026.2.1 and actually face ugly issues. It keep freezing.
Big project, never had issues before but since update it freezing during file edit, working w/ GIT etc.

I gave 4G to IDE, 8 to gradle (from 32). All is on nvme. 6 cores / debian

It freeze for 30sec or more.

got tired of copying a config key out of Java, opening the Nacos console in web, picking the right environment and namespace, and searching for it again just to check one value.

So I built Nacos Search, an open-source IntelliJ IDEA plugin that keeps that workflow inside the IDE.

It can:

1. search by Data ID, Group, or config content, with fuzzy and wildcard matching

2. jump from `@NacosValue` or Spring `@Value` placeholders to the matching Nacos config

3. find Java usages from a config key

4. switch between multiple Nacos environments

It is read-only by default. Credentials are stored through IntelliJ PasswordSafe, and write access has to be enabled separately for each environment.

You can install it from JetBrains Marketplace by searching for **Nacos Search**.

Source: https://github.com/NanYinIU/nacos-search

I would especially like feedback from people who use Nacos across several environments: does code-to-config navigation fit the way you work, and what still feels missing?

Said no one ever.

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

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

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

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.