JetBrains Rider (EAP): baixar versions anteriors

Rider 2026.3 EAP 6: Release Notes
Let AI agents run .NET tests through Rider
Agents need to run tests to check their own work. Without IDE support, an agent runs dotnet test, parses the console output, and handles each test framework's quirks on its own. The Rider MCP server now supports this workflow.
An agent starts a test run with test_run_start and then retrieves its status and results. Rider builds the required projects, runs the tests through its own test infrastructure, and returns structured results to the agent, including test failures and build problems. Rider returns results in the same format regardless of the test framework or runner, including VSTest and Microsoft.Testing.Platform.
Nothing happens out of sight. Agent-run tests show up in Rider as regular test sessions: you can follow a run, inspect results and failures, and navigate directly to the relevant code.
Structured results can also require fewer tokens for the agent to process than raw console output, potentially reducing token usage and execution cost. How much depends on the model, project, context, and workflow.
Native WSL support – now in Beta
Rider now supports the Native WSL mode recently introduced in the IntelliJ Platform. You can open a solution stored inside WSL and work with it from Rider running on Windows: file access, indexing, build, code analysis, and debugging all use the Linux file system and toolchain. Rider uses IJent to interact with the WSL environment, while the IDE itself and the ReSharper language server stay on Windows.
Rider already detects .NET SDKs installed inside WSL to build your solution and supports debugging; support for unit tests and NuGet is coming next.
This support is in Beta, so expect some limitations and quirks.
Lua support in Rider
Lua is everywhere in game development: gameplay logic, engine customization, and hot updates. Now you can keep your engine code in C++ or C# and your Lua scripts in the same IDE, without relying on third-party Lua plugins.
We developed a new Lua plugin, which we maintain ourselves.. It's available in Beta on JetBrains Marketplace and supports Lua 5.1–5.4, LuaJIT, and Luau. You don't need to change how you annotate your code. Rider infers types from your existing EmmyLua, LuaLS, and LDoc comments and from Luau type annotations, so your project works as it is.
Here's what you get:
- Syntax and error highlighting, plus more than 35 inspections with quick-fixes.
- Completion, Quick Documentation, parameter info, and inlay hints.
- Go to Declaration, Find Usages, call hierarchy, and require path resolution.
- Refactorings like Rename, Extract Function, Inline, Change Signature, and Move to Module.
- A formatter with Lua code style settings.
To install the plugin, go to Settings | Plugins | Marketplace and search for "Lua". You can pick your dialect in Settings | Languages & Frameworks | Lua.
The plugin is in Beta, so expect some rough edges.
C# Interactive has been removed from Rider
C# Interactive is no longer part of Rider, starting with 2026.3 EAP 7.
Very few Rider users were actively using the feature, and it had accumulated several correctness and usability issues over time. Rather than maintaining a legacy workflow that no longer met our quality bar, we removed it as part of the ongoing simplification of the product.
If C# Interactive was important to your workflow, please let us know in our issue tracker.

For the complete list of updates included in this build, please see our release notes.

Rider 2026.3 EAP 6: Release Notes
Verse support in Rider – built from scratch
Rider now brings Verse, C++, and the Unreal Engine integration together in one IDE. Built from scratch on Rider’s own language engine, the new Verse Language plugin brings native Verse language support to the IDE without requiring an external language server.
The plugin highlights your code and reports errors as you type. It also gives you code completion, Go to Declaration, and Find Usages actions everywhere in your .NET solution, as well as Quick Documentation. The Rider MCP server makes all those features available to your AI agents.
To work on C++ and Verse in the same project, open your Unreal Engine 6 project's .sln or .uproject. You can also open the .code-workspace that Unreal Engine generates for Verse. It contains only your Verse files, so it loads quickly.
You can install this plugin by going to Settings | Plugins | Marketplace and searching for "Verse Language". The plugin is in Beta, so it’s still a little rough around the edges. For example, you can't navigate between C++ and Verse code yet.
What additional features would make Rider your go-to Verse editor? Tell us in our issue tracker.
Rider now fully supports .vcxproj.filters
Now, you can reorganize a C++ project in Rider, and your Visual Studio teammates will see the same structure. Rider updates .vcxproj.filters as you work:
- Create filters, including nested ones, and add new or existing files to them.
- Rename and move files and filters with drag-and-drop or refactorings.
- If a project doesn’t have a .filters file yet, Rider creates one when you add your first filter.
- When the .filters file changes outside of Rider (for example, when your teammate edits the project in Visual Studio or you pull the latest changes from version control), Rider updates the project tree accordingly.
- Toggle the project tree between the filter view and the on-disk folder structure at any time.
To turn it on, go to Settings | Languages & Frameworks | C/C++ | VCX filters and check the box.
This feature is experimental, so you may run into issues. If something doesn't work as expected, please report it to us. Your feedback will help us get the feature ready for release.
Debug Unity CoreCLR Players
Unity 6.7 introduces CoreCLR as a new scripting runtime for desktop Players, and Rider 2026.3 EAP now supports it along with Mono / IL2CPP. You can debug a CoreCLR Player, set breakpoints, and step through your code just as you would with Mono / IL2CPP.
Mono Players continue to work as before, so if you’re sticking with Mono for now, nothing changes. You can also try CoreCLR in a separate branch and compare how your game behaves on each runtime.
There are two important things to keep in mind:
- This change applies only to Players. In Unity 6.7, the Unity Editor (including Play mode) still uses Mono, so your Editor workflows in Rider will stay the same. However, if you're testing Unity 7 Alpha with the CoreCLR Editor, Rider already offers early support. We’ll continue to improve that support as Unity 7 evolves.
- CoreCLR Player support is still experimental. Unity is releasing it as a technical preview, so now is a great time to try it with your project and see how it behaves. If you have any issues debugging a CoreCLR Player in Rider, please report them in our issue tracker.
More responsive code editing
Editing code is now more reliable. We separated text editing from the rest of the IDE, so actions like typing, pressing Enter or Backspace, automatic indentation, and moving code elements no longer slow down when you open a solution or switch branches. That fixes some long-standing annoyances, like caret jumps or flicker during fast edits.
If anything behaves differently from what you expect, please let us know in our issue tracker.

For the complete list of updates included in this build, please see our release notes.

Rider 2026.3 EAP 5: Release Notes
JetBrains Air EAP in Rider
Air in Rider gives you one unified place to work with coding agents such as Codex, GitHub Copilot, Junie, Claude, and other ACP-compatible agents. It detects agents already installed on your machine and lets you use them inside your development environment, without requiring a separate JetBrains AI subscription.
Air helps you go beyond a single chat message. You can start several agent sessions simultaneously, follow their progress, and see which files have changed or need your attention. Agents can also use Rider tooling via skills, such as debugging and profiling, to investigate a problem with expanded context.
Rider remains the place where you review and validate the result, helping you work with less uncertainty and more confidence in what you ship. Yes, Air makes it much easier to delegate routine or larger tasks while keeping the changes, diffs, branches, and commits visible. Still, you decide what to accept, what to change, and when the work is ready to become part of your project.
Learn more

For the complete list of updates included in this build, please see our release notes.

