Welcome to RustRover 2026.1. This version focuses on supporting the way modern Rust teams build, test, and maintain their code. Highlights include:
- Native cargo-nextest integration
- Call hierarchy for faster navigation
- Easier access to macro expansions
- Configurable visibility on module creation
- Support for more AI agents, including GitHub Copilot and Cursor
Key updates
Code analysis is now more accurate
We’ve continued improving RustRover’s code analysis, with a recent focus on reducing false positives that can cause confusion.
If you notice any false positives, please report them in our issue tracker so we can keep improving code insight.
Run tests faster with cargo-nextest support in the IDE
Running tests in large Rust workspaces can be slow with the default test runner. Many teams rely on cargo-nextest for faster, more scalable execution, but until now, it required switching to the terminal.We’ve added native support for cargo-nextest directly in the IDE. You can now run and monitor nextest sessions with full progress reporting and structured results in the Test tool window, without leaving your development workflow.
Trace call chains more easily
If you’ve ever tried to trace how execution reaches a function in a trait-heavy codebase, a flat list of usages can be hard to interpret. You get the matches, but you lose the bigger picture of the call chain.
RustRover 2026.1 adds Call Hierarchy support for Rust, so you can 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 most recently Codex, RustRover now lets you work with more AI agents directly in the AI chat. You can choose from agents such as GitHub Copilot, Cursor, and many others supported through the Agent Client Protocol (ACP).
Choose module visibility on creation
When you create a new module, you often know right away whether it should be public or private. Previously, that meant creating the file first and then updating visibility manually.
RustRover now lets you 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
RustRover 2026.1 updates LLDB to version 21, bringing performance and reliability improvements for debugging sessions. Expect faster loading of debug information through improved DWARF indexing and parallel shared-library parsing, along with more reliable breakpoint behavior in inline code.
Macro expansion, one step away
Rust macros can hide a lot of logic behind a single line. When you need to confirm what code will actually be compiled, seeing the expansion is often the fastest way to understand what is going on.
RustRover makes it easier to find macro expansions right where you need them. Use the gutter icon on macro calls or the ⌥↩ (macOS) / Alt+Enter (Windows/Linux) shortcut to open the Show Context Actions menu and inspect the generated code without leaving the editor.
Bug fixes and code insight improvements
Code insight improvements for derive macros
Derive and procedural macros generate code behind the scenes, which can make IDE analysis harder than it looks in the source.
RustRover 2026.1 improves name resolution to reduce misleading warnings and keep 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
If you work with nightly and compiler-internal crates (rustc_*
), you may have seen RustRover report E0463
errors even though the project still built successfully. That mismatch can make it harder to rely on editor feedback when you are working close to compiler internals. This RustRover 2026.1 reduces these 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 are available without consuming AI quota for JetBrains AI Pro, Ultimate, and Enterprise subscriptions, helping you keep changes consistent and stay in the flow while you iterate.
More agent options in the AI chat
RustRover now supports a wider choice of agents in the AI chat, including Junie and Codex, so you can pick the one that best fits the task at hand. It allows you to switch between assistance styles without leaving the development workflow.
AI help for database work
When you’re working with a connected database, 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.
Code With Me sunset
As we continue to evolve our IDEs and focus on the areas that deliver the most value to developers, we’ve decided to sunset Code With Me, our collaborative coding and pair programming service. Demand for this type of functionality has declined in recent years, and we’re prioritizing more modern workflows tailored to professional software development.
As of version 2026.1, Code With Me will be unbundled from all JetBrains IDEs. Instead, it will be available on JetBrains Marketplace as a separate plugin. 2026.1 will be the last IDE version to officially support Code With Me, as we gradually sunset the service.
Facts Only
RustRover 2026.1 is a new version of the Rust IDE released in 2026.
The update includes native support for cargo-nextest, allowing test execution within the IDE.
A Call Hierarchy feature has been added to visualize and navigate function call chains.
Macro expansions can now be accessed via a gutter icon or keyboard shortcut (⌥↩/Alt+Enter).
Module visibility (public/private) can be configured during creation in the New Rust Module dialog.
The IDE supports additional AI agents, including GitHub Copilot and Cursor, via the Agent Client Protocol (ACP).
LLDB has been updated to version 21, improving debugging performance and reliability.
Code analysis accuracy has been enhanced, reducing false positives in derive macros and rustc crates.
Next edit suggestions in AI tools no longer consume quota for JetBrains AI Pro, Ultimate, and Enterprise users.
AI chat can now assist with database queries and SQL adjustments.
Code With Me, the collaborative coding feature, will be unbundled from the IDE and eventually discontinued.
Executive Summary
RustRover 2026.1 introduces several enhancements aimed at improving Rust development workflows. Key updates include native integration with cargo-nextest for faster test execution, a new Call Hierarchy feature to trace function calls in complex codebases, and easier access to macro expansions directly from the editor. The IDE now supports additional AI agents like GitHub Copilot and Cursor through the Agent Client Protocol (ACP), while also allowing developers to set module visibility during creation. Performance improvements include an updated LLDB debugger (version 21) and reduced false positives in code analysis, particularly for derive macros and rustc crates. AI features have been expanded with quota-free next edit suggestions and database query assistance. Notably, Code With Me, the collaborative coding tool, will be unbundled and eventually sunset, reflecting a shift toward more modern workflows.
The release balances productivity gains with workflow refinements, addressing common pain points in Rust development. While the focus on AI integration and performance optimizations aligns with broader industry trends, the decision to phase out Code With Me suggests a strategic pivot away from real-time collaboration tools. The updates cater to both individual developers and teams, emphasizing efficiency and reliability in large-scale projects.
Full Take
This release reflects a broader trend in developer tooling: the convergence of AI assistance, performance optimization, and workflow specialization. The strongest version of this narrative is that RustRover is evolving to meet the needs of professional Rust teams by integrating high-demand features (like cargo-nextest) and reducing friction in complex workflows (e.g., macro expansions, call hierarchies). The decision to sunset Code With Me, while pragmatic, raises questions about the future of real-time collaboration in IDEs—does this signal a decline in demand, or a strategic shift toward asynchronous, AI-mediated workflows?
Pattern-wise, the announcement leans heavily on **ARC-0012 Authority by Association** (highlighting AI agents like GitHub Copilot) and **ARC-0034 Solutionism** (framing every update as an unalloyed improvement without acknowledging trade-offs, such as the potential overhead of AI integration). The phrasing around "modern Rust teams" and "more scalable execution" subtly invokes **ARC-0041 Progress Narrative**, implying that adoption of these tools is inevitable for "serious" developers.
Root cause: The paradigm here is **tool-driven productivity**, where the IDE becomes a Swiss Army knife of features, assuming that more integration equals better outcomes. This echoes the historical pattern of IDEs absorbing terminal workflows (e.g., test runners, debuggers) to centralize control—convenient, but risking vendor lock-in and cognitive overload.
Implications: For human agency, the AI integrations could democratize expertise (e.g., database queries) but also risk homogenizing problem-solving styles. The sunset of Code With Me may disproportionately affect remote teams or mentorship dynamics, where real-time collaboration is irreplaceable. Second-order consequences include potential fragmentation if AI agents become siloed (e.g., Copilot vs. Cursor) or if debugging performance gains mask underlying complexity in Rust projects.
Bridge questions:
1. How might the reliance on AI agents in IDEs shape the learning curves for new Rust developers? Could it create a dependency on "black-box" assistance?
2. What alternatives to Code With Me might emerge for teams that still prioritize pair programming, and how will JetBrains' pivot affect them?
3. If cargo-nextest integration speeds up testing, will this encourage more frequent testing, or will teams simply tolerate larger test suites without refactoring?
Counterstrike scan: A coordinated influence campaign pushing this narrative would emphasize **urgency** ("modern teams *need* these tools") and **exclusivity** ("only serious developers use RustRover"). The actual content avoids overt manipulation, focusing on feature announcements rather than fear-based messaging. The closest alignment is the implicit framing of AI as a necessity, but this stops short of predatory rhetoric. Clean.
Patterns detected: ARC-0012 Authority by Association, ARC-0034 Solutionism, ARC-0041 Progress Narrative
Sentinel — Human
The article exhibits strong human authorship signals, with natural language variation, domain expertise, and product-specific voice. No significant indicators of synthetic generation detected.