RustRover リリース

JetBrains Air - one place to run your agents and verify their work

• As of this release, RustRover ships with Air, a new layer for agentic development. Work with the coding agents of your choice, and run, track, and verify multi-agent workflows inside your IDE, where code intelligence helps agents make fewer wrong turns and gives you the tools to review every change before it ships.
• Your agents, your models, your subscriptions – with Junie Lite for free
  • JetBrains Air is a system of products for agentic software development. It works with Claude Agent, Codex, Gemini, GitHub Copilot, Junie, OpenCode, and other ACP-compatible agents. Air detects the agents already installed on your machine so you can connect them in a click, and you can add more from the agent registry.
  • Your existing setup carries over, too: provider subscriptions, API keys, and even a custom base URL all work, with no JetBrains AI subscription required. Run Claude Agent on your Claude subscription in the terminal or in a full-screen IDE tab, use other agent subscriptions in the chat or terminal, and switch between subscriptions at any moment, even mid-session.
  • Air includes free AI with the Junie Lite configuration, so you can use an agent without a subscription. You only need a JetBrains Account.
• A central workspace to review changes and guide the agent
  • Review an agent's changes with the surrounding code and your project tools in view, and send feedback straight back to the agent. Anchor a note to a specific line in the diff, or comment directly from the code, so the agent gets concrete context about the change you want. Work in the chat or the terminal, whichever suits you.
• Shorter type and symbol names in the debugger
  • Long, fully qualified Rust names can make debugger views hard to read. In response to user feedback, RustRover now shortens type names in the Variables and Watches views and symbol names in the Frames view, making it easier to scan the program state and the call stack.
• Navigation from profiler results to Rust code
  • When you find a hot spot in profiler results, you can now jump straight to the Rust code behind it. Jump to Source opens Rust function declarations instead of reporting Declaration not found, and profiler results show readable Rust function names instead of mangled symbols. Both improvements work with perf on Linux and DTrace on macOS.
• AI agents can now use the RustRover debugger
  • AI agents can now debug Rust code using the RustRover debugger. RustRover provides a debugger MCP server and a rustrover-debugger skill that teaches agents how to use it. With them, an agent can set breakpoints, step through code, and evaluate expressions, much like you do in your own debug sessions. Once enabled, the MCP server works with any AI agent that supports MCP and with the same debuggers and operating systems as the RustRover debugger. The rustrover-debugger skill should be enabled and installed for either RustRover or your agent of choice. The corresponding settings can be configured via Settings | AI.

Platform and IDE improvements

• Sound cues for IDE events and editor line marks
  • Screen reader users now get audio cues for editor line marks: errors and warnings, lines added, changed, and removed under version control, and code folding. You can also hear when things finish. Builds, tests, and other time-consuming background tasks report their results with distinct sounds for success, warning, and error states, and breakpoint hits now also trigger a sound. If you work across multiple monitors or several projects at once, enable these sounds so you don’t have to glance at the screen to check statuses.
  • With screen reader support enabled, line-mark cues and sounds for the most important events (builds, tests, breakpoint hits) are enabled by default.
  • Agents in Air come with sound cues of their own, and they’re enabled by default for everyone, whether or not you enable screen reader support. You'll hear when an agent finishes, stops with an error, or needs your input, as well as when dictation starts or stops.
  • Everything else is opt-in. You can explore and preview the sounds on the new Accessibility settings page, and use the Play sound checkbox on the Notifications settings page to enable cues for a specific notification group.
• Automatic error and freeze reporting
  • RustRover 2026.3 automatically sends error and UI freeze reports to JetBrains, helping us identify the problems that interrupt your work and prioritize fixes based on their impact.
  • Reports contain only technical data. Personal details such as file paths, URLs, and usernames are removed from report messages before they leave your machine. You can turn automatic reporting off in Settings | Appearance & Behavior | System Settings | Data Sharing.