Rider 2026.3 EAP 4: Release Notes
Async debugging from .NET 11
Rider’s async debugging tools now support Runtime Async, a new feature in .NET 11. You can set breakpoints and step through runtime-async methods, and Rider reconstructs async call stacks across await points, even in apps that use both traditional and runtime-async methods.
You can still see parameters and local variables at suspension points. They show up in the Threads & Variables tab, so you can check them just like you would in a regular stack frame.
If a simple stack view isn’t enough, try the Tasks tab. It now recognizes runtime-async methods and lets you explore complex chains of async operations to see how tasks connect.
Azure DevOps plugin
The Azure DevOps plugin now includes several updates that make it easier to manage your pull requests directly in Rider.
- You can now sign in to Azure DevOps using your Azure account. If you use a self-hosted server, token-based authentication is still supported.
- You can now see pull request events and discussions together on a single timeline.
- You can manage comments in the timeline, diff view, and code editor. This lets you reply to discussions, interact with existing comments, and add new ones without leaving Rider.
With these updates, the plugin now includes all of the features we had planned. Check this request for more details.
JetBrains Air in IDEs
JetBrains Air is now available in Rider 2026.3 EAP 4, bringing agentic development closer to the IDE. Benefit from your choice of coding agents, support for parallel workflows, and IDE-native review and verification.
Please note that the bundled Air plugin takes over a couple of keyboard shortcuts:
- ⌘2 on macOS / Alt+2 on Windows and Linux will open the Agent Session tool window instead of Bookmarks.
- Ctrl+Ctrl on any platform will open a quick input window instead of Run Anything.
Learn more.

For the complete list of updates included in this build, please see our release notes.

Rider 2026.3 EAP 3: Release Notes
New Welcome screen
With Rider’s new Welcome screen, you can get started right away without opening a solution. The Welcome screen is now part of the main IDE window rather than a separate one, so you can quickly edit a file, use the terminal, work with databases, or attach the debugger or profiler to a running process.
If you need to do more complex work, you can open or create a solution to use all of Rider’s intelligent features. You’ll still find your recent solutions and remote development connections in the Projects and Files tool window on the Welcome screen, so you can easily switch between quick tasks and full IDE work in one place.

For the complete list of updates included in this build, please see our release notes.

Rider 2026.3 EAP 2: Release Notes
New week – new EAP build!
Files view: Go beyond the .sln without leaving Rider
With the new Files view in Rider, you can see your repository just as it appears on disk. This makes it easy to open and edit a range of external files, such as CI pipelines, Dockerfiles, scripts, documentation, and AI agent instructions. You no longer have to add these files as solution items or create virtual folders in the IDE to access them.
The Files view replaces the File system view, which only covered the directory containing your .sln file. Search Everywhere can now find files available in the Files view, too.
This view is designed to be lightweight, offering simple browsing and editing without indexing your whole repository by default. If you have frontend projects outside your main solution, such as a React app alongside a .NET backend, you can enable full IDE support for them in Rider whenever you need to.
Rider’s Files and Solution views are designed to complement each other, letting you pick the best option for your work. Use the Solution view to focus on your projects, and switch to the Files view when you need to update configurations or look through the rest of your repository. If AI agents update code, specs, or examples, the Files view makes it easy to check related files and see the bigger picture, all without leaving Rider.
Get Rider ready for your AI agent
The AI Agent setup widget is a new entry point that is now available in the bottom-right status bar. This widget helps you find and set up Rider’s features for coding agents. When you open it, you’ll see a list of supported features like MCP tools, skills, and hooks, along with brief explanations of how each one can help your workflow.
The overview shows you which features are already enabled and which ones you can set up, with direct links to the right settings pages. No matter if your coding agent runs inside Rider or in an external terminal, the widget helps you see what Rider offers and quickly find the settings you need to begin.
Less noise and clearer context for AI agents with hooks
Rider’s hooks now provide AI agents with more targeted feedback after code changes. This helps cut down on unnecessary information and makes formatting changes coming from the IDE easier to spot.
Agents now get inspection results from the Run files inspections hook only for the code they added, not the whole file. This lets them focus on their own changes.
The Reformat file hook now gives a diff that shows any formatting changes made by the IDE. Agents can see what changed right away, so they don’t have to reread the file to understand the updates.
GDScript code completion goes further
Scene unique nodes (the ones marked with %) now show up in code completion. Rider reads the node names from your scene files, so you get the same suggestions you'd expect for any other symbol – instead of typing them from memory and finding out at runtime whether you got everything right.
Completion also works in the debugger's immediate window now. When you're paused at a breakpoint and want to inspect or call something, you get suggestions there too – no more writing expressions blind in the one place where mistakes cost you a debug session.

For the complete list of updates included in this build, please see our release notes.

The Rider 2026.3 Early Access Program is here!
The first early preview build comes with:
- Rainbow brackets in the code editor.
- Easier to set up data breakpoints for debugging Unreal Engine or custom C++ game engine code.
- Game Development category on the Plugins settings page.
- Test coverage for unit tests written with TUnit.
- Filters in code completion.
This blog post has all the details.
For the complete list of updates included in this build, please see our release notes.

Rider 2026.2 EAP 9 is out!
As we're moving closer to Rider's next stable release, the bulk of our work is now dedicated to bug fixes and under-the-hood work.
For the full list of changes included in this build, please refer to our release notes.

Rider 2026.2 EAP 8 is out with the following updates:
You may notice this build is labeled EAP 8. We skipped EAP 7 last week and rolled its changes into this fresh build. Everything from the planned EAP 7 is included here.
Evidence-based performance investigation with the new dottrace-analyze AI agent skill
Rider 2026.2 EAP 8 introduces dottrace-analyze, a new AI agent skill that lets the agents inside AI Assistant diagnose performance problems using runtime evidence instead of guesswork.
You can hand your AI agent a .dtp snapshot collected with dotTrace – using dotTrace inside Rider, the standalone dotTrace application, or the dotTrace command-line tool – and it reads the profile, finds where the CPU actually went, traces the hot path back into your code, and explains the root cause and how to fix it.
In our evals, the skill moved the agent from reliably lost to reliably correct, catching bottlenecks that are genuinely hard to spot by reading code alone. Get the full story on our blog.
New Welcome screen [Beta]
The new Welcome screen opens as a tab inside the IDE instead of blocking startup, helping you get to useful actions faster – whether you’re opening a full solution or using Rider’s tooling before a solution is loaded.
From the Welcome screen, you can open a project, return to recent work, manage plugins, launch the Terminal, attach the debugger or profiler to a running process, or work with databases without waiting for a solution to finish loading.
For the full list of changes included in this build, please refer to our release notes.

Rider 2026.2 EAP 6 is out with the following updates:
Cleaner async call stacks in the debugger
Rider 2026.2 EAP 6 improves how async call stacks are presented during debugging. The debugger now reduces noise from generated async and task infrastructure frames, making it easier to follow the logical flow of your code instead of digging through compiler-generated implementation details.
This should make debugging async .NET code feel closer to working with a regular synchronous call stack: the relevant project frames are easier to spot, while the lower-level generated frames remain available when you need to inspect the full execution details.
To get more information on the key updates of this EAP cycle, see our blog.
For the full list of changes included in this build, please refer to our release notes.

Rider 2026.2 EAP 5 comes with the following updates:
- Quality-check hooks for Claude Code and Codex.
- Improved Explain with AI discoverability for build errors and runtime exceptions.
More about each of these changes on our blog.
For the full list of changes included in this build, please refer to our release notes.

