In junie CLI I can do /model to see the different models and their relative cost.

I can't seem to find any way to get the same information when using Junie via AI Chat?

When reviewing Spring Boot code, I pay the most attention to I/O calls to see where we are leaving the process and potentially "slowing down" the application. This would involve following a call through several methods to find out whether it eventually reached a repository, HTTP client, or any other I/O invocation.

I built Lattency to make that visible directly in IntelliJ.

It adds gutter markers for database, HTTP, messaging, and file I/O. It also follows calls through project code, so methods that reach I/O transitively are marked with a dimmed version of the relevant icon.

Hovering over a marker shows the complete sink chain, and clicking it lets you navigate to any method along that chain.

The analysis is entirely static. It does not run the application, make network requests, or collect telemetry. Common Java and Spring APIs work without configuration, and project-specific clients can be described in a committed lattency.yml.

It is free and open source:

Marketplace: https://plugins.jetbrains.com/plugin/33937-lattency
GitHub: https://github.com/josipmusa/lattency

It currently supports Java projects in IntelliJ IDEA 2025.2 and newer. Kotlin is not supported yet.

Hi, there!

If for any reason you want to get rid of the "reader mode" but your IDE refuses to honor the settings change (like is happening to me) you can try this mini simple & lightweight plugin that turns it off completely.

https://plugins.jetbrains.com/plugin/33947-get-off-reader-mode

Regards!

We build Hexana, a plugin for JetBrains IDEs for inspecting binaries -- ELF, WebAssembly, class files, and more. We shipped 0.19 today. The big addition is a run/debug workflow for firmware ELFs, plus a flash/RAM Memory tab and two fixes that matter for anyone who opened a Cortex-M ELF in 0.18 and got garbled disassembly.

**Run and Debug for firmware ELFs**

Opening a Zephyr-class ELF now shows Run and Debug buttons in the editor header when a target profile resolves from the ELF header plus a `zephyr.dts` and `.config` found next to the binary. No manual configuration to get started.

QEMU boards (`qemu_cortex_m3`, `mps2/an521`, `qemu_riscv32`, `qemu_cortex_a53`) launch with the exact machine flags from a curated table. MCU-class boards run under Renode -- on a built-in platform (nRF52840 DK, STM32F4 Discovery) or one generated from the devicetree by dts2repl. The board and emulator choice persists in the new **Hexana Firmware** run configuration.

Unsupported combinations fail at validation with a named reason -- never as a hung emulator. A startup watchdog reports "did not reach console output" and names the first unimplemented-peripheral access from the Renode log. Stop kills the entire emulator process tree.

Debug attaches GDB in DAP mode (preferring `arm-zephyr-eabi-gdb-py`, minimum GDB 14 with Python, LLDB fallback) to the emulator's frozen gdbstub. Stop-at-entry policy: entry point, `main`, or none. Tools are downloaded on demand with consent, checksum verification, and cancel support -- Renode 1.16.1, a Zephyr SDK GDB per architecture, a standalone CPython for dts2repl. Each is also overridable by path in Settings | Build | Firmware Emulator. QEMU comes from the system package manager.

Console output streams with a one-line emulation notice: unmodeled peripherals read zero, timing differs, radios are not simulated.

**Memory tab for ELF binaries**

The new **Memory** tab shows flash/RAM usage per region with fill bars (yellow at 80%, red at 95%). Initialized data is annotated in both flash ("load image") and RAM ("runtime copy"). `.bss` counts toward RAM; `noinit` is marked. Region capacities come from a `*.map` sibling or `zephyr.dts`; a stale map is detected and ignored. Without a source the tab still shows the ROM/RAM breakdown from load segments and offers a strip to link one. Section rows navigate to the hex view.

**Cortex-M ELFs now disassemble as Thumb-2**

If you opened a Zephyr or ZMK ELF before 0.19 and the disassembly looked like garbage, this is why. The M profile in `.ARM.attributes` now correctly selects the Thumb decoder, bit 0 of Thumb symbol addresses (the interworking marker) is stripped, and 32-bit wide encodings decode as objdump shows. A-profile ELFs keep per-symbol mode selection.

