RustRover vs VS Code + rust-analyzer: What Changes in Your Rust Workflow

Comparison

RustRover vs VS Code + rust-analyzer: What Changes in Your Rust Workflow

As the team behind a dedicated Rust IDE, we’re naturally curious to see how RustRover stacks up against other popular setups for Rust development and the strengths and trade-offs of each one. This article is the first in a series where we’ll look at different Rust workflows.  

We’re not unbiased, but we want to give you an objective overview of what each tool offers. We’ll break down what each setup does well, its limitations, and what it’s like to use day-to-day. We’ll start with VS Code + rust-analyzer, one of the most common setups. We’ll also share a few tips for switching from VS Code to RustRover, so you can try it yourself and see what workflow is the best fit for you.

TL;DR: RustRover vs VS Code + rust-analyzer

• VS Code is a general-purpose editor. The rust-analyzer extension provides Rust-specific completion, diagnostics, navigation, and refactoring.
• RustRover is a professional Rust IDE with its own code analysis engine integrated with its Cargo project model, while other IDE tools use project context provided by that model.
• VS Code gives you a modular environment that you can customize with extensions, settings, tasks, and launch configurations.
• RustRover may suit developers who want code analysis, Cargo, testing, debugging, and refactoring connected through one project model.
• Either setup works well for day-to-day Rust development. The better fit depends on how you prefer to organize and configure your tools. Some developers prefer to keep both options available, and switch between them based on the task at hand.

VS Code + rust-analyzer and RustRover: A quick overview

VS Code + rust-analyzer

VS Code was launched by Microsoft back in 2015, with the first released version 1.0 in 2016. It’s a general-purpose editor that you can extend for different languages and workflows. For Rust, language support comes from rust-analyzer, which runs as a language server and analyzes the Cargo workspace behind the files you have opened. It provides completion, diagnostics, inlay hints, navigation, quick-fixes, and refactoring inside VS Code.

VS Code lets you further customize your setup with extensions, tasks, launch configurations, terminal commands, and personal settings. This makes it a flexible option for those who want to use the same editor for multiple languages.

RustRover

JetBrains introduced RustRover in public preview in 2023 and released it in 2024. It grew out of the IntelliJ Rust plugin, and we built it as a dedicated professional Rust IDE.

RustRover uses its own Rust analysis engine. When you open a Cargo project, the IDE analyzes the workspace and builds a model of its crates, dependencies, targets, and code structure. This understanding supports completion, navigation, inspections, quick-fixes, and project-wide refactoring.

Cargo, testing, debugging, databases, web dev support, and version control are also built into the IDE. RustRover remains configurable within this structure. You can customize keymaps, settings, code style, run configurations, toolchain behavior, and the interface, as well as install plugins for additional technologies and workflows.

RustRover vs VS Code: Key differences

Before we get into the table, a quick note about what we mean by “VS Code + rust-analyzer”: We’re focusing only on the parts of the setup that are essential for Rust development, which include the integrated terminal, tasks, launch configurations, and (in some cases) a debugger extension. We won’t cover every optional extension, only the tools needed for the workflows in this article.

The overview above explains how the two setups are put together. The table below shows how they differ when you navigate code, run Cargo targets, test, debug, and refactor.

Workflow area	VS Code + rust-analyzer	RustRover
Rust code analysis	Rust-specific analysis comes from the rust-analyzer language server, which runs through the VS Code extension.	RustRover does not use rust-analyzer. It uses JetBrains’ own Rust analysis engine, integrated with the IDE’s project model.
Navigation	rust-analyzer provides actions such as Go to Definition and Go to References. You can use them with VS Code’s Explorer and workspace search.	RustRover provides declaration and usage navigation through its indexed project model. The Project and Cargo tool windows provide additional workspace views.
Cargo and running code	You can run Cargo commands in the integrated terminal or start supported targets through rust-analyzer. Tasks can save commands you use regularly.	You can run targets from the editor or the Cargo tool window. RustRover creates run configurations that you can save and adjust.
Testing	You can run tests through rust-analyzer actions, Cargo commands, or VS Code tasks.	You can run tests from the editor or the Cargo tool window and view the results in the IDE’s test runner.
Debugging	Rust debugging requires a compatible extension, such as CodeLLDB or Microsoft C/C++. Launch configurations can save your debugger settings.	Rust debugging is included in the IDE and works through the same run/debug configurations used for targets and tests.
Inspections and refactoring	rust-analyzer provides diagnostics, quick-fixes, renaming, and other refactoring actions. Cargo Check or Clippy can provide additional feedback.	RustRover combines built-in inspections, quick-fixes, and refactoring tools with feedback from Cargo Check or Clippy. You can review affected usages before applying project-wide changes.

That difference in how the two setups are put together also comes up in community discussions. One Reddit user described it this way:

Comment
by u/metalciaga from discussion
in rust

AI-assisted development in VS Code and RustRover

If AI is part of your workflow, you can use it in either environment for quick suggestions or larger-scale tasks that use broader project context. The agents you can connect, how you access models, and which development tools those agents can use differ. Here is a short overview of AI capabilities in both environments. 