Rider 2026.2 EAP 4 is out with the following updates:
New in Azure DevOps support: Pull requests
Rider 2026.2 EAP expands Azure DevOps support with the introduction of pull requests.
The new Azure DevOps tool window lets you list and filter pull requests, review changed files, vote, complete existing PRs, and create new ones without having to switch to any external tools. You can review PRs in the context of your project with full access to Rider’s code insight, navigation, and editing features.
To get started, clone a project from Azure DevOps and connect using a personal access token.
We’re working toward a more complete Azure DevOps review workflow in Rider. Timeline view and in-editor PR comments and discussions are planned for future updates.
Support for Godot Asset Store development
In addition to the recently added project templates for CMake and Godot projects, this preview build introduces support for creating Godot Asset Store addons directly from Rider.
You can now use dedicated project templates to start new Godot addons, including script-based assets, editor plugins, and native C++ GDExtensions. The generated projects come with a preconfigured structure, build settings, and run configurations, so you can run the Godot editor and debug GDScript or native C++ code from Rider with less setup.
The templates also follow the official Godot Asset Store submission recommendations, helping you keep your addons publish-ready from the start.
Check out our documentation for a comprehensive guide.
The official JetBrains Rider Integration add-on
We’re also publishing our official Godot addon, JetBrains Rider Integration, on the Godot Asset Store. The addon simplifies connecting Rider as an external editor for Godot, giving you access to Rider’s code insight, navigation, inspections, and debugging support while working on Godot games and addons.
For the full list of changes included in this build, please refer to our release notes.

Rider 2026.2 EAP 3 is out with the following changes:
- New AI agent skill to reduce token use for test generation
- The ability to preview suggested code changes
- Project templates for Godot and CMake
- Improved experience in the NuGet tool window
- Backend memory usage improvements
For more information please see our blog post.
For the full list of resolved issues and improvements, please refer to the release notes.

Rider 2026.2 EAP 2 comes with the following updates:
Faster debugger startup and restart
We've made several performance improvements to the debugger:
- Debugger startup on Windows is now around 3 seconds faster in affected scenarios. This improvement addresses a debugger worker startup delay that could affect .NET, Mono, and Unity debugging, as well as some mixed-mode debugging workflows.
- Restarting an application with Monitoring enabled is also faster, with the delay reduced by approximately 2 seconds.
- We've also reworked silent exception handling to improve performance when debugging applications that throw and catch a large number of exceptions.
- This build fixes memory leaks and removes unnecessary startup-time calculations that could affect debugger stability and responsiveness.
Improved source generator debugging
Debugging source generators should now work more reliably with newer SDKs on Linux and macOS. Starting a debugging session no longer requires a successful build of the target project, and target project files are no longer compiled before startup, which should make the workflow faster.
XAML Hot Reload for WPF is now available in Beta
You can now edit XAML while your WPF application is running and apply the changes without losing the current application state or rebuilding and restarting during UI iteration. Together with the existing C# Hot Reload support, this completes the core WPF edit-and-continue workflow in Rider.
We'd appreciate your feedback on this feature. Please leave your comments here.
Basic Natvis support on Linux and macOS
Rider 2026.2 EAP 2 introduces basic Natvis support for the C++ debugger on Linux and macOS, improving the debugging experience when inspecting native data structures across platforms.
For the full list of changes included in this build, please refer to our release notes.

The Rider 2026.2 Early Access Program is here!
The first early preview build comes with:
- Major Roslyn performance improvements that make branch switching in large and complex solutions significantly faster.
- Game development updates, including reworked handling of Unity asmdef references and improvements to GDScript support.
- Azure Functions support for local development moving directly into Rider, with project and trigger creation, running, debugging, Azurite integration, and Docker debugging support.
- Aspire improvements, including support for file-based AppHosts, improved dev certificate validation, and resource status indicators and commands in the editor gutter.
This blog post has all the details.
For the complete list of updates included in this build, please see our release notes.

Rider 2026.1 EAP 8 is out!
As we're moving closer to Rider's next stable release, the bulk of our work is now dedicated to bug fixes and under-the-hood work.
Click here to review the full list of issues resolved in this build.

Rider 2026.1 EAP 7 comes with the following updates:
CMake support for C++ projects [Beta]
Rider 2026.1 introduces Beta support for CMake-based C++ projects, allowing you to open, edit, and build them directly in the IDE. This makes it easier to work with cross-platform projects without switching to another build system.
The initial implementation focuses on C++ workflows,including editing and debugging CMake configuration files. Some workflows and edge cases may still require refinement, and we'll continue improving performance and compatibility in upcoming releases. We would love for you to share your experience in this ticket.
Smoother MAUI iOS development workflow from Windows
Developing .NET MAUI applications for iOS from Windows requires connecting Rider to a Mac build host. Rider 2026.1 streamlines this workflow with a new setup experience that automatically prepares the remote environment.
When you connect to a Mac, Rider now verifies the remote system configuration, including macOS, Xcode, the .NET SDK, and required MAUI workloads. If any components are missing, Rider can install or update them automatically, helping you get started faster.
We've also improved diagnostics and connection stability, and fixed issues that previously prevented MAUI apps from deploying to iOS simulators or devices from Windows. You can now build, deploy, and debug MAUI iOS applications from Windows more reliably.
Decompiler
The decompiler now supports C# 14 user-defined compound assignment operators.
Notable fixes
We're continuing to improve the new expressions evaluator for Unreal Engine projects. This build comes with fixes for issues [RIDER-136243] and [RIDER-136070].

For the full list of changes included in this build, please refer to our issue tracker.

Rider 2026.1 EAP 6
As we're approaching Rider's next stable release, the bulk of our work on this EAP was dedicated to bug fixes and under-the-hood work.
For the full list of fixes and improvements, please refer to our issue tracker.

Rider 2026.1 EAP 5 comes with the following updates:
Debug Unreal Engine projects on iOS mobile and VR devices
Following Android debugging for mobile and VR devices introduced in Rider 2025.3, we're now completing the mobile game development picture with iOS support.
On macOS, you can now debug Unreal Engine games on iOS-based mobile and VR devices directly from Rider. Set breakpoints, inspect variables, step through code, and analyze call stacks – all within the familiar debugger interface.
Initial Xcode setup for provisioning and signing is still required per Apple's requirements.
F# support
Stepping during debugging is now supported for async and task expressions.
Notable fixes
For the full list of changes included in this build, please refer to our issue tracker.

Rider 2026.1 EAP 4 comes with the following updates:
Support for file-based C# programs
Rider now supports working with single-file C# programs that can be run using dotnet run file.cs. You can open a standalone .cs file without a .csproj and run it directly from the IDE.
Rider's editor recognizes file-based programs with top-level statements, #! shebangs, and #: directives, including #:package and #:sdk. Code highlighting, completion, run markers, and debugging are all available, allowing you to create quick scripts, prototypes, and one-off tools written as a single C# file.
Push-to-Hint in Remote Development
Push-to-Hint is now available in Remote Development mode.
You can temporarily reveal inline hints that are normally hidden by activating Push-to-Hint (double-press and hold Ctrl). This shows additional code hints without permanently enabling them. The widget for this feature lets you pin the mode or quickly access related settings.

At the moment, hints displayed in Push-to-Hint mode are informational only – actions on hints are not yet available in Remote Development.
Notable fixes
We've fixed an issue where disabling the Code With Me plugin prevented any run configuration from being launched. [RIDER-135511]
For the full list of changes included in this build, please refer to our issue tracker.