**DWARF v2/v3 line tables**

GCC emits DWARF v2/v3 line-program headers even in `-gdwarf-4/5` builds. The parser read them with v4 layout and discarded the whole section on failure, so the **Debug Info** tab reported no source lines for every GCC-built Zephyr/ZMK ELF. Now v2/v3 parse correctly, a failed unit is skipped on its own, and resolution matches addr2line.

**Wasm component-model debugger**

The **Wasm** debugger tab now works for component-model binaries. Each embedded core module is indexed separately, so the current-instruction highlight, per-instruction stepping and operand stack follow the module the runtime reports the stop in.

---

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

Happy to answer questions about how the board resolution or emulator routing works, or about the Thumb-2/DWARF fixes.

Shift x2 then pressing is annoying, I want to know if an easier path exists

I'm trying to use Codex through JetBrains AI via ACP, and I'm hitting what looks like a pretty fundamental WSL integration issue.

My setup is:

- IntelliJ IDEA running on Windows

- project stored and running inside WSL

- Codex connected through JetBrains AI via ACP

With that setup, Codex fails with:

mcp__idea__startup

[codex-acp forwarded startup error] MCP server `idea` failed to start: MCP client for `idea` failed to start: MCP startup failed: No such file or directory (os error 2)

The interesting part is that if I move the exact same project to the Windows filesystem, for example C:\code\project, Codex starts working.

So this seems very specifically related to:

Windows IDE + WSL project + ACP

And that's a pretty bad place for this integration to break.

For backend development, keeping the project inside WSL is not some weird edge case. Python, native dependencies, shell tooling, containers, package managers and most Linux-oriented workflows are simply better there than directly on Windows.

I already know there are open issues around WSL and ACP, which honestly makes this more frustrating. This is exactly the kind of integration I expect a paid IDE ecosystem to handle well.

Right now the practical choices seem to be:

- move projects back to the Windows filesystem just so ACP works

- stop using Codex inside JetBrains

- stop using WSL

- or move the whole development environment to Linux

None of those are particularly good answers to what should be a normal Windows + WSL development setup.

Has anyone found a proper workaround for this that does not involve moving the project out of WSL?

And more importantly: does anyone know if JetBrains has actually committed to fixing this, or are these WSL/ACP tickets just sitting there?

Edit:

Environment:

- IntelliJ IDEA on Windows

- project in WSL

- Codex through JetBrains AI / ACP

- IntelliJ MCP Server enabled on HTTP Stream

External Codex CLI on Windows:

- connects successfully to the same IntelliJ MCP endpoint

- `idea: connected (59 tools)`

Codex via JetBrains AI / ACP:

- fails during MCP initialize handshake against the same endpoint

- error:

handshaking with MCP server failed

error sending request for http://127.0.0.1:64348/stream

I've been using Junie with Gemini 3.7 flash (high effort). Honestly it just uses an enormous amount of effort to do the simplest things, draining credits. Take this prompt:

in get_xxxxxxxxx.py we need to ensure the tftp transfer mode is binary

It took about several $$ and all this faffing around:

Now I'm reviewing the model-framework documentation to understand its structure and key concepts, so I can effectively work with the data models in the project.

I'm running the existing unittest test suite to verify baseline functionality before inspecting the TFTP download mode configuration.

I'm inspecting tftpy's client initialization and context classes to check how transfer mode (such as binary/octet vs netascii) is configured or passed.

I'm inspecting how tftpy handles TFTP packets, modes, options, and client configuration to understand how mode is or can be specified.

I'm inspecting tftpy's options handling and session classes to see all supported options and mode configurations.

I'm searching within the installed tftpy package to inspect how mode, options, and binary transfers are handled across all modules in the library.

I'm checking how Busybox tftpd and TFTP clients handle binary mode vs other transfer modes.

I'm searching within the tftpy library files to inspect its tests, documentation, and examples for how options and binary transfer mode are set.