• Git worktrees for parallel work and easy code reviews
  • RustRover can now copy your local project configuration into new Git worktrees, including run configurations and other settings stored in .idea. You no longer need to commit those settings to Git or recreate them for each worktree.
  • You can also list local and ignored files in .worktreeinclude for the IDE to copy, and configure a custom script to run when a worktree is created, for example, to install dependencies.
• Other worktree improvements include:
  • Support for multi-root projects.
  • More reliable worktree creation in repositories with submodules.
  • The option to check out a branch that is already in use in another worktree, using --ignore-other-worktrees.
  • Automatic removal of deleted worktrees from Recent Projects.
  • Improved support for WSL and container-based projects.
• New plugin management UI
  • On the Plugins page, JetBrains have merged the Installed and Marketplace tabs into a single view, so one search box now finds plugins whether they’re already installed, bundled with the IDE, or available on JetBrains Marketplace.
  • Results are grouped into clear Installed, Bundled, and Suggested sections that you can expand as needed, so you no longer have to switch tabs to find what you’re looking for.
  • The Plugins page also opens in its own window, which leaves more room for plugin descriptions, screenshots, and release notes. Simple toggles and a less crowded layout give it a cleaner look.

Remote development

• Remote development directly from the IDE
  • You can now work on projects hosted on a remote machine directly from RustRover. An integrated SSH connection flow lets you connect to a host, start a development session, and reconnect to existing sessions, keeping remote work part of your everyday coding workflow.
  • With connection and session management built into the IDE, your team will have fewer applications to configure, maintain, and keep secure.
• Native OpenSSH support
  • RustRover now uses OpenSSH for SSH connections, improving compatibility with the authentication methods and tools your team already uses.
  • Expanded support includes certificate-based authentication, hardware security tokens such as YubiKey, kerberos-sspi, X11 forwarding, and ProxyJump, along with a broader range of SSH agents and wrappers.
• Light mode for remote development
  • You can now start working on a remote project while the remote IDE is still downloading, installing, and launching. Light mode opens the project early and gives you immediate access to editing, the terminal, and file search, with no additional downloads. Once the remote IDE is ready, your session transitions to full mode automatically, preserving your work and state.

Terminal

• The terminal is now a more dependable home for modern CLI tools and terminal-based agents, and it fits into your layout wherever you need the space.
  A more reliable terminal for your command-line tools
• Run modern command-line tools directly in RustRover, with faster output and fewer rendering glitches. The terminal now uses the Ghostty emulator by default, improving support for keyboard shortcuts, emoji, and styling in terminal applications, including AI coding agents such as Claude Code, Codex, and Junie.
• You get the compatibility of a modern standalone terminal, along with IDE features such as file links and command blocks, keeping your terminal workflow close to your code. Ghostty’s support for evolving terminal standards also helps the IDE keep pace with the CLI tools you use.
• Terminal tabs in the editor
  • Give build logs, long command output, and terminal-based agents such as Claude Code more room alongside your code. In version 2026.3 of RustRover, you can simply drag a terminal tab into the editor area, choose Open as Editor Tab from its context menu, or use the dedicated shortcut Alt+Shift+Enter, even while a session is running.
  • Split terminal tabs beside source files, switch between them with the switcher, and name them yourself or let them take the name of the process you start. You can drag a tab back to the Terminal tool window or invoke Return to Tool Window from the tab context menu when you want to change the layout.
  • If a session is running, RustRover will warn you when you try to close its tab or restart the IDE, helping prevent unintentional session termination and potential data loss.

• Code editor. Completion
  • Error highlighting in completion stopped working in 261 builds.
• Security
  • Oracle's fixes for CVE-2026-91403 and CVE-2026-114820 were integrated into JBR.

• Code Insight
  • False positive "Binding is never used" when matching struct's enum field without qualification.
  • Fixed support for final_associated_functions (unstable from 1.95).
  • Problem with support for c_variadic arguments (stable since rust 1.99.0).
  • False positive: is_* method with &mut self triggers wrong self convention warning.
  • False positive unresolved reference in a derive-helper attribute.
  • Type cannot be inferred correctly: ! type is not unified with corresponding type variable.