Area	VS Code	RustRover
AI workflows	VS Code supports inline suggestions, chat, planning, multi-file editing, and agent-driven tasks.	JetBrains AI provides code suggestions and other in-IDE features, while Air lets you run agent-driven tasks inside RustRover
Agent choice	You can use agent providers such as GitHub Copilot, Claude, and Codex.	Air works with agents including Junie, Claude Agent, Codex, GitHub Copilot, and OpenCode. You can also connect other compatible agents through ACP.
Models and accounts	You can use models included with a GitHub Copilot plan, connect supported providers with your own API key, or use supported local models.	You can use JetBrains AI, supported provider subscriptions, or your own API keys. Available options depend on the agent and provider you choose.
Development tools and context	Agents can work with workspace code, errors, tests, the terminal, and tools connected through MCP.	You can run agents inside RustRover and review their changes with the IDE’s project and code tools. Starting with RustRover 2026.3, agents can also control the debugger through MCP.

Air also goes beyond the IDE. You can use it through the web, command line, and mobile, while its team features cover shared environments and automations. For this comparison, we’re focusing on Air inside RustRover: running agents and reviewing their work alongside your code.

What do these differences look like in practice?

Imagine you are working in a multi-crate workspace. A function called from a binary crate is defined in a library crate and re-exported through another module. You need to find its declaration, check its uses, rename it, and run the tests that cover this functionality.

In VS Code, you can start with rust-analyzer’s Go to Definition action to find the function. Next, Go to References shows where it is used across the Cargo workspace, and Rename Symbol applies the new name across the relevant Rust files. Once the change is ready, you can run the affected test through a rust-analyzer action or use Cargo in the integrated terminal. If the test fails, rust-analyzer can provide the Debug action, while a compatible debugger extension provides debugging support. You can save commands and debugger settings in tasks and launch configurations to repeat the workflow.

In RustRover, you can start by following the function to its declaration through the IDE’s indexed project model. The Project and Cargo tool windows provide additional workspace views, while Find Usages shows where the function is referenced. You can then use the Rename refactoring and see what will change before applying the new name. Once the change is ready, run the test from its gutter action or the Cargo tool window. If it fails, you can start debugging from the same gutter action or run/debug configuration. RustRover creates a temporary configuration that you can save if you want to reuse the same arguments or environment variables.

Both environments can take you from navigation to a completed change. The difference is the path you follow and how the tools present the wider project context along the way.

We asked several Rust developers who normally used VS Code to work in RustRover for a week and keep a diary of their experience. This was a JetBrains study, so their comments do not represent every Rust developer, but they tell us a lot about what it’s like to make the switch.

“The debugger was easily the best part, honestly. Being able to stop right on the age check and see the real numbers made it click instead of me just assuming the math worked.”

Anonymous participant in a JetBrains RustRover diary study

How to switch from VS Code to RustRover in five steps

Switching from VS Code to RustRover doesn’t mean you have to re-learn everything. Follow the steps below to customize your setup so that RustRover feels familiar from day one. 

1. Import your settings and select the VS Code keymap

When you first open RustRover, select VS Code in the Import Settings dialog and choose what you want to bring over. This can include your keymap, theme, extensions, and recent projects.

2. Open a familiar Cargo project

Start with a real project rather than a sample. If the repository has multiple Cargo projects and RustRover asks which ones to attach, include the projects you want the IDE to work with. Do not dismiss the dialog without checking it, or parts of the repository may be missing from the project model.

Orhun Parmaksız, a JetBrains Developer Advocate and open-source Rust contributor, shared how he brought his familiar workflow into RustRover:

“When I move to a new IDE, I prefer to keep the keybindings and habits I already use. For RustRover, I used IdeaVim and asked Codex to adapt my Neovim configuration. I saved the result in my dotfiles so I could reuse it, and VS Code users can take the same approach with their own keybindings. The transition was smooth; the only drawback was needing to restart the IDE for the configuration changes to take effect.”

You can see Orhun’s .ideavimrc and RustRover configuration files on GitHub.

3. Check your Rust toolchain

Before opening the project, go to Settings | Rust and ensure that RustRover has detected the toolchain you expect to use. If the Toolchain version shows a version number and you do not see an option to install or download Rustup, you are ready to continue.

4. Wait for the project to load

Let the first Cargo sync and indexing finish before investigating red highlighting or unresolved code. At this stage, RustRover is still building its understanding of the project, so some warnings may be only temporary.

5. Run or debug something you’re already familiar with

Choose a familiar test or target and run or debug it from the editor. This is a quick way to confirm that the project, toolchain, and main development actions are ready.

If your project uses Cargo features, you can manage them through the IDE instead of a separate JSON configuration. For complete setup instructions and more VS Code equivalents, see the migration guide.

RustRover or VS Code: Choosing the right fit?

If you already use VS Code for several languages, prefer a lighter editor, and want to choose your own extensions and configuration, staying with VS Code and rust-analyzer may make the most sense. 

But if you want a professional Rust IDE with an integrated debugger, project-wide refactoring, Cargo.toml assistance, and tools that share the same understanding of your Cargo project, RustRover feels like a natural choice. The trade-off is that a full IDE can feel heavier and busier than an editor-based setup.

If you are still unsure, open one of your projects in both environments and try doing a task you perform regularly. Seeing each setup in action will tell you far more than a list of features ever could.

FAQ