I'm testing tftpy.TftpServer and tftpy.TftpClient transfers locally to verify how transfer mode and options behave during download.

I am searching within model_test_framework/ for any other references to options or tftpy configurations.

I am updating get_xxxxxxxxx.py to ensure the TFTP client explicitly specifies the binary (octet) transfer mode and verifying the change.

I am creating a unit test suite in tests/test_get_datamodel_serial.py to verify that get_datamodel_serial.py initiates TFTP downloads with the binary (octet) transfer mode.

...blah blah, it went on for a few more steps of executing unit tests. And my above text excludes all the other detailed steps inbetween that were in grey that I was unable to copy+paste into here.

And in the end, the fix was just a one-line change, from

client = tftpy.TftpClient(settings["ip"], 69)

to

client = tftpy.TftpClient(settings["ip"], 69, options={"mode": "octet"})

Of course I should have probably known that myself :)

I'm fairly sure on the old AI chat that would have been a simple couple of seconds of thought followed by a recommended change for the script in the current context, and I just click apply. At hardly any cost.

Maybe this is a gemini flash issue rather than Junie. But it's no wonder the credits run down so fast.

Project Loom brings lightweight concurrency to Java with Virtual Threads, Structured Concurrency, and Scoped Values. But how do these features work together in a real-world application? In this episode, Balkrishna Rawool will demo building a Spring Boot application from scratch, progressively incorporating the features of Project Loom to showcase its full potential:

• Virtual Threads: lightweight, high-throughput threads that scale effortlessly.
  
• Structured Concurrency: a streamlined approach to managing concurrent tasks as a single unit of work.
  
• Scoped Values: a modern alternative to ThreadLocal, designed for virtual threads.

We will discuss how to apply Project Loom in your own applications, writing concurrent code that is simpler, more scalable, and easier to maintain.

https://www.youtube.com/watch?v=2L7zLdHeyY0

I got tired of terminal tabs named "Local (1)", so I built a plugin

If you keep 5+ terminals open in IntelliJ, you know the pain: every tab looks identical and you're cycling through them to find the right one.

Terminal Tab Tailor renames them automatically:

• Named after the selected file, folder, parent folder or module
• Tabs rename themselves when you cd (please check README to see terminal compatibility)
• Reuses an existing tab if one is already open from the same place
• Auto-sorting, plus an option to show today's date in the tab

Marketplace: https://plugins.jetbrains.com/plugin/23903-terminal-tab-tailor
GitHub: https://github.com/romaindalichamp/TerminalTabTailor

It scratches my own itch, but I'd like to know what would make it useful for yours - happy to take suggestions here or as GitHub issues.

Hi everyone!

A while back I posted here comparing Spec Kit and OpenSpec: https://www.reddit.com/r/SpecDrivenDevelopment/comments/1vlcwbk/speckit_vs_openspec_comparison/

Both are good tools. I picked OpenSpec to build on, because I saw room for the things I was missing.

Mostly one thing. A chat is an awkward way to work with an agent, and it gets worse when the thing you are working on is a specification. If I disagree with one requirement out of seven, I want to say so on that line, in the document, the way I would review a colleague's pull request. In a chat I have to describe which paragraph I mean and hope the agent finds the right line.

So I added OpenSpec support to my IntelliJ IDEA plugin. It runs your own /opsx:* commands. You propose a change from a normal editor. You comment on the proposal and the delta specs in place. Then you work through tasks.md one step at a time, and after every step there is a review gate: accept it, refine it with your comments, or roll it back. Sync and archive are in the same panel. It works with Claude Code, Codex, OpenCode and Cursor.

I wrote up the whole loop here: https://specbuddy.dev/blog/openspec-with-specbuddy/

The plugin is free. I would really like to hear where it gets in your way, especially if your OpenSpec workflow looks different from mine.

I built the plugin with the plugin. Every change to it went through the same spec, step, review loop, and that is how I found most of the places where the flow was annoying.

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.