• Code editor
  • Match arms inlet a = match {...} are fully red during typing inside.
• Code insight. Macros
  • Proc Macro doesn't work on Arch with sytem rust.
  • Go to Super does not navigate from included files.
  • "Meta" macro binding cannot be matched in case of ... = <expr>.
• Code insight. TOML
  • False positive on TOML "Duplicate table header".
• Quick Fixes (QFs) & Intentions
  • Add remaining patterns should add Some before None.
• Tools. Profiler
  • CLion profiler: jump to Rust source error "Declaration not found".
  • Profiler: incorrect output formatting.

• Code Insight
  • False positive [E0382]: value used after move in pattern binding with @.
• Formatter
  • RustRover ignores settings 'use rustfmt instead...' when 'optimize imports' enabled during formatting on save.
• Refactoring
  • "Optimize imports" shredders code in a Slint project.
• UI
  • Rust plugin cannot be loaded without terminal plugin.
• No subsystem
  • FP multi-resolved associated const chained from an assoc type with 2 bounds of the same trait.

• Code Insight
  • Added support for 'min_exhaustive_patterns' (stabilized in 1.82.0).
• Code insight. Macros
  • Added support for 'macro_metavar_expr_concat' (new feature from 1.81.0).
• Solana
  • Added logs and accounts interactivity in explorer.

• Code Insight
  • Broken parsing: support super_let (unstable from 1.88.0).
  • Parsing error in standard library with for<'a> and [const].
  • False E0432 "unresolved import" for items marked #[rust_analyzer::completions(ignore_flyimport*)].
  • Move E0004 (non-exhaustive match) error place from match to scrutinee.
• Code editor
  • Don't commit document in RsEnterInLineCommentHandler.
• Code insight. Macros
  • Cannot expand cfg_select! {} macro with a comma, an stdlib regression in Beta.
• Code insight. TOML
  • 'Wrong' keywords in .toml should not create an error.
• External Linter
  • External Linter can't find crate for test on custom targets without std and test harness.
• Project model
  • stdlib-local-copy is broken.
• Usability
  • Issue with Cargo Sync command execution logs in Sync tab of Build Tool Window.
• Refactoring
  • Optimize imports action doesn't preserve correctly multiline imports.
• Solana
  • Anchor deploy bug.
  • Zoom breaks several items alignment / size in Solana tool window.
  • Expanding logs is not clear when there is no room.
• Tools
  • Remove command execution timeouts to prevent flaky failures and improve reliability.
• UI
  • File templates from plugin sometimes do not appear in New menu.
• No subsystem
  • Broken primitive type docs on nightly/beta.

• Code insight stops working: IllegalStateException "Can't find definition for macro CfgDisabled".
• Cannot resolve vulkano crate's include macro when using vulkano from gitSelecting. An excluded member in the Attach Project dialog deselects the root project.

Key highlights

• Faster navigation for axum and reqwest - In axum projects, route strings are the entry points to your service, but tracing them back to handlers or related client calls often still requires manually searching through the code. RustRover 2026.2 introduces support for the axum and reqwest libraries. The IDE now understands routes in your project, enabling URL resolution, endpoint discovery, and navigation between routes and handlers. Route calls include references and inlay hints that make endpoint relationships easier to understand at a glance. This release also adds reqwest generation and navigation, helping you create client calls with less manual setup.
• Code insight for Ferrocene toolchains - Developers using Ferrocene can now benefit from RustRover's code insight features, including completion, navigation, inspections, and code analysis. RustRover now supports a Ferrocene toolchain managed by criticalup and linked to rustup. The IDE also provides setup guidance and clearer error messages to help you configure the toolchain correctly and resolve issues.
• Interactive declarative macro tester - Declarative macros are among Rust's most powerful tools, but their syntax is different from that of regular Rust. When the output is not what you expected, it can be hard to see how the input matches the macro definition and what code the macro produced. The new interactive declarative macro tester shows you the code your macro input expands into, as well as how the input and output correspond, directly in the IDE. Provide macro input, inspect the expanded output, and see how the input is transformed. This makes matching errors easier to understand when developing macro_rules! macros.