Rider 2026.1. EAP 3 is out with the following changes:
F# debugging
- Smart Step Into lets you skip intermediate calls and step directly into the selected function.
- Function return values are now shown in the Local Values view.
- Stepping behavior has been reworked to handle curried functions, constructors, and other F#-specific patterns correctly. This also avoids unintended stepping into compiler-generated tuple code, resulting in more predictable debugging.
C++ debugging
We continue to improve Rider's expression evaluator used for Unreal Engine debugging. This update includes better handling of runtime evaluation errors [RIDER-134740], implicit array decay in expressions [RIDER-135055], support for string literal operations [RIDER-135267], and new Natvis-based intrinsics such as strstr() and wcsstr()[RIDER-134815].
See our blog post for details on the broader Unreal Engine debugging improvements.
For the full list of changes included in this build, please refer to our issue tracker.

Rider 2026.1 EAP 2 is out with the following changes:
New design for the Hot Reload function
The UI shown when source code changes are detected during run and debug sessions has been updated. The previous banner-style prompt has been replaced with a compact floating toolbar in the top-right corner of the editor.
The toolbar displays a fire icon to prompt applying code changes, which is replaced by a green check indicator after the changes are successfully applied. A kebab menu is also available to configure Hot Reload behavior.
New C++ folding settings
In addition to the C++ naming rule improvements introduced in EAP 1, this build introduces new C++ folding settings under Code Folding | C/C++. You can choose to fold template parameters by default, to fold lambdas, and to use space instead of a new line before { in a collapsed state.
For the full list of changes included in this build, please refer to our issue tracker.

Rider 2026.1 EAP 1 comes with the following updates:
- .NET runtime updated to .NET 10
- New C# inspections, quick-fixes, and improvements to code completion and generation.
- Azure DevOps integration: The ability to clone repositories from Rider
- Package Manager Console with NuGet PowerShell and EFCore commands support
- .NET mixed-mode debugging on Windows
- The ability to inspect .NET assembly output via the new .NET Disassembler plugin
- Enhanced integration with the Godot Editor
- Improved Natvis expression evaluation
- C++ naming rules improvements

Learn more about these updates in this blog post.

Rider 2025.3 EAP 8 is out!
As we're approaching Rider's next stable release, the bulk of our work on this EAP was dedicated to bug fixes and under-the-hood work.
Important fixes included:
The Navigate | File Member action now correctly displays the structure of the current file in C++ projects, instead of showing data from a previously opened file. [RIDER-131674]
For the full list of fixes and improvements, please refer to our issue tracker.

Rider 2025.3 EAP 7 comes with the following updates:
Debugger support for C# 12 Inline Arrays
Rider's .NET debugger now supports the InlineArray types introduced in C# 12. You can easily view, expand, and inspect inline array elements while debugging, with clear element indexing and value display in the Locals window.
Faster startup and reduced memory usage
Project loading is now noticeably faster thanks to workspace model optimizations and lazy loading of project nodes. Rider now loads only essential project data at startup, fetching the rest on demand. These improvements significantly speed up startup and lower memory usage, especially in large solutions.
For the full list of fixes and improvements, please refer to our issue tracker.

Rider 2025.3 EAP 6 comes with the following updates:
Database and ASP.NET issue detection in the Monitoring tool
The Monitoring tool window in EAP 6 introduces database and ASP.NET issue detection, expanding its capabilities beyond CPU, memory, and GC tracking. You can now see slow queries, inefficient request handling, and other performance bottlenecks appear and update in real time as your application runs.
Learn more in this blog post.
Notable fixes
Navigating to file members now works correctly for C++. [RIDER-131308]
For the full list of fixes and improvements, please refer to our issue tracker.

Rider 2025.3 EAP 5 is out with the following updates:
Constexpr debugger for Unreal Engine projects
Rider now supports debugging constexpr code in C++. You can pause execution inside constexpr functions, inspect variables, and evaluate expressions just like in regular runtime debugging. Learn more in our blog post.
For the full list of fixes and improvements, please refer to our issue tracker.

Rider 2025.3 EAP 4 is out with the following updates:
The bulk of our work for this build was dedicated to bug fixes and under-the-hood work for better performance. You can learn more about that from Rider's Roadmap.
The Islands UI theme
Have you tried the new Islands theme in Rider yet? You can enable it in Settings/Preferences | Appearance & Behavior | Appearance | Theme. We’d love to hear your feedback as we continue to refine the new look of the IDE.
For the full list of fixes and improvements, please refer to our issue tracker.

Rider 2025.3 EAP 3 introduces the following updates:
- It is now possible to switch from .sln to .uproject files in Solution Explorer.
- Local-path Unity packages are now displayed in Solution Explorer without restarting.
- Find Usages for Blueprints in the Config and Content folders now works as expected.
- Find Usages for JavaScript methods starting with # in multi-module projects now works as expected.
- We’ve resolved the connection issues that previously affected Microsoft SQL Server LocalDB databases when using the JetBrains JDBC driver.
For the full list of fixes and improvements, please refer to our issue tracker.

Rider 2025.3 EAP 2 is out with the following changes:
Godot
- Improvements to GDScript debugging, including support for debugging specific scenes, tool scripts, and devices, as well as passing arguments.
- Expanded GDScript language support with better handling of nested classes and enums. The inspection for unused parameters has also been refined to highlight the parameter itself.
New Islands theme
- Rider now includes the new Islands theme, giving the IDE a refreshed look and feel. You can enable it in Settings/Preferences | Appearance & Behavior | Appearance | Theme. We’d love to hear your feedback as we continue refining it.
C++ debugging
- When debugging minidumps, Rider can now automatically download binaries and symbols from symbol servers.
Fixes and improvements
- The Code Annotations settings page no longer gets stuck in a loading state.
- Surround With and related actions now behave as expected.
- Environment.CurrentDirectory now correctly points to the output directory when using a Launch Settings run configuration.
- Menus on Linux now have rounded corners for a more consistent look across platforms.
- The Show Usage popup now displays the full file path.
For the full list of changes included in this build, please refer to our issue tracker.

The Early Access Program for Rider 2025.3 Is Here!
This first build brings a variety of updates for Unity, Unreal Engine, Godot, and more.
Unity
- Added an IL Viewer for Unity projects.
Unreal Engine
- Customizable folders and files in the .uproject project model.
Godot
- Added support for typed Dictionary in GDScript.
- Inconsistent leading whitespace inspection for GDScript files.
- New project template for developing GDExtensions.
- Added support for the Chickensoft GoDotTest test runner.
- Rider can now automatically build when focus moves away from the IDE, ensuring the Godot Inspector reloads and updates exported properties.
Solution management
- You can now create .slnx solution files directly from Rider templates, without having to manually convert .sln files.
For more details about these updates, read our blog post. Check out all the changes included in this build in the issue tracker.

Rider 2025.2 EAP 8 is out!
As we're moving closer to Rider's next stable release, the bulk of our work is now dedicated to bug fixes and under-the-hood work.
If this is your first Early Access Program (EAP) build for the 2025.2 cycle, be sure to check out these blog posts to catch up on the new features and enhancements introduced so far.
Click here to review the full list of issues resolved in this build.

Rider 2025.2 EAP 7 comes with:
Low-level exception suppression for C++ and game development
You can now suppress low-level exceptions and signals triggered by manual breakpoints like int3 across all platforms. This gives you more control when debugging C++ game projects and lets you skip over certain asserts without constantly resuming execution.
Read the blog post for all the details.
For the full list of changes included in this build, please see our issue tracker.

Rider 2025.2 EAP 6 comes with:
Unity shader debugging with the new Frame Viewer plugin
The new Frame Viewer plugin introduces source-level debugging for Unity shaders. Developers can inspect .rdc snapshots from RenderDoc, step through original ShaderLab code, set breakpoints, and analyze draw calls with vertex and pixel selection, texture previews, and shader-based filters.
The Frame Viewer plugin is currently only available for Unity projects on Windows.
Major update to GDScript support
GDScript support has been significantly upgraded by integrating the former third-party plugin directly into Rider. This update resolves SDK initialization issues, fixes missing references like Globals, improves icon rendering, and eliminates reliance on insecure SDK downloads.
Roslyn code completion support
Support for Roslyn-based completions has been added. Analyzer packages using the CompletionProvider API can now deliver context-aware code suggestions through the Roslyn CompletionService, enabling richer completions for ASP.NET Core and custom project scenarios.
The ability to pause all processes on a breakpoint
Rider now includes an option to pause all attached native processes when a breakpoint is hit during multi-process debugging. This improves debugging consistency in complex scenarios, such as game development or distributed systems.
You can enable this behavior by going to Settings/Preferences | Build, Execution, Deployment | Debugger and checking the Pause all native processes on breakpoint hit option.
New UI styles: One Island vs Many Islands
In the latest 2025.2 EAP of JetBrains IDEs, you can find two new UI styles: One Island and Many Islands, each available with both dark and light modes. Ultimately, one of these styles will become the new default – your feedback will help us decide which one. More on that here.
For the full list of changes included in this build, please see our issue tracker.

Rider 2025.2 EAP 5 comes with:
Reimagined Monitoring tool
The EAP 5 build introduces an improved version of the Monitoring tool, designed to make performance optimization a breeze for .NET applications. New interactive charts visualize runtime performance while intelligent detection automatically flags bottlenecks and issues. One click takes you from a finding to the responsible piece of code, with the option of a full investigation through bundled dotTrace and dotMemory profilers.
You can learn more on our blog.
OpenTelemetry plugin for JetBrains Rider
Get runtime observability without leaving your IDE! The new plugin brings logs, metrics, and traces directly into Rider. Click from any log entry straight to the responsible code, visualize performance metrics, and see auto-generated architecture diagrams based on your application's flow.
This blog post has all the details.
For the full list of changes included in this build, please see our issue tracker.

Rider 2025.2 EAP 4 comes with:
SQL project support via bundled plugin
Rider now provides support for SQL database projects via a bundled plugin. The plugin works out of the box and delivers a smoother experience for working with SQL database projects. Key capabilities include:
- Support for Microsoft.Build.Sql SDK-style projects
- Project templates for creating new SDK-style SQL database projects
- Schema comparison
- Project publishing
- Importing projects from a database
- Adding database references
C# support
C# 14's null-conditional assignments
Rider now provides initial support for a?.b = c and a?[i] = c syntax from C# 14, allowing you to write safer, more concise conditional assignments without explicit null checks.
LoggerMessageAttribute refactoring
When working with Microsoft.Extensions.Logging package, there's now a new context action to convert ILogger method calls into LoggerMessageAttribute-based methods for improved performance.
Smarter ILogger<T> completion
Now when you write ILogger<>, Rider will suggest the current type as a context-aware completion inside the angled brackets.
inside the angled brackets.

For the full list of changes included in this build, please see our issue tracker.

Rider 2025.2 EAP 3 comes with:
Mixed-mode debugging for Unity on Windows x64
You can now debug managed and native code side-by-side using Unity mixed-mode debugger support. The feature is technically implemented to support Mono mixed-mode debugging, so if you use Mono runtime outside of Unity the feature will also be useful for you. You can enable it in Unity or .NET project run configurations.
All the features of both debuggers are supported and you can step into native code from managed code by stepping into "extern" methods.
Hit count conditions for C++ breakpoints
Rider's native debugger now supports hit count conditions for breakpoints in C++ code. You can set breakpoints to trigger only under specific conditions – like on the 10th time it's hit, every 5th time, or after it's been hit 10 times total. This works across all supported native debuggers: LLDB, GDB, and DAP (PlayStation).
C++ support
You can now fold regions defined by // region and // endregion comments in C++ code for easier navigation and structure management.
Notable fixes:
We've resolved a long-standing issue where buttons in the Immediate window's toolbar would disappear when using the expression evaluation tab. [RIDER-121332]
Fixes for Unity debugger
Several issues affecting Unity debugging have been resolved in this build:
- Performance improvements:
- In most cases, the debugger pauses runtime much less frequently.
- Breakpoints in generic classes and methods don't cause Rider and Unity to freeze.
- Exception breakpoints are now processed more quickly and reliably.
- The resume/suspend imbalance issue has been fixed.
- An error is now reported when attempting to attach to Unity if it was left in an inconsistent state by a previous debugging session.
You can explore each fix in more detail by going to this parent-ticket.

For the full list of changes included in this build, please see our issue tracker.

Rider 2025.2 EAP 2 build comes with:
Step filters in C++ debugging
Rider now supports step filters for C++, helping you skip over library or framework code when stepping into functions during debugging. It reads both default and user-defined .natstepfilter files, which define which functions should be excluded from step-into actions. Rider also recognizes .natjmc files and treats them as step filters. These filters can also be configured manually in Settings/Options | Build, Execution, Deployment | Debugger | Stepping.
For the full list of changes included in this build, please see our issue tracker.

The Rider 2025.2 Early Access Program is here!
The first early preview build introduces:
- Support for Roslyn-based suppressors.
- Return of the Pencils widget (also available in Rider 2025.1.2).
- A few important bug-fixes.
This blog post has all the details.
For the complete list of updates included in this build, please see our issue tracker.

Rider 2025.1 EAP 9 is out!
As we're moving closer to Rider's next stable release, the bulk of our work is now dedicated to bug fixes and under-the-hood work.

Click here to review the full list of issues resolved in this build.

Rider 2025.1 EAP 8 comes with the following updates:
Remote development in Rider is moving to JetBrains Toolbox
Starting with the 2025.1 release, remote development in Rider can now be managed through the JetBrains Toolbox App. While Gateway remains available for remote access to Linux machines, the transition to Toolbox has begun, with the goal of making it the primary access point for remote development in future releases.
The latest Early Preview build for Toolbox introduces full remote development support, allowing you to connect to Windows, macOS, and Linux hosts, set up SSH access with OpenSSH, and keep all your projects in one place.
For more details and a step-by-step guide, check out this blog post from the Toolbox team.
Support for Azure Function projects
Rider 2025.1 now supports running and debugging Azure Function projects via the .NET Aspire and the Azure Toolkit for Rider plugins. Please share any feedback you may have on the functionality in the comments to this ticket.
Support for AWS Lambda Function projects in .NET Aspire
The .NET Aspire plugin now also supports running and debugging AWS Lambda Function projects in Rider. For more information, please see this GitHub issue.
For full information about the updates included in this build, please see our issue tracker.

Rider 2025.1 EAP 7 is out
This release contains smaller bug-fixes and improvements to the performance and stability of the IDE.
For full information about the changes included in this build, please see our issue tracker.

Rider 2025.1 EAP 6 comes with the following updates:
New Detach button for C++ debugging
Rider now offers a Detach button when debugging C++ applications. You can now detach from a running C++ process without terminating it, allowing the application to continue executing independently.
The Detach button can be found in the Run/Debug menu during the debugging of C++ applications or on the toolbar of the Debugger tool window.
String interpolation support in the Decompiler tool window
Support for C# string interpolation is now available in the decompiler, making the output more readable and aligned with modern C# best practices.
The decompiler will now automatically transform string.Concat and string.Format calls into C# string interpolation where applicable.
For full information about the updates included in this build, please see our issue tracker.

Rider 2025.1 EAP 5 comes with the following updates:
- Roslyn syntax tree visualizer
- Support for dotnet watch as a run/debug configuration
- Input/output redirection for run configurations
- Enhanced C++ debugging on Windows
- Unity Profiler integration
For full details about the updates included in this build, check out this blog post.

Rider 2025.1 EAP 4 comes with the following updates:
Game development
NoesisGUI framework support: We've added support for the NoesisGUI for Unity and Unreal Engine projects, expanding the range of C++ game UI libraries available for game development in Rider.
We've also resolved an issue where the NoesisGUI preview on Windows would get stuck in an endless loading state. [RIDER-122145]
Godot improvements: Rider now supports .uid files in Godot 4.4. When files are moved within Rider, the corresponding .uid files are moved together to maintain project integrity.
C++ native debugger (LLDB) improvements for Windows
In addition to the performance enhancements we revealed in EAP 2, we've also made improvements to Natvis support, stepping accuracy, and debugging stability for Unreal Engine and other C++ projects on Windows. Here are some highlights:
- We improved type visualization by adding support for Synthetic items in Natvis, enhancing Unreal Engine debugging. [RIDER-116407]
- We added support for the NVO format specifier in Natvis. [RIDER-120524]
- We enabled Natvis intrinsics in expression evaluation, within other Natvis types, and in conditional breakpoints. [RIDER-111190]
- We added support for char8_t from C++20. [RIDER-120687]
- We added a link to apply an expression fix with a single click. [RIDER-114653]
- We implemented support for exclamation syntax (module.dll!expr) in the context operator for expression evaluation and conditional breakpoints. [RIDER-119956]
- We improved stepping accuracy in debugging. Stop-over no longer falls into inline functions incorrectly, and the Step-in and Step-over actions now stop at the correct lines. [RIDER-119314]
- We resolved an issue where debugging sessions could crash the target process due to access violations, particularly in optimized Unreal Engine builds. [RIDER-121706]
.NET debugger fixes
We've fixed an issue where expressions in the Immediate Window were evaluated twice, ensuring correct debugging behavior. [RIDER-83380]
Code navigation
We added support for the Next Highlighted Usage and Previous Highlighted Usage actions to improve code navigation. [RIDER-15896]
Decompiler improvements
- Support has been added for the allows ref struct generic anti-constraint from C#13. [DOTP-8182]
- Support has been added for ref fields and scoped parameter modifiers. [DOTP-8181]
- Support has been added for file-scoped namespaces. [DOTP-8184]
For full information about the updates included in this build, please see our issue tracker.

Rider 2025.1 EAP 3 comes with the following updates:
- Proper support for Blazor WebAssembly publishing.
- The main menu has been merged with the main toolbar on Windows and Linux.
- The option to set up automatic plugin updates.
- Several decompiler enhancements.
For full information about the updates included in this build, check out this blog post.

Rider 2025.1 EAP 2 build comes with:
Easier environment variable configuration with .env files
Rider 2025.1 EAP 2 simplifies the management of environment variables. Instead of entering variables manually, you can now use .env files directly in your run/debug configurations.
Look for the folder icon (Browse) next to the Environment Variables field to attach your .env files, and Rider will take care of loading them before launch. You can even use multiple files across different projects to maintain consistent configurations.
A Load .env option is also available as a pre-launch task to ensure your environment variables are ready when your application starts.
Faster debugging for C++ projects
Rider 2025.1 brings faster stepping times to debugging large C++ projects, particularly in Unreal Engine development. Thanks to targeted optimizations in our custom LLDB debugger, delays during step-over and step-into operations have been dramatically reduced. This blog post has all the details.
Improvements for remote development environments
This build also brings improvements to workflows in Docker containers and other remote environments. Check out this blog post to learn more.
For full information about the updates included in this build, please see our issue tracker.

The Rider 2025.1 Early Access Program is here!
The first early preview build introduces:
- Repository-wide visibility in the Solution Explorer.
- Automatic child processes attachment for the .NET debugger.
- Enhanced .NET exception breakpoint configuration.
- Separate color settings for C++ keywords.
For full information about the updates included in this build, check out this blog post.

Rider 2024.3 EAP 5 is out with:
C# 13 field keyword support (preview features)
Rider 2024.3 offers support for the field keyword. With the introduction of this keyword, instead of using separate field declarations for properties, you can now directly access the anonymous backing field inside the property accessors, simplifying property declarations, especially when validation, transformations, or computations are needed.
Multiline TODO comments support
Rider 2024.3 now supports multiline TODO comments, allowing indented text on subsequent lines to be treated as part of the same TODO item. This enhancement makes it easier to group related notes and tasks together in your codebase. You can now add context to your TODOs across multiple lines, improving readability and organization.
Additionally, if you encounter a to-do item in code that links to an external issue, you can use Peek To-do link action (Ctrl+Shift+click) to display the issue inline.
Code cleanup
We've significantly reworked the internals of Code Cleanup modules responsible for applying quick-fixes, such as those used to remove code redundancies. This update aligns Code Cleanup with the same engine that powers the scoped application of quick-fixes. We've also enhanced the engine to ensure it fully resolves issues, addressing rare cases where scoped applications previously left additional suggestions unresolved. In addition, more code analyzers have been fine-tuned for greater granularity, building on the improvements introduced in Rider 2024.2. Finally, we implemented parallel preprocessing in Code Cleanup, which optimizes file processing for better performance.
Freeze/Thaw individual threads during debugging
Rider 2024.3 introduces the ability to freeze and thaw individual threads during debugging sessions for more precise control over multithreaded applications. This feature allows you to right-click on any thread and select Freeze to pause its execution without affecting the rest of the application. When you're ready, you can right-click again and select Thaw to resume the thread’s execution.
Support for primary constructors in the Decompiler
When working with classes that declare a primary constructor, the Decompiler will now display the constructor and its parameters correctly, giving you a complete view of how objects are instantiated directly from the decompiled code.

For the full list of updates, please refer to our issue tracker.

Rider 2024.3 EAP 4 is out with:
User experience
Run widget: Launch multiple configurations simultaneously
The updated Run widget now allows launching multiple configurations at once by holding Ctrl and clicking the debug icon. It also displays the controls for all running configurations, simplifying management.

Increased default tab limit
The default tab limit in the editor has been increased to 30, allowing more tabs to stay open before closing the least recently used ones. You can adjust this in Settings | Editor | General | Editor Tabs.

Updated UI for the new terminal
We've updated the new terminal's UI with a more compact design, reducing padding to maximize your screen real estate. The smaller padding saves space, giving you enhanced visibility while working with commands without sacrificing readability.

Unity
The solution scope now correctly displays only the files listed in the generated .csproj files. Additionally, the All Places and Non-Solution Items search scopes now function as expected, including files from the Assets, ProjectSettings, UserSettings, and all Unity package directories.
For the full list of updates, please refer to our issue tracker.

Rider 2024.3 EAP 3 is out with:
Windows Forms Designer for .NET projects
At long last, Windows Forms Designer now works for projects that target .NET 6.0 and up, helping you create, observe, and modify the UI of your Windows Forms applications. You will get pretty much the same experience and functionality as in Windows Forms Designer for the classic .NET Framework.
As for limitations, please keep in mind that third-party controls and VB.NET Windows Forms applications are not supported.
The embedded decompiler
The IL Viewer now provides IL code for assembly manifest files, including:
- Assembly and module info such as name, custom attributes, etc.
- Referenced assemblies and modules.
- Forwarded types.
- A list of files and resources.
This IL code is shown when the caret in the text editor is on an assembly or module attribute, or somewhere inside an <AssemblyName>.cs file for external assemblies.
Docker and Kubernetes
- Cluster-level Kubernetes log streaming and analysis with pattern matching.
- Support for network policies in the Kubernetes UI.
- New Docker Compose build attributes.
More details can be found on our blog.
Infrastructure as Code
- OpenTofu support.
- Terraform usage indicators.
- Terraform fmt support.
More details can be found on our blog.
For the full list of improvements and fixes included in this build, please refer to our issue tracker.

Rider 2024.3 EAP1 Is Here!
Support for hot reloading C++ with Live++
We've been working with the folks at Live++ to bring seamless C++ hot reloading support to Rider! There's no new UI, but the user experience should be a lot smoother.
Other features and improvements
- Ability to select the Code Cleanup profile for each file and to skip code cleanup from running on a file.
- New options to adjust C# naming rules more precisely.
- Built-in live templates to generate UE_LOG and UE_LOGFMT logging statements in Unreal Engine solutions.
You can find more details about these updates in this blog post.

Rider 2024.3 EAP1 Is Here!
Support for hot reloading C++ with Live++
We've been working with the folks at Live++ to bring seamless C++ hot reloading support to Rider! There's no new UI, but the user experience should be a lot smoother.
Other features and improvements
- Ability to select the Code Cleanup profile for each file and to skip code cleanup from running on a file.
- New options to adjust C# naming rules more precisely.
- Built-in live templates to generate UE_LOG and UE_LOGFMT logging statements in Unreal Engine solutions.
You can find more details about these updates in this blog post.

Rider 2024.2 EAP 9 is out with:
More debugging performance improvements for Rider on macOS
We have fixed an issue that caused slow debugger performance on macOS. This fix improved performance in various scenarios, including exception handling, code evaluation, conditional breakpoints, and stepping, resulting in a smoother and more efficient debugging experience. Additionally, applications running under the debugger now execute more quickly, reducing overall testing and debugging time.
For the full list of fixes and changes included in this build, please see our issue tracker.

Rider 2024.2 EAP 8 is out
The .NET Aspire plugin bundled
The .NET 8 SDK introduced .NET Aspire – a new approach to tackling the complex issues around building distributed applications on the .NET stack. In response to this innovation, JetBrains introduced new integrated tooling – the .NET Aspire plugin for Rider.
Starting with this build, the .NET Aspire plugin is now bundled with Rider. The plugin comes with a corresponding project template that you can select when setting up a new solution.
For the full list of changes included in this build, please refer to our issue tracker.

Rider 2024.2 EAP 7 comes with:
Semantic highlighting for C#, C++
We've added support for optional semantic highlighting for C# and C++. This feature is designed to help you distinguish between different parameters and local variables in the code by color. You can enable or disable semantic highlighting in Settings/Preferences| Editor | Color Scheme | Language Defaults | Semantic Highlighting.
Navigation improvements
Target framework, project, and shader context selectors have been moved from breadcrumbs to the inspection widget.
We've also resolved the issue where Navigation bar members took up too much space [RIDER-114327].
Debugging performance on macOS
After much investigation and refactoring, we were able to improve the startup time of applications debugged in Rider on macOS by an average of 6 seconds. For more information and to share feedback on your experience, please see this issue.
Code With Me (CWM)
We've been working hard to bring you a better version of Code With Me (CWM) in the 2024.2 release of Rider. With the latest set of refinements now completed, we're at the stage where your feedback is crucial and will guide all our further refinement and development efforts.
This iteration we've made improvements to various aspects of the typing experience when using CWM. Enhancements include better code completion, more seamless code editing, improved syntax highlighting, refined live templates, and a more robust Undo functionality. You can find a more technical status update here.
Please take the time to test CWM and tell us about your experience.
Monitoring tool
The Monitoring tool window now displays information about managed heaps for .NET Framework applications [DPA-1954]. Please note that information about managed heaps and garbage collection in the Monitoring tool is only available with Dynamic Program Analysis (DPA) enabled.
This build also contains 2 bug-fixes pertaining to Monitoring: DPA-2036, DPA-1952.
CQRS validation
Rider now supports Command Query Responsibility Segregation (CQRS). CQRS helps in using different models for updating and reading information, improving code architecture and performance. The support includes inspections to identify CQRS violations, with highlighting and quick fixes available for many issues. You can enable SQRS analysis by looking up "CQRS validation" in Rider's Settings/Preferences.
For the full list of changes included in this build, please refer to our issue tracker.

Rider 2024.2 EAP 6 is out with:
Full line code completion for C#
Rider introduces support for a new type of code completion: gray text single-line suggestions that complete lines based on the context of the current file. These suggestions are powered by language models that run locally without sending any code over the internet. As of EAP 6, full line code completion is only available for C#, with C++, JS/TS, and CSS support to follow shortly.
Reworked navigation bar
The navigation bar in Rider has been reimagined. Now, the path from the project root to the file you're working on also features the symbol where the caret is currently positioned. Clicking on any symbol in the chain reveals a popup that displays neighboring symbols in the file. You can navigate to these neighboring symbols directly from the popup with a single click.
Improvements to debugging C++ projects
This build introduces a number of fixes and quality-of-life improvements:
More user-friendly error messages: Previously, debugging optimized code with LLDB in Rider would sometimes result in unclear internal error messages. These have now been replaced with more user-friendly messages, helping you understand issues more easily. (RIDER-67319)
Evaluation and visualization of partially available variables: Now, even if some variables are not fully accessible, the debugger can still provide useful information about them. (RIDER-94876).
Improved data breakpoint experience: The handling of data breakpoints in Rider has been significantly improved. Previously, many data breakpoints, especially those involving items generated by the Natvis visualization framework, did not work correctly and failed silently. This meant that users were not informed when a breakpoint did not function. Data breakpoints should now work more reliably, as any item with an address in memory can be added to a data breakpoint. Moreover, when a data breakpoint cannot be added (for instance, if a Natvis item expression lacks an address), Rider will inform the user about the error instead of failing silently. (RIDER-71394, RIDER-113879, RIDER-113875)
Notable fixes:
- Correct parsing of the dateTime and Timestamp database columns has been restored. (RIDER-114175)
- We've introduced the option to disable automatic adding of DDL data sources to the Database tool window to avoid overconsumption of resources and resulting IDE freezes. You can enable and disable the option by going to Settings/Preferences | Build, Execution, Deployment | SQL Projects. (RIDER-92646)
- VCS color hints in the tool window or popup structure for C++ once again work correctly. (RIDER-112441)
- Code Vision no longer flickers on startup. (RIDER-106697)
For the full list of improvements and fixes included in this build, please refer to our issue tracker.

Rider 2024.2 EAP 5 comes with the following updates:
- Reader Mode
- Extract Common Code refactoring for C#
- Sticky Lines for C++ accessibility specifiers
- Monitoring tool now supports C++, Unity, Unreal Engine, Mono, .NET Framework projects
dotTrace:
- Fixed missing kernel sampling events in Timeline mode.
dotMemory:
- Automatic snapshot analysis in the Inspections view.
- Cross-workspace snapshot comparison view.
AI Assistant:
- Explain with AI for Dynamic Program Analysis (DPA)
- Support for debugging GDScript in Godot
For more information, please check out this blog post.

Rider 2024.2 EAP 4 comes with the following updates:
- Reader mode
- Inline rendering of documentation comments
- Tasks view and a task dependency graph
For more information, please check out this blog post.

Rider 2024.2 EAP 3 comes with the following updates:
Plugins
- Bundled .NET Watch Run Configuration plugin
Unreal Engine
- Preprocessor directives in sticky lines
For more information, please check out this blog post.

The Rider 2024.2 Early Access Program has begun!
The first early preview build features:
- Better UI for the Usages of... popup.
- Support for project/solution template parameters with multiple choices.
- An enhanced user experience with the Log tool window.
- Recognition of implicitly used configs for tools and frameworks.
- Several other handy updates for web development.
- Improvements to debugging Unreal Engine games.
- Performance improvements for dotTrace.
- Improved object instance filtering for dotMemory.
- Numerous enhancements for the decompiler.
Notable fixes:
[CVE-2024-37051] Fixed a security vulnerability related to the JetBrains GitHub Plugin. For more details, please refer to the blog post.

For more information on the Early Access Program and the updates included in this build, check out this blog post.

Rider 2024.1 EAP 9 comes with the following updates:
AI
When renaming a local variable, you will get name suggestions powered by AI in the code completion popup.
Collection Visualizer
You can now pin the Collection View window to the code editor as a tab using the pin icon on the right side of the toolbar.
Debugger
There is a new option to configure Just-In-Time compilation to deoptimize methods on step into and methods with breakpoints, and recompile them to improve stepping and code evaluation while debugging external code. This option is enabled by default. It only works on .NET 8 and higher, and only on Windows because of limitations in .NET 8.
Publish
Publish to Folder now supports publishing MAUI apps for all target platforms: Android, iOS, macOS, and MacCatalyst.
Unreal Engine support
Automation scripts are supported when opening .uproject files.
Godot support
The gdUnit4Mono unit test framework is now supported.
Refactorings
We've made several improvements to the Make Static refactoring as described on the ReSharper page.
For the full list of changes included in this build, please refer to the issue tracker.

Rider 2024.1 EAP 8 comes with the following updates:
Code With Me
After much anticipation, preliminary Code With Me support has finally been added to Rider! To enable it, go to Tools | Enable Code With Me. Please share your feedback with us by commenting on the corresponding YouTrack issue!
Blazor support
You can now generate additional files like .razor.cs, .razor.css, .razor.js on generating a Blazor Component file template.
Refactorings
We’ve made several improvements to the Change Signature refactoring. For more details, refer to the ReSharper page.
Unity support
We’ve dropped the extended support for Unity versions predating 2019.2. This means Rider no longer offers features related to Unity Editor integration.
For the full list of changes included in this build, please refer to the issue tracker.

Rider 2024.1 EAP 7 brings:
- More suggestions to convert code to collection expressions
- New Collection was modified inspection
- Updates to Generate | Formatting Members
- Refreshed product icons
- New Explain with AI button to clarify exceptions and error messages
- The bundled Kubernetes plugin
For more information, check out this blog post.

Rider 2024.1 EAP 6 comes with the following updates:
- Updated New Project dialog.
- Blazor WASM Hot Reload for debugging.
- Enhanced support for disposable resources in async methods.
- Custom naming rules in Settings.
- Version Control Systems improvements.
For more information, check out this blog post.

Rider 2024.1 EAP 5 comes with the following updates:
- A collections visualizer for the debugger.
- Sticky lines in the editor.
- Enhanced GitHub Actions support.
- Support for the WebCIL packaging format for WebAssemblies in the Assembly Explorer.
- More ways to access and build type dependency diagrams.
Find out more in this blog post.

Rider 2024.1 EAP 4 comes with the following updates:
- New Monitoringtool window.
- Blazor WASM Hot Reload in Run mode.
- Assembly resolve for addTagHelper directives.
For more information, check out this blog post.

Rider 2024.1 EAP 3 is out, featuring:
- The option to show tool window names in the side toolbars
- The option to scale down the entire IDE
- Stepping time and inline breakpoints for debugging
For more information, check out this blog post.

Rider 2024.1 EAP 2 comes with the following updates:
Revamped Terminal
This build brings an overhauled Terminal that gains both visual and functional enhancements designed to elevate the convenience and simplicity of terminal-based tasks. This update both improves the tool visually and expands its feature set.
Support for .NET process dumps
When you're debugging, process dumps are crucial because they allow you to examine the program's state at the time of an error, even if the issue is not easily reproducible. Previously, Rider was only able to process C++ core dumps. Starting with this EAP 2 build, the IDE will also allow you to import dumps for .NET processes. To import a process dump, go to Run | Debug Core Dump or drag and drop the dump file into the editor.
Improvements to Godot support
- We've implemented highlighting for major Godot file types (.gd, .tscn, .tres, .godot), and improved highlighting for .gdshader. Click here for more information.
- The IDE now offers automatic runtime detection for Godot 4, including for launchSettings.json [https://github.com/JetBrains/godot-support/pull/125].
- There's now a Start Godot Editor button in the main toolbar, similar to the one we have for Unity [https://github.com/JetBrains/godot-support/pull/119].
Performance and memory profiling
The built-in dotTrace and dotMemory profilers now support MAUI and .NET macOS applications.
Supported target frameworks:
- MAUI Windows: net8.0-windows, net7.0-windows
- MAUI Mac: net8.0-maccatalyst, net7.0-maccatalyst
- macOS applications: net8.0-macos, net7.0-macos
Profiling MAUI applications with Rider on macOS is only possible in Run with Timeline and Attach with Timeline modes. Click here for more information on the profiling modes available.
For the full list of changes included in this build, please refer to the issue tracker.

The Rider 2024.1 Early Access Program begins!
This year's first EAP build features:
- New options for type dependency diagrams:
- Add a node using Search
- Add related types
- Remove nodes from a diagram
For more information, please check out this blog post.

Rider 2023.3 EAP 8 comes with the following updates:
As of this build, the IDE provides support for the following .NET 8 SDK functionalities:
- Updated project templates.
- The ability to create, run, and debug projects targeting the new SDK.
- Updated support for Roslyn Source Generators.
- New C# 12 features, including primary constructors, interceptors, and alias directives to reference any type.
- Support for F# 8 features, namely shorthand lambda expressions, nested record updates, static interface members, let bindings, and more.
- Support for @ variables.
- Support for Identity API endpoints.
Click here for the full list of .NET 8 updates and bug fixes we’ll be delivering over the next couple of weeks leading up to the 2023.3 release.
Additional updates in this EAP build include:
- The data flow analysis (DFA) mode in the debugger has been renamed and is now called the predictive debugger.
- We've made improvements to the experience of reviewing multiple iterations of analyzing a cycle with the predictive debugger. Cases where only one iteration is possible are now appropriately reflected in the UI [RIDER-89886].
- We've also fixed static variable evaluation in the debugger in case of different AssemblyLoadContext classes [RIDER-96018].
- Rider's ability to connect to MS SQL Server databases has now been restored.
Known issues
Hot Reload doesn't give warnings if changes could not be applied [RIDER-102058].
For the full list of changes included in this build, please refer to our issue tracker.