Productivity improvements

• Criterion benchmark run configurations - Benchmarking is easier when you stay close to the code you are measuring. That's exactly why JetBrains have made it possible to run Criterion benchmarks from the IDE. You can now create run configurations for Criterion benchmarks, launch them from the gutter icon next to criterion_main!(), and view the results in the Run tool window.
• Smarter import cleanup for Rust code - Import cleanup should remove noise without making you worry that something important might disappear. In Rust code with macros, external linter results, or large files, however, unused imports can be harder to clean up reliably. In this version, import cleanup delivers fewer false positives. Additionally, JetBrains have added support for imports reported by external linters and optimized how cleanup works inside macro calls. The Optimize Imports action is also faster and more conservative in larger files, removing only imports that are marked as unused.
• Local variable completion for struct literals - When building a struct from values already available in scope, you often have to retype local variable names or fix missing fields manually. RustRover now suggests local variables inside struct literals when the Create field quick-fix can be applied. You can insert a value that's already in scope and then create the matching field, making it faster to build up struct literals as you code.
• .env file support for Rust - Environment variables are easy to mistype and hard to track when your Rust code and .env files are disconnected. This release adds support for .env files. You can complete available environment variables when writing runtime env calls, jump from Rust code to a related variable declaration, find usages from the .env file, and rename keys across both code and the configuration.
• Ability to copy fully qualified Rust paths faster - Some Rust workflows require a ::-delimited path to a function, method, or item, for example, when you're working with tools like cargo asm, selecting targets, or adding rustdoc links. Rebuilding that path manually can break your flow. RustRover 2026.2 makes the Copy Reference action smarter for Rust. In supported contexts, you can copy the fully qualified module path for the item under the cursor with one shortcut, eliminating the need to manually piece the path together.
• Improved editor experience in split mode - In split mode, the IDE frontend and backend run separately, which can make everyday editor interactions feel less smooth in some remote development setups. Editing in split mode now feels smoother, and the improvements are especially pronounced when you're typing or making regular code changes. This makes remote workflows feel closer to the experience of working in the standard local IDE, particularly when the backend runs on another machine or in a company-managed environment.

AI updates

• Agent skills manager - AI agents are only as useful as the context they have. When they don't have knowledge of your frameworks, conventions, and tooling, you end up re-explaining the same setup in every new chat window. Agent skills fix that. Install them once in RustRover and your agents carry that domain knowledge across every project and session - automatically. Browse and manage skills directly from the IDE, expand the built-in library with external registries like public GitHub repositories, or let RustRover import skills you've already set up for Claude Code or Codex.
• Support for third-party providers in AI completion - AI completion is an in-editor code suggestion experience that combines inline completion and next edit suggestions that go beyond the cursor. Available to all JetBrains AI users out of the box, it's powered by JetBrains-trained models and doesn't use up your AI credits. With the latest update, you can now connect your own OpenAI-compatible model providers for AI completion.
• GitHub Copilot built into RustRover - As the result of a direct partnership between JetBrains and Microsoft, GitHub Copilot is now a natively integrated agent in JetBrains IDEs. Unlike in the previous ACP Registry setup, Copilot is available out of the box and provides a more cohesive experience. You can access Copilot directly from the agent picker in the AI chat. Authentication is handled through OAuth with your GitHub account, and an active GitHub Copilot subscription is required.

Platform and IDE improvements

• Git and version control - Git workflows are now smoother with faster conflict resolution and improved worktree management. This release adds automatic handling of simple conflicts across an entire changeset and enhances Git worktree management, making it easier to clean up and manage worktrees directly from the IDE.
• Accessibility - RustRover is now more accessible with keyboard navigation in the main toolbar and status bar and expanded Orca screen reader support on Linux.
• Performance and UX - Performance and usability improvements help keep the IDE responsive during everyday work, with asynchronous file saving, a faster custom file chooser, and an updated Sync Plugins dialog.
• Everyday productivity - Common IDE interactions are smoother. Markdown now supports footnotes, Search Everywhere remembers selected scopes, bookmarks persist when switching branches, and tab colors in the Islands theme have been improved.

• Code Editor
• Added the ability to get module path string for items.

• Code Insight
  • Fixed issue with: Evaluate 'cfg(feature = "foo")' in Rust stdlib.
• UI
  • In "Attach Cargo projects" popup, Cargo.toml files should be sorted before directories.

• Debugger
  • Added "Don't step into libs" option for debugger.
• Code Insight
  • Added support for const impl syntax and rait impl restriction syntax.
• Project model
  • Updated minimum supported version to 1.70.

• Code Insight
  • False positive 'Unnecessary cast' for 'None as Option<*>'.
  • False positive for self-import. Rework inspections for use {self as name} and use::{self as name}.
• Code insight. TOML
  • TOML incorrect autocomplete tail text for enums.
  • Completion in toml files other than Cargo.toml are duplicated.
• Project model
  • Updated minimum supported version to 1.70.

• Code Insight
  • Optimize find usages of a trait member.
  • RustRover freezes after removing a quote before large lazy_static! macro definition.
  • False Positive: errors from invalid parsing of comment starting with ////.
  • False positive E0070 "Invalid left-hand operand" for dereferenced &mut assignment.
  • False positive E0116/E0117 when type is also defined via include!() in build.rs - IDE resolves to build script crate.
  • False positive E0004 "match does not cover all possible cases" on Result with struct pattern and rest (..) syntax.
  • False positive E0658 "bool_to_result is unstable" - IDE resolves to nightly inherent method instead of in-scope trait method.
  • Broken type inference when if_let_guard syntax is used.
• Debugger
  • No "Remote Debug" in run/debug configuration template list.
• External Linter
  • Confusing red lines under the file name with running external linter on the fly option enabled.
• Project model
  • Enormous CPU usage with Rust plugin in IntelliJ IDEA 2025.3.3.

• Code insight. Language injection
  • Added automatic language injection for query_scalar macro from SQLx crate.
• Code editor
  • Highlight target loop when clicking continue statement.
• UI
  • Highlight and separate search results for the test code occurrences.

• AI
  • AI generate documentation writes text in doctest and code in comments.
• Build & Run
  • Main point of panic is not highlighted in output message.
  • Missed cargo command descriptions in Cargo Run Configurations.
  • Update CargoOptions standard command list against current cargo docs.
• Build & Run. Tests
  • Enable colors in cargo nextest tool window.
• Code Insight
  • FP [E0277] trait is not implemented: built in derives on "destroyed" copied item are not considered.
  • Flaky multi-resolve of type with name Eq (the same as Eq trait from prelude).
• Code editor
  • "Apply fix" skips existing derive attribute.
• Code editor. Completion
  • Code completion list shows items in double.
• Code insight. Macros
  • False Positive 'variable is never used', if variable is used in a macro definition.
  • Derive macros have wrong priorities in name resolution.
• Debugger
  • Remote Debug run configuration: LLDB debugger should be default option on macOS.
• External Linter
  • External linter fix for providing derive ignores existing declaration.
• UI
  • Do not list RsDocTestInjectableLanguage in Filter menu for file types.
  • File and Code templates do not appear in create file menu.

Key updates

• Improved code analysis accuracy, with a focus on reducing false positives that can cause confusion.
• Added support for cargo-nextest enabling faster testing. Native support for cargo-nextest is now available directly in the IDE so you can run and monitor nextest sessions with full progress reporting and structured results in the Test tool window.
• Trace call chains more easily with added Call Hierarchy support. Explore call relationships in a dedicated view and navigate complicated code faster. The hierarchy is Rust-aware and distinguishes between trait method calls and calls to concrete implementations.
• ACP Registry in RustRover - In addition to Junie, Claude Agent, and Codex, RustRover now lets you work with more AI agents directly in the AI chat. Choose from GitHub Copilot, Cursor, and many others supported through the Agent Client Protocol (ACP).
• Added the ability to choose module visibility directly in the New Rust Module dialog. This means you can create public or private modules and attach them to a module in a single step, reducing cleanup and keeping project structure consistent.

Workflow improvements

• Updated LLDB debugger - LLDB version 21 improves performance and reliability for debugging sessions. Expect faster loading of debug information through improved DWARF indexing and parallel shared-library parsing, plus more reliable breakpoint behavior in inline code.
• Macro expansion is now easier, use the gutter icon on macro calls or the Alt+Enter shortcut to open the Show Context Actions menu and inspect the generated code without leaving the editor.

Code insight improvements

• Code insight improvements for derive macros - Improved name resolution reduces misleading warnings and keeps editor feedback more dependable. Expect cleaner inspections and steadier code insight in macro-heavy projects.
• Restored trust in IDE diagnostics when working with rustc crates - reduces RustRover report E0463 errors even though the project still built successfully (false positives), so diagnostics in the editor better match what you get from cargo build and cargo check when using rustc_* crates.

AI updates

• Next edit suggestions, now quota-free - Next edit suggestions help you apply related edits across a file, not just at the cursor. In RustRover 2026.1, they do not consume your AI quota, so you can keep changes consistent and stay in the flow while you iterate.
• More agent options in the AI chat - Added support for a wider choice of agents including Junie and Codex, so you can pick the one that best fits the task at hand. Switch between assistance styles without leaving the development workflow.
• AI help for connected database work - RustRover's AI chat can help you query and analyze data, adjust SQL queries, and confirm changes right in the IDE. This keeps database work in the same flow as your code, instead of bouncing between tools. External agents can access the same database support through an MCP server.

• Added support for 'Call hierarchy' function.

• Code Insight
  • False negative E0382 (use of moved value) on example from docs.
  • False Positive: format macro: Width specifier must be of type usize.
• Code editor
  • No highlighting for comments inside an attribute.
• Code insight. Macros
  • False Positive E0425: Incorrect macro expansion with path metavar.
• Debugger
  • Don't step into stdlib doesn't work on nightly.
• Formatter
  • View jumping after save / auto-format code.
• Tools
  • Call Hierarchy: Infinite opening in case of recursion.
• UI
  • Duplicate New item in the context menu in split-mode.

• You can now transform 'for_each' into 'for' and vice versa.
• Added the ability to specify visibility for a created file.

• Build & Run
  • Run Configuration parameters incorrectly parsed when there is the following sequence ".." "string".
• Code insight. TOML
  • cargo.toml: FP Property 'autolib' is not allowed.
• Project model
  • RustRover: Unresolved reference Zeroable when using bytemuck::Zeroable.
• Run Configuration
  • Run configuration incorrectly parsed backslashes and quotation marks on Windows.

• Code Insight
  • False positive[E0599] Method abs not found in the current scope for type i32.
  • Go to Declaration doesn't work for 'include!' macro with generated sources in OUT_DIR.
• Debugger
  • Pretty-printer test gdb.btree is failing on nightly.
• UI
  • Editor cursor becomes invisible after Quick-Fix Import.
• No subsystem
  • Rust: cannot delete line containing module definition.
  • After typing in an empty lib.rs file, Sync Cargo Changes floating button appears.

• Code Insight
  • False Positive E0070: assignment to pattern.
  • Incorrect deref_mut type inference for RPIT if the returned trait has DerefMut as supertrait.
• Code Insight. Resolve
  • False Positive E0412: Projection on type variable.
  • False Positive E0432: Unresolved import when parent is aliased.
  • False Positive E0433: Unresolved module from extern crate.
• External Linter
  • False positive trait bound not satisfied error exists only in Problems tool window.
• No subsystem
  • Do not suggest to add crate to dependencies for UR that can't be path to crate.
  • Invalid left-hand operand.