Rider Changelog

What's new in Rider 2024.1 Build 241.14494.14 EAP 8

Mar 7, 2024

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.

New in Rider 2024.1 Build 241.14024.36 EAP 7 (Mar 1, 2024)

New in Rider 2024.1 Build 241.12662.57 EAP 5 (Feb 16, 2024)

New in Rider 2024.1 Build 241.11761.31 EAP4 (Feb 10, 2024)

New in Rider 2024.1 Build 241.10840.28 EAP3 (Feb 3, 2024)

New in Rider 2024.1 Build 241.9959.26 EAP2 (Jan 27, 2024)

New in Rider 2023.3.3 Build 233.14015.60 (Jan 23, 2024)

New in Rider 2024.1 Build 241.8102.132 EAP1 (Jan 20, 2024)

New in Rider 2023.3 Build 233.11799.183 RC 1 (Nov 29, 2023)

New in Rider 2023.3 Build 233.11799.22 EAP 7 (Nov 15, 2023)

New in Rider 2023.2.3 Build: 232.10203.29 (Nov 4, 2023)

New in Rider 2023.3 Build 233.10527.19 EAP 4 (Oct 23, 2023)

User experience:
Running multiple projects:?
With Rider 2023.3 you can run and debug multiple projects simultaneously with advanced control over task execution order and conditions. The new Run Multiple Projects feature allows you to set up custom multi-launch configurations to ensure all of your solution’s dependencies are handled flawlessly.
To create a multi-run configuration, right-click on the solution or a selection of projects and choose Run Multiple Projects, then configure any additional parameters for the desired configuration.
Save as Solution Filter:
Rider 2023.3 will allow you to quickly and easily create solution filters (.slnf files). Using solution filters can help you tailor your IDE’s Project view to match the specific context you’re working in, making it easier to manage large, complex projects.
To create a solution filterr, right-click on your solution in the Solution Explorer and select Save as Solution Filter.
Solution structure
Type Dependency Diagrams:
Rider 2023.3 allows you to explore the relationships and dependencies between different classes, structs, interfaces, and modules in your solution through Type Dependency Diagrams. Studying type dependency diagrams can give you insight into how various types in the codebase interact with each other, making it easier to grasp your project’s design and bringing more clarity to debugging.
You can view a Type Dependency Diagram for any combination of projects, folders, and types inside them by right-clicking on that selection in the Solution Explorer and selecting Tools / Show Type Dependency Diagram.
Code completion for CPM:
.NET 7 introduced Central Package Management (CPM) to aid developers in streamlining the package management process associated with application development. In this EAP cycle, we’re introducing enhanced support for your CPM files with code completion features for NuGet package names and versions. These files now see the same support as in a .csproj file. These changes should help developers more quickly and accurately manage package references. See our blog post on Central Package Management for a clearer understanding of this relatively new feature.
Performance profiling:
This build introduces advanced options to the Timeline profiling mode when using Rider’s built-in dotTrace profiler. The new options are:
Sampling rate configurations
Sampling for native allocations
Parallel download of native symbol files, including the option to download them in the background
To edit the profiling configurations, go to Run | Switch Profiling Configuration | Edit Configurations, or click on the kebab menu in the main toolbar, then Profile with… | Edit configurations.
dotTrace now also supports System.Data.SqlClient for applications targeting the .NET and .NET Core frameworks.
Notable fixes:
Rider now allows adding a condition to a breakpoint on an expression-bodied property (RIDER-98095).
The IDE’s breakpoint editor now shows completion options for the current expression body method if there is a line break after => (RIDER-100363).

New in Rider 2023.3 Build 233.9802.20 EAP 3 (Oct 17, 2023)

New in Rider 2023.3 Build 233.9102.265 EAP 2 (Oct 10, 2023)

New in Rider 2023.2.2 Build 232.9921.83 (Sep 27, 2023)

New in Rider 2023.3 Build 233.6745.316 EAP 1 (Sep 27, 2023)

New in Rider 2023.2 Build 232.8660.212 (Aug 3, 2023)

A new major update for Rider has just been published! You can download the 2023.2 release build from our website, install it via the Toolbox App, or use this snap package from the Snapсraft store (if you are using a compatible Linux distribution).
We invite you to explore the new features and improvements in version 2023.2 of your favorite cross-platform .NET IDE.
C# updates:
Rider 2023.2 comes with the following improvements to its C# language support:
New inspections and context actions, improved typing assistance, and formatting options for working with raw string literals.
Inspections and quick-fixes for handling common Entity Framework issues.
Two new inspections and corresponding quick-fixes aimed at improving code readability when working with local functions.
Inspections for #nullable directives and NRT annotations.
Improved navigation from var declarations.
Primary constructor support for non-record classes and structs from the C# 12 preview.
Support for default parameter values in lambda expressions.
New code inspections designed for better control over object disposal.
Better C# discard support.
New inlay hints for improved code readability when working with tuple component names, null and default components, and deconstruction patterns.
Improved support for #pragma warning directives.
For full information on the C# updates, please visit the What’s New in Rider 2023.2 page.
You may also want to check out our EAP posts for the 2023.2 release for an in-depth look at the latest updates in code analysis.
UX/UI improvements:
Reworked Build tool window:
In Rider 2023.2, we’ve reworked the Build tool window, both in terms of performance and UX/UI. Build output results are now loaded in a “lazy” manner, meaning only the build details you choose to look into from the event tree will be loaded and displayed. This makes the output far more CPU-friendly and easier to navigate.
New UI becomes the default look:
The latest version of Rider makes the reimagined IDE interface first unveiled in version 2022.3 the default for all new users. The new UI is sleek, modern, and highly customizable.
If you haven’t made the switch yet, we encourage you to give it a try by going to Settings / Preferences | Appearance & Behavior | New UI | Enable new UI.
Customization and streamlining:
The new UI is designed to eliminate visual clutter and streamline your workflow. Several updates in the 2023.2 release advance these goals:
Customizable project headers:
You can now navigate between all of your open projects by color! Headers come with predefined colors by default, but you can change them according to your preferences. You can even set up a custom icon for your solution as a finishing touch!
Improved main toolbar customization:
We’ve expanded the customization options for the new UI’s main toolbar. You can now use a drop-down menu to quickly choose actions that you want to add to the toolbar. To do so, right-click on any widget, select Add to Main Toolbar, and explore the available options.
Pinned run configurations in the Run widget:
To make managing multiple run configurations easier, we’ve implemented the option to pin preferred configurations in the Run widget. To add a run configuration to the Pinned section, open the kebab menu (three dots) next to its name and select Pin.
Other notable UX/UI updates:
Reworked hamburger menu in the main toolbar on Windows and Linux.
Light theme with light headers.
Single-click navigation between project directories.
File sorting by modification time in the Solution Explorer.
Native Linux header removed in the new UI.
AI Assistant [Limited access]:
With this release, we introduce a major addition to Rider – AI Assistant. The initial set of AI-powered features offers an integrated AI chat and weaves naturally into some of the IDE’s core user workflows. AI Assistant can analyze selected code, explain the meaning of a commit or a runtime error, generate documentation, and create Unity files written to your specifications.
Access to the AI capabilities is limited for now and requires you to install the plugin and log in to the JetBrains AI service. For more information, refer to this blog post.
Version control:
GitLab integration:
Rider 2023.2 introduces initial integration with GitLab, allowing you to work with the Merge Request functionality right from the IDE and streamline your development workflow.
Background commit checks:
We’ve reworked the behavior of commit checks for Git and Mercurial to speed up the overall commit process. Checks are now performed in the background after you commit but before you push.
Option to commit specific lines of code:
Rider 2023.2 introduces a highly anticipated feature that allows you to selectively commit specific parts of code chunks. To perform a partial commit, select the lines within a chunk and call Include these lines into commit from the context menu.
Performance:
With Rider 2023.2, we’ve revised our approach to caching the data required by the IDE to make its systems work. This revision, supported by myriad performance tests, resulted in a noticeable reduction in disk space consumption for each solution you open. In practical terms, it means less time spent doing disk input/output and faster loading times for solutions.
Game development:
Unity:
This is another release loaded with features for Unity development, with lots of improvements to the experience of editing ShaderLab files, additional updates to DOTS functionality, and better support for USS files.
Here are some key updates:
The new AI Assistant is aware of your development environment, providing Unity-specific responses and making relevant Unity API suggestions. AI Assistant can also generate a file written to your specifications for a Unity solution.
Improved ShaderLab support, including new typing assistance, live templates, improvements to viewing the file structure through breadcrumbs and the Structure tool window, and Ctrl+Click navigation to the name declaration of a shader or pass. Learn more from this blog post.
Support for Unity DOTS continues to expand. We’ve made some useful improvements to code generation for the Data-Oriented Tech Stack (DOTS) based on some great feedback from the Unity community. We’ve also introduced new file and live templates, in addition to extending Burst context analysis to more parts of your code.
Unreal Engine:
Rider 2023.2 is another great update for Unreal Engine support, with lots of updates to C++ as well as the introduction of support for Hot Reload and Live Coding, performance improvements for Blueprint indexing, and fixes and updates for Perforce support.
Some highlights:
This release features improved Blueprints indexing. By classifying Blueprints as secondary resources, Rider can now index all of your code before looking at your assets. This means you get access to the rich code editing experience sooner, while the assets are still being indexed in the background.
Rider now supports invoking Hot Reload and Live Coding from the IDE, allowing you to update your Unreal application while the editor is running.
We’ve improved the integration with Perforce, notably decreasing the time it takes to refresh the status of local files, among other fixes and updates.
.NET SDK:
Rider 2023.2 introduces a host of improvements for working with Roslyn analyzers and Source Generators, including the introduction of new project templates for them and a Reboot Source Generators button.
Docker support has been bolstered with the option to run Docker in fast mode, Docker Compose run configuration labels, and the ability to view the Docker log in the Console tab when debugging Docker containers.
Last but not least, Hot Reload is finally available for solutions targeting .NET MAUI!
Other release highlights:
The Find Usages functionality has received a functional upgrade in Rider 2023.2. Now, if you invoke Find Usages Advanced on a symbol (such as a method, class, or variable), the IDE will display a window where you can specify additional search criteria.
In Rider 2023.2, you can collect and analyze memory snapshots inside the IDE just as you can in the standalone version of the dotMemory profiler.
The Call Tree view now lets you group call stacks by individual threads, providing deeper insight into thread-specific performance issues.
Rider 2023.2 integrates the Qodana code quality platform. Learn how you can elevate the quality of your C# code with Qodana in this blog post. You can find more general information about Qodana here.
Rider’s F# support has received a number of exciting updates, starting with F# to C# in-memory references. Learn about all of the F# updates here.
Rider 2023.2 comes with support for the LSP API for plugin developers. Here’s a blog post about it from the IntelliJ IDEA team.
Rider 2023.2 introduces the Feature Trainer, a new interactive tool designed to help both new and experienced users familiarize themselves with the extensive features and workflows offered by the IDE.
For more information about all these features and tons of others, visit the What’s New in Rider 2023.2 page. You can also review the full list of requests we’ve addressed this release cycle in our public bug tracker.

New in Rider 2023.2 Build 232.8660.134 EAP 10 (Jul 22, 2023)

New in Rider 2023.2 Build 232.8660.29 EAP 8 (Jul 10, 2023)

New in Rider 2023.2 Build 232.8453.124 EAP 7 (Jul 3, 2023)

New in Rider 2023.2 Build 232.8296.16 EAP 6 (Jun 26, 2023)

New in Rider 2023.2 Build 232.7754.74 EAP 5 (Jun 16, 2023)

New in Rider 2023.2 Build 232.7295.15 EAP4 (Jun 9, 2023)

New in Rider 2023.2 Build 232.6734.14 EAP3 (Jun 6, 2023)

New in Rider 2023.2 Build 232.6095.13 EAP2 (May 22, 2023)

New in Rider 2023.1.2 Build 231.9011.39 (May 17, 2023)

New in Rider 2023.2 Build 232.5150.114 EAP1 (May 15, 2023)

New in Rider 2023.1.1 Build 231.8770.54 (Apr 30, 2023)

New in Rider 2023.1 Build 231.8109.212 (Apr 5, 2023)

New in Rider 2023.1 Build 231.8109.192 EAP 10 (Mar 30, 2023)

New in Rider 2023.1 Build 231.8109.136 EAP 9 (Mar 24, 2023)

New in Rider 2022.3.3 Build 223.8836.53 (Mar 23, 2023)

New in Rider 2023.1 Build 231.8109.48 EAP 8 (Mar 10, 2023)

C# support:
Insert a return type specification for lambdas:
Lambda expressions in C# usually have implicitly-typed parameters and an inferred return type. Sometimes, it can be useful to add explicit types in a signature of a lambda expression to make code clearer or to help C# type inference in some complex scenarios involving overload resolution. A context action to insert parameter types, Insert parameter signature, has been around for a while.
Syntax style for null checking patterns:
We provided the new “Syntax style” setting to help you enforce one consistent style of not null checks inside patterns. It consists of 2 options: empty recursive pattern syntax { } and negated pattern not null, where the latter is set by default. You can adjust this behavior by going to Settings/Preferences | Editor | Code Style | C# | Syntax Style tab.
ArgumentNullException.ThrowIfNull style of null checks:
.NET 6.0 SDK introduced a new API for null checking – ArgumentNullException.ThrowIfNull. Our code analysis engine has recognized this checking approach since then, but there was no option to use this API as a default style of null checks produced in Rider. In the 2023.1 release, we added an ArgumentNullException.ThrowIfNull pattern to Settings/Preferences | Editor | Code Style | C# | Null checking for Rider.
Editor:
Option to specify the placement of pasted content:
In Rider 2023.1, there’s now a special setting that allows you to control the placement of pasted content. In Settings/Preferences | Advanced Settings, find the Editor section and select the desired behavior for the Paste action from the drop-down list.
Text filters for unit test trees:
Text search filters inside the Unit Tests and Unit Test Coverage tool windows are now taken into account when running tests using the toolbar’s Run buttons. Only the tests that satisfy the search criteria will remain listed and run.
F# support:
There’s a new quick-fix that generates missing pattern branches in a match expression.
Fixes:
We’ve solved an issue where Rider was not showing usages of the Script method in Animator controllers in the Code Vision view
We’ve fixed a bug interfering with Rider’s ability to save files or sync scripts with Unity when the user switches to a different application
We’ve restored Rider’s ability to display XML docs in the Quick Documentation pop-up window in Unity projects
We’ve fixed an issue with Run to Cursor not working when debugging Blazor web applications
We’ve resolved the issue of Unity meta files being corrupted whenever the user reverts using LocalHistory

New in Rider 2023.1 Build 231.7864.80 EAP 7 (Mar 6, 2023)

New in Rider 2023.1 Build 231.7665.34 EAP 6 (Feb 24, 2023)

New in Rider 2023.1 Build 231.7515.11 EAP 5 (Feb 17, 2023)

Database Schema Compare:
Schema Compare is an essential tool for database development and maintenance. It lets users compare two databases to quickly identify the differences between them, ensure there are no discrepancies, and keep the data up to date.
This EAP build introduces Schema Compare for connected databases, SQL Server database projects, and .dacpac files. To initiate the comparison, right-click on the database project file in the Solution Explorer and choose Schema Compare….
We’ve created a dedicated editor window where you can view and edit Schema Compare (.scmp) files. Additionally, the Problems View window will now include the issues identified as a result of database comparison as well as the ones spotted by database model validation.
Debugger:
Visualizers for string variables:
You can now hover over a variable during a debugging session and its value will be visualized for HTML, XML, JSON, JWT, or an URL-encoding formatter.
Reattach to Process action:
You can now easily reattach Rider’s debugger to the last process it was attached to by simply going to Run | Reattach to Process… in the main menu. The new action becomes active after the first debugging session.
Code cleanup:
Reformat inactive preprocessor branches in file is a new task type inside the Built in - Reformat code profile we’re introducing in Rider 2023.1. The task enables you to reformat inactive preprocessor branches. It can only be applied to the entire file at once and works only with C# sources.
This task cannot reformat code hidden behind a preprocessor directive #if that is always false. The two most obvious examples of this limitation are #if false ... #endif and #define A #if !A ... #endif constructs.
Rename refactoring :
We have improved the way Rider handles renaming files in a project. From this build on, whenever you rename a file inside your solution, a dialog will appear with the option to rename all relevant symbols (classes, interfaces, etc.) to match the change.
Game development:
Unreal Engine:
If a Blueprint file fails to be parsed by Rider, Rider will now display the parsing errors in a separate Blueprints tab in the Problems View window. This allows you to locate the problematic file in the Solution Explorer window. Each problem contains a short description of the kind of error that was detected.
Unity:
Rider will now use localized documentation when showing tooltips for Unity APIs and online help.
We’ve also improved support for finding usages of C# code in Unity animations and showing animation event handlers as unused.
Unit testing:
We’ve introduced a Trigger Continuous Testing action, as well as the option to set up a shortcut for it. The action makes it possible to trigger continuous testing directly, whereas previously, you could only do this indirectly by building or saving your project.
To assign a shortcut to this action, go to Preferences/Settings | Build, Execution, Deployment | Unit Testing | Continuous Testing, select Trigger Continuous Testing on…, and set up a shortcut of your choice.
Notable fixes:
Erroneous Code Cleanup on Save:
We’ve fixed a behavior causing Rider to reformat all C++ files within a .uproject solution whenever changes were made to a build.cs file that Code Cleanup on Save was enabled for.
Screen flickering on macOS Ventura :
We’ve identified and fixed the root cause for Rider’s screen flickering that occurred after an OS update to macOS Ventura.

New in Rider 2023.1 Build 231.6890.15 EAP 4 (Feb 13, 2023)

Full IDE zoom:
It’s now possible to zoom into and out of Rider, increasing or decreasing the size of all UI elements at once. From the main menu, select View | Appearance and adjust the IDE’s scaling.
Debugging WASM startup code:
Rider can now debug startup code for WebAssembly (WASM) .NET applications. Previously, the WASM debugger could only attach after app initialization was done for most projects, because it required some time to perform port calculation, connection initialization, etc. The delay made it impossible to debug startup-time code.
Now, Rider waits for the page target initialization, connects the debugger, and only then does it start the actual app loading. That makes it possible to catch breakpoints set at the early stages of the app’s initialization logic.
Web development:
Astro support:
Initial Astro support has landed, with a new plugin available to use in Rider. You can download the Astro plugin from JetBrains Marketplace, or install it directly from the IDE by going to Preferences / Settings | Plugins and searching for “Astro”.
The plugin provides basic functionality such as syntax highlighting, code completion with automatic imports, refactorings, navigation, intentions, code folding, Emmet support, and correct formatting. Please test it out and report any problems you find to our issue tracker. We are planning on adding more advanced Astro support in the future.
Angular:
We’ve added a new feature for Angular. Now, when you’re working with global and exported symbols in the Angular template, Rider will automatically add an import for them into your component on code completion or when you use a quick-fix.
Support for TypeScript in Vue template expressions:
Rider 2023.1 EAP 4 includes support for TypeScript in Vue template expressions. The Vue template expressions now sync with lang=”ts” when added to script tags. As a result, Rider can better evaluate TypeScript, providing preferences and relevant refactorings matching what’s inside the script tag. You may have noticed before that there were differences between settings and refactorings for pure .js and .ts files. Now the lang attributes will match.

New in Rider 2023.1 Build 231.6471.8 EAP 3 (Feb 3, 2023)

New in Rider 2023.1 Build 231.5920.16 EAP 2 (Jan 31, 2023)

New in Rider 2022.3.2 Build 223.8617.53 (Jan 27, 2023)

New in Rider 2023.1 Build 231.4840.377 EAP 1 (Jan 19, 2023)

New in Rider 2022.3.1 Build 2022-12-21 (Dec 22, 2022)

New in Rider 2022.3 Build 223.7571.128 EAP 9 (Nov 26, 2022)

New in Rider 2022.3 Build 223.7571.24 EAP 8 (Nov 14, 2022)

New in Rider 2022.2.4 Build 222.4459.9 (Nov 9, 2022)

New in Rider 2022.3 Build 223.6646.116 EAP 4 (Oct 17, 2022)

New in Rider 2022.3 Build 223.6160.184 EAP 3 (Oct 10, 2022)

New in Rider 2022.3 Build 223.6160.92 EAP 2 (Oct 7, 2022)

New UI:
We invite you to switch to the new UI for IntelliJ-based IDEs in Settings | Appearance & Behavior | New UI Preview. The new UI is an ongoing effort to reduce the visual complexity of the IDE and help you focus on your work. Give it a test drive and be sure to send us your feedback!
User Experience:
We have fine-tuned the algorithm behind the Search Everywhere result list to make its behavior more predictable and its ability to select the elements you’re searching for more accurate. Now, when you start typing your query, the IDE freezes the first search results that appear and doesn’t re-sort them when more options are found (as was the case with earlier versions).
The highly requested option to dock tool windows to floating editor tabs is finally here! To make it more convenient to arrange your working space and interact with Rider on multiple monitors, we’ve implemented the option to drag tool windows out of the main window and dock them to floating editor tabs.
Last but not least, we’ve added an action for switching between solutions within the solution explorer. Right-clicking on a solution other than the one you are working on will now trigger a context menu, where you can select “Open” to simultaneously close the active solution.
Memory Profiling:
Our built-in memory profiling tool, dotMemory, is now available in Rider on Linux and macOS, in addition to Windows.
C# 11 support:
We’re continuing to expand our support for the latest C# language features with the basic implementation of file-local types and UTF-8 literals.
C++ support:
We’ve implemented the option to run a clang-format binary directly instead of using Rider’s formatter engine, ensuring full compatibility with the industry-standard formatter, as well as better performance and a more extensive range of formatting options. You can toggle between the bundled and external clang-format options by going to Settings | Editor | Code Style | C++ and selecting the Clang-format option.
Unreal Engine:
Rider’s Generate GUID tool now supports GUID strings in the Unreal Engine format.
Unit testing:
We’ve made the unit test explorer tree “lazy” so that it will be faster and less taxing on memory. Previously, all nodes would be created automatically along with the unit test tree, causing it to lag when explored and consuming too much memory. Now, only the nodes belonging to the expanded parts of the tree will be created, giving you noticeably improved performance.
Debugger:
The debugger’s performance with the Allow property evaluations and other function calls option disabled has been drastically improved. We are now able to evaluate a lot more expressions in no-side-effects mode for .NET, .NET Framework, and .NET Core projects.
MAUI support:
Starting with this EAP build, you’ll be able to run and debug WinUI 3 projects.
Internet Information Services (IIS):
In response to a popular request from our community, we’ve added a new IIS Application run configuration for running and debugging classic ASP.NET applications on an IIS Server. We’re also introducing support for the IIS command name from the launchSettings.json file for ASP.NET Core applications.
Dynamic Program Analysis:
We’ve added a number of inspections for applications with SQL database access. These inspections help you to address various issues related to database usage, namely:
Long command execution times.
Too many database connections.
Too many simultaneously executed database commands.
Commands returning too many records.
The new inspections are available for all applications that use Entity Framework Core and .NET Data Provider for SQL Server.
Fixes:
Unreal Engine:
In response to a popular request, we’ve removed shader items from auto-import completion for Unreal Engine projects (RSCPP-33277).
We’ve corrected the way Rider handles and processes UE5 build outputs on Linux (RIDER-80067).

New in Rider 2022.3 Build 223.4884.77 EAP 1 (Sep 26, 2022)

Startup performance improvements:
Everyone likes to get news about performance improvements in their favorite tools, and today, that’s just what we have for you. We’ve made several changes to increase Rider’s startup speed and reduce the time it takes to open a solution:
Rider can now load a solution file and build its project tree instantly without having to wait for the backend to initialize (RIDER-78148).
We’ve enabled parallel loading for the projects in solutions (RIDER-78090, RIDER-71728, RIDER-78089).
We’ve removed all loading states from the solution explorer to achieve a cleaner UI. From now on, all these loading progress bars will be rendered in the IDE Status bar.
C# support:
This build brings a number of language injection improvements:
We’ve added support for language injections using the [StringSyntax] (from .NET 7) and [LanguageInjection] (from JetBrains.Annotations) attributes, as well as support for the // lang=<language_name> language injections instruction comment.
Language injections are now possible in interpolated strings and string concatenations for any language, whereas before it was only available for SQL. Please note that syntax errors are suppressed when string interpolation or concatenation with arbitrary expressions are used. Language injections inside C# 11 raw strings are also supported.
An indent guide separating the indentation from the actual value is now displayed on raw strings.
In addition to these improvements for language injections, we’ve also implemented suggestions encouraging you to use C# 11’s unsigned right shift (>>>) operator (RSRP-489309) and to use pattern matching instead of Span.SequenceEqual("literal") (RSRP-489310).
NuGet support:
Working with NuGet is an essential part of any .NET project. In this EAP build, we’ve implemented the highly requested support for NuGet Central Package Management (also known as the Directory.Packages.props file) for all NuGet operations (RIDER-41805).
We’ve also improved the scrolling experience inside the Packages list in the NuGet tool window (RIDER-46958).
Hot Reload for Blazor:
As you may already know from the roadmap, the team is working hard to support the .NET6 Hot Reload feature for Blazor. This build introduces Hot Reload for Blazor Server Apps. You can find more information about this new support in this issue, and you can check out this article to learn more about what Hot Reload in Rider can do for you. And keep an eye on these EAP posts for updates about Hot Reload for Blazor WebAssembly apps.
Unreal Engine support:
Rider is a powerful companion for creating games on Unreal Engine. During this release cycle we plan to polish and enhance many existing features. Let’s see what you can already try out in this EAP build.
Rename with CoreRedirects:
Rider already provides the option to add CoreRedirects when renaming Unreal classes or properties via the Rename refactoring. This now also works for:
Renaming UFUNCTION()
Renaming USTRUCT()
Renaming UENUM
When you perform the Rename refactoring, Rider now suggests adding CoreRedirects in these cases:
If you agree, then the corresponding .ini file is updated automatically:
It is now much harder to break your game accidentally by renaming things!
Enhanced support for the .uproject project model:
For Unreal Engine-based projects, Rider works with both .sln and .uproject projects. We are continuing to enhance the support for the native .uproject model to make it more accurate and comfortable to work with:
Rider 2022.3 EAP respects additional source locations, specifically AdditionalRootDirectories and AdditionalPluginDirectories specified in .uproject.
It also supports custom programs placed in the game location and generates all the programs’ project files correctly (RIDER-80061).
Rider now supports modules with several .Build.cs files for platform-specific modules (RIDER-75387, RIDER-79769).
Completion and inspections in .uplugin and .uproject files are now supported when using the .uproject project model.
Other improvements:
The auto-import on completion feature can save you tons of time. But if adds an incorrect #include directive, the problem may be tricky to detect. That’s why we’ve worked hard to polish it and make sure it doesn’t suggest unwanted entities from system headers in auto-import (RSCPP-31618). By default, system headers are not suggested, but if you want them to be, you can enable them in Settings/Preferences | Languages & Frameworks | C++ | Unreal Engine:
Finally, the log presentation in the UnrealBuildTool tool window has been improved (RIDER-78257).
IL Viewer:
Rider’s IL Viewer tool window is now able to decompile code into different levels of C# language constructs. There are two C# levels available: high-level, with certain syntax constructs simplified using the latest language features, and low-level, for cases when you want to know how these syntax constructs are desugared.
UI/UX :
We are continuing to implement small optimizations for Rider’s UI to make it more relevant and useful:
We’ve cleaned up the Add menu so it only presents relevant items for the current solution or project.
The Open in Terminal action is now in the Solution Explorer context menu.
The File | New at the top menu has been renamed File | New Solution to better reflect the actual action it will execute.
Miscellaneous:
The .NET User Secrets action has been added for ASP.NET projects (RIDER-11406).
Rider will now show Roslyn Analyzer ID and URL Reference in a Quick Documentation tooltip for inspections produced by Roslyn Analyzers (RIDER-52119).

New in Rider 2022.2.1 Build 222.3739.37 (Aug 10, 2022)

New in Rider 2022.2 Build 222.3345.44 EAP 9 (Jul 14, 2022)

New in Rider 2022.2 Build 222.3345.9 EAP 8 (Jul 7, 2022)

New in Rider 2022.2 Build 222.3244.17 EAP 7 (Jul 5, 2022)

New in Rider 2022.2 Build 222.3048.11 EAP 5 (Jun 17, 2022)

New in Rider 2022.2 Build 222.2964.37 EAP 4 (Jun 10, 2022)

New in Rider 2022.1.2 Build 221.5787.36 (Jun 4, 2022)

New in Rider 2022.2 Build 222.2680.9 EAP 2 (Jun 1, 2022)

New in Rider 2022.2 Build 222.2270.26 EAP 1 (May 20, 2022)

.NET 6 runtime for the backend on Windows:
We’ve finally migrated the Rider backend to the .NET 6 runtime on Windows! Rider now uses the .NET 6 runtime to run the backend service on all supported operating systems: Windows, macOS, and Linux.
In light of this change, we’ve also replaced NGen with the CrossGen utility to create native images on Windows after installing Rider because it works with the .NET runtime and is cross-platform.
UI/UX:
Resizable Run/Debug widget
In response to your feedback, we’ve made it possible to change the width of the Run/Debug widget on the main toolbar. If there is space available on the toolbar to extend the Run/Debug widget, you can drag the left corner and resize it. Now you can create more space for the widget when you want or need it.
Hiding the Solution Configuration list on the toolbar:
To reduce clutter on the main toolbar, we’ve moved the solution configuration list to the build icon’s dropdown menu (green hammer). From the feedback and statistics we collected, we determined that users don’t change their solution configurations often enough to justify keeping a separate widget on the toolbar at all times. However, if ever you need the configurations, they are still available with one click on the triangle next to the green hummer icon. This opens the same list that you are used to.
C# 11:
We’ve added support for one more C# 11 feature – checked user-defined operators. This helps developers create user-defined operators that operate on types where arithmetic overflow is a valid concept. Rider shows all compiler errors and warnings:
CS9023: User-defined operator ‘+’/’!’/’~’ cannot be declared checked.
CS9024: An ‘implicit’ user-defined conversion operator cannot be declared checked.
CS9025: The operator ‘…’ requires a matching non-checked version of the operator to also be defined.
Better support for solution filters:
Rider 2022.2 EAP1 makes working with filtered solutions much easier. You can now filter a project, a set of projects, a solution folder, or even all projects out of the result solution. Use the Solution Filter | Remove project action in the context menu on a project, a solution folder, or the root solution node in the Solution Explorer view. To show the projects that were filtered out, enable “Show All Files” mode in the Solution Explorer view and use the Solution Filter | Add Project action in the context menu.
Early preview of MAUI support:
We’ve introduced an early preview of our .NET Multi-platform App UI (.NET MAUI) support. In this build we support only projects that target the Android and iOS platforms. You can use run configurations to run and debug your project, as well as to deploy your application to a target device. We would appreciate any feedback you have about this feature.
Unreal Engine support:
We are continuing to improve our Unreal Engine support:
Rider now supports Spec tests from the Unreal Engine automation testing framework. If you have a set of tests defined in the Define method after the DEFINE_SPEC macro or the BEGIN_DEFINE_SPEC / END_DEFINE_SPEC macros, Rider will successfully discover them, so you can run and observe them in the Unit Tests view.
Assembly Explorer:
The way ReadyToRun (R2R) and NGen assemblies are presented in the Assembly Explorer has been improved. A small processor symbol icon and ngen or R2R labels are now displayed next to each assembly’s name.
The Metadata tree has the ReadyToRun header.

New in Rider 2022.1.1 Build 221.5591.20 (Apr 30, 2022)

New in Rider 2022.1 Build 221.5080.72 EAP 8 (Mar 29, 2022)

New in Rider 2022.1 Build 221.4994.45 EAP 6 (Mar 15, 2022)

New in Rider 2022.1 build 221.3427.104 EAP 1 (Feb 2, 2022)

New in Rider 2021.3.3 Build 213.6775.4 (Jan 31, 2022)

New in Rider 2021.3.2 Build 213.6461.51 (Dec 24, 2021)

New in Rider 2021.3 Build 213.5744.293 (Dec 8, 2021)

Support for .NET 6, including Hot Reload:
Now you can enjoy official support for .NET 6 SDK in Rider. It includes project templates, the latest target frameworks, the latest NuGet API, Blazor WebAssembly debugging, creating/running/debugging projects targeting the new SDK, ASP.NET scaffolding for .NET 6 projects, and Hot Reload. In our previous blog posts, we covered how you can work with Hot Reload in Rider if you are targeting .NET 6 and how it actually works.
Redesigned main toolbar with a new Run/Debug widget:
We’ve completely redesigned the main toolbar. The old main toolbar had problems that we wanted to eliminate:
There were too many icons, most of which were hardly ever used.
The VCS and the navigation functionality were not discoverable.
It was not possible to control multiple run configurations.
With the new design, we’ve tried to give our users a cleaner, more functional toolbar. It includes a new Run/Debug widget, navigation buttons, a VCS widget, a large Search Everywhere field, a Solution Configuration widget for managing solution-related configurations, and more. You can learn about the revamped main toolbar and how to use its features in this blog post.
Note: if you had Rider installed before this release, you won’t see the new toolbar by default, as we didn’t want to disrupt your user experience. You can give the new toolbar a try by enabling it under View | Appearance | Toolbar.
Updated debugging experience:
A new UI has come to the Debug tool window! Now it has three tabs: Threads & Variables, Console, and Debug Output. We removed the toolbar on the left and transferred the icons to either the top toolbar or the context menu.
We also have good news for UWP developers: you can now start your UWP project with the debugger attached. You no longer need to run the project first and then manually attach the debugger to the running process.
Another big update is that you can now debug both .NET (Core) and .NET Framework apps in local Windows Docker containers.
New Problems View tool window:
We’ve introduced the Problems View tool window (the Problems tab in the Rider UI) to give you an easy way to see warnings and errors for the current file, or whole solution, and problems with missing tooling and broken environment configurations.
The tool window has three tabs:
Current file – all of the errors, warnings, suggestions, and hints that Rider code analysis found in the file you are currently working on
Toolset, Environment – all of the diagnostics and messages related to the solution load activities, NuGet restore processes, and so on
All Solution Files – all the errors that Solution Wide Error Analysis found in the whole solution.
Updates to code analysis:
More C# 10 features:
Rider continues to add more C# 10 features. In this release, we’ve added support for file-scoped namespaces, global usings, the CallerArgumentExpression attribute, the “interpolated string handlers” concept, and C# 10 lambdas. You can learn how Rider can make it easy to adopt them in your codebase in our series about the new C# 10 features.
Nullable reference types:
Rider has two new quick-fixes, Replace with JetBrains.Annotations attributes and Remove nullable annotations without ‘#nullable’ context. These help you get rid of NRT syntax when you copy code samples from other resources but don’t have NRT enabled in your solution. There are also new quick-fixes for mismatches between type arguments and their nullability constraints, as well as for correcting annotations on parameters with nullable default values in a file, project, or whole solution.
Improved support for SQL language injections:
We now support many common cases where you write SQL code right inside of C# code. For instance, SQL query strings are correctly resolved for string.Format methods, string interpolations, and simple string concatenations.
Updates for Unity:
This release brings major updates to Rider’s support for Assembly Definition Files:
You can use Ctrl+Click to navigate to a reference; find usages of assembly definitions across the whole project, even in referenced packages; rename assembly definitions; and get completion when adding new references.
Rider will work with GUID based references, displaying a helpful hint with the target assembly definition’s name and Alt+Enter actions to convert between named and GUID-based references.
Rider will now highlight unmet “define constraints” in Assembly Definition Files. This makes it easy to see why an assembly has been excluded.
Setting up version defines has also gotten easier, with completion for package names and an inlay hint for the currently installed version.
Other highlights include:
Support for Apple silicon processors: no more x64 to ARM64 translation! Rider is now much faster on Apple chips.
Xamarin: in the Plist editor, we’ve implemented support for standard Xcode schemes. They help Rider provide understandable names for keys, value validation according to key type, and a list of possible keys when you add a new one to the Plist. These work on both macOS and Windows.
The XAML Preview now works for applications that target the .NET 6, .NET 5, and .NET Core 3.x SDKs. You can preview the results of any change you make in XAML code directly in Rider.
Rider can generate Binding Redirects for NuGet packages in .NET Framework projects. If Binding Redirects are needed in your project, Rider will add them to the App.config or Web.config file.
Rider now officially supports F# 6. There are powerful updates for the Introduce Variable refactoring, and using F# functions recursively is now easier, as you don’t have to go back and manually add rec to the containing function.
We’ve introduced the Reformat and Cleanup on Save setting. This feature allows you to reformat and tidy up whenever you explicitly invoke Save or Save All in the IDE. We hope it helps you keep your code nice and neat and saves you the trouble doing it manually.
We’ve introduced the new Bookmarks tool window that will replace a similar instance – Favorites.

New in Rider 2021.3 Build 213.5744.263 EAP 10 Beta (Dec 1, 2021)

New in Rider 2021.3 Build 213.5744.78 EAP 8 (Nov 17, 2021)

New in Rider 2021.3 EAP 7 Build 213.5455.4 (Nov 8, 2021)

New in Rider 2021.3 EAP 4 Build 213.4928.4 (Oct 14, 2021)

New in Rider 2021.2.2 Build 212.5284.64 (Oct 13, 2021)

New in Rider 2021.3 EAP 1 Build 213.3714.460 (Sep 28, 2021)

.NET 6 SDK Support
Starting from this EAP, Rider officially provides initial support for .NET 6 SDK, including project templates, target frameworks, and creating/running/debugging projects targeted to the new SDK. If you experience any issues, please let us know. Please note that the Hot Reload feature and Blazor Debugging for .NET 6 are not supported yet.
New UI for the Debug tab
A new UI is coming to the Debug tab! We have lots of changes to talk about.
By default, there are three tabs: Threads & Variables, Console, and Debug Output. Other tabs like Memory and Parallel Stacks are hidden, but you can show them via the Options Menu (the nut icon).
We completely removed the left toolbar and moved icons to the top toolbar or the context menu. To keep the top toolbar as short as possible, we reordered the icon set and left only the most important actions visible. The rest of the icons were moved to the More dropdown menu (three vertical dots icon). Hide Frames from Libraries icon and Hide/Show Threads toggle have been moved to the context menu in the Threads view.
The More dropdown menu has a new Settings submenu. Here, you can find a shortlist of the most common settings related to the debugger without having to go to the Settings/Preferences dialog and drill down into the Build, Execution, Deployment | Debugger page.
The Immediate Window has several updates too:
Add Watch has been moved from the Variables view to the toolbar of the Immediate Window.
There are two layouts: maximized and minimized. In the minimized layout, you can see the execution result only in the $result variable in the Variables view. In the maximized layout, in addition to the $result variable, you can see the history of the previously executed lines with the results of the executions. You can toggle between them using the Expand/Collapse icon.
A new option, Stop on Breakpoints, is available. It forces the evaluating process to stop on the breakpoints while evaluating an expression. Disabling the option will allow the evaluating process to ignore the breakpoints.
The Add Watch action now has a shortcut, Ctrl+Shift+Enter.
Debugger Updates
The debugger itself received a couple of long-awaited and highly-requested features.
First of all, there is good news for UWP developers: you can start your UWP project under the debugger right away. You no longer need to run the project first and then manually attach the debugger to the running process.
Secondly, you can now debug both .NET (Core) and .NET Framework apps in local Windows Docker containers. Previously, the debugger could work only with .NET Core apps in Linux Docker containers.
Language Support
C# 10
The C# 10 is around the corner, and Rider continues adding some of the upcoming features. Today, we are happy to add support for file-scoped namespaces and global usings.
Let’s start with file-scoped namespaces. In addition to supporting the new syntax itself, we’ve added a new Syntax style option (Settings/Preferences | Editor | Code Style | C# | Syntax Style | Code body | Namespaces) which helps you select the desired style. When you choose the style, Rider will show you inspections for code that has to be changed to follow the style and suggest the appropriate quick fix for you. You can propagate the fix through the project or even through the whole solution in one click.
If you want to return to the previous Syntax style for the code, there are two context actions: “Convert to file-scoped namespace” and “Convert to block-scoped namespace.”
Now, let’s take a quick look at global usings. Rider code analysis is aware of usings marked with the global keyword and uses these usings to correctly resolve symbols in all the code files in the project. If Solution Wide Error Analysis is ON, Rider will highlight global usings which have no usages in the project as unused with a proper quick-fix suggestion to remove the statement. Rider will also notify you if the global using has been placed in the wrong place in the file.
Code Analysis
It is not unusual for people to copy pieces of code from other resources, like stackoverflow.com. Nowadays, with nullable reference types is available in C#, some of the code samples already include the NRT syntax. But what if you don’t have NRT enabled in your solution? To help you get rid of this syntax after pasting such code to your project, Rider has two new quick-fixes: Replace with JetBrains.Annotations attributes and Remove nullable annotations without ‘#nullable’ context.
We’ve added a couple of new quick-fixes and a context action for static local/anonymous functions with closures:
A quick-fix, Allow closures, to remove static modifiers from a local or an anonymous function if it contains closures.
A quick-fix, Pass closure as a parameter, to lift closures in static local functions to parameters.
A context action, Pass closure as a parameter, to lift closures in non-static local functions to parameters.
There is a new inspection, Simplify string interpolation, with a corresponding quick-fix to replace .PadLeft() and .PadRight() method calls with interpolated string placeholders with an alignment expression.
In addition to adding new quick-fixes, we significantly improved the daemon performance for files with huge methods inside:
Methods with large/nested conditional expressions, tuple expressions, or switch expressions.
Methods with lots of type checks when nullable reference types are disabled.
Methods with a lot of indexer accesses when nullable reference types are enabled.
Methods with a huge number of closures when nullable reference types are enabled.
Now, the code analysis is completed faster for such files.
Better Support For SQL Injections
In this release, we improved the support for SQL injections. We now support a lot of common cases where you write SQL code right inside C# code:
SQL query strings are correctly resolved for string.Format methods, string interpolations, and simple string concatenations.
There are no more errors on an SQLParameter variable for parameters inside SQL query strings when using the Microsoft SQL Server dialect or the Dapper library.
Unity Support
We’ve made a couple of small fixes for Unity support in this EAP, plus we’ve added a nice little feature to display the contents of a serialized field’s [Tooltip] attribute in the editor as a tooltip. There’s also an Alt+Enter context action to convert an XML documentation summary into a [Tooltip] attribute, so you’ll be able to see your XML docs in the Unity Inspector. There’s more to come in future EAPs!
Support for Apple Silicon Chips
Some time ago, we started an early preview for the Rider “Apple Silicon Edition” build, which natively runs on Mac computers with Apple silicon processors. Starting from this EAP, this support is included in the regular Rider and will be delivered as part of our EAP and release pipelines. The first EAP build uses the following runtimes:
The Apple silicon–compatible JBR (JetBrains Runtime) for the frontend.
The .NET6 RC1 for the backend.
Project and Solution Properties
Now, let’s look at what’s new in the Project Settings dialog:
You can specify an application icon in the Resource section on the Application page.
There is a new Build Events page to specify commands to run for before and after build.
The Inspections page gets several project properties related to code analysis: Localizable, Localizable inspector, and Solution-Wide inspections.
You can configure reference paths for a project on the Reference Path page.
The Solution Properties dialog has a new Dependencies column in the table to specify build dependencies for each project.
Run Configurations for Publishing
Starting from the 2021.3 EAP, Rider imports all .pubxml files from Properties/PublishProfiles on project loading and converts them to run configurations. Whenever you add a new .pubxml, a new run configuration is generated automatically. There is no more need to create these run configurations manually!

New in Rider 2021.2.1 Build 212.5080.71 (Aug 28, 2021)

New in Rider 2021.2 Build 212.4746.113 (Aug 3, 2021)

Support for ASP.NET Core Endpoints:
We introduced the new Endpoints tool window to help you explore and navigate to any ASP.NET Core endpoint in your project that is registered or annotated with [Route], [Http{Method}], or [AcceptVerbs] attributes. You can inspect endpoint documentation, jump to the source of the controller that implements an endpoint, or find usages to see where it is registered.
In the code editor, you will get first-class support as well! When you use HttpClient, code completion will suggest all URIs that can be resolved to actions in controllers annotated with [Route], [Http{Method}], or [AcceptVerbs] attributes. Renaming an attribute route in a controller affects its usages in URIs, and you can even rename a route directly from the URI string.
You can also use the HTTP Client tab to create and submit requests to your application. This is useful for testing APIs. Learn more in our blog post A Better Way To Discover APIs With The New Endpoints Window.
Blazor WebAssembly Debugging:
The long-awaited client-side debugging for Blazor WebAssembly has come to Rider! Currently, it works for .NET 5.0 and .NET Core 3.1 applications. To get started, follow the official Microsoft guide to set up WASM debugging. Then just start debugging your applications as usual.
When starting a debugging session, the debugger launches and attaches to an instance of Chrome or Edge, including Edge on Ubuntu. From there, you can switch between the web UI and the debugger. Read more about this in our blog post Blazor debugging improvements in Rider 2021.2.
Code Analysis:
If you still use temporary variables to swap variable values, Rider 2021.2 will help you modernize your code with the new Swap via deconstruction quick-fix!
New useful inspections that come with the corresponding quick-fixes: Replace empty array creation with Array.Empty<T>, Replace new EventArgs() with EventArgs.Empty, and Replace Type[0] with Type.EmptyTypes.
Rider respects the generated_code property from your .editorconfig file, allowing you to specify which files to ignore in its code analysis.
Code Analysis is getting a couple of performance improvements for the Find similar issues feature and for large and complex switch statements and switch expressions.
Nullable Reference Types:
Rider now indicates suppressions (!) that are no longer needed and that can be safely removed.
A new context action lets you search for all nullable warning suppressions in scope. From the Find Results tool window, you can then re-evaluate whether the suppressions are needed or not.
We’ve introduced a new refactoring to change nullability, which will update nullability annotations and suggest propagating the changes throughout your codebase.
Several new inspections with corresponding quick-fixes are available when you’re using JetBrains.Annotations attributes and nullable reference types are enabled.
Rider adds new inspections and quick-fixes to help you with using compiler-supported annotations such as [DisallowNull], [AllowNull], [MaybeNull], and [NotNull].
Source Generators Support:
Many of the features available for manually-written code files are also available for source-generated files. For generated code, warnings and errors are displayed in the editor and on the marker bar. Refactorings, like Rename and Change Signature, can now be triggered from source-generated files.
You can now use Find Usages, search for inheritors, and navigate from generated code to manually written code with Ctrl+Click and Navigate To. Semantic highlighting is enabled so that class members like events, fields, and properties are highlighted correctly. All inlay hints are shown where appropriate. Also, Rider now supports code generated by source generators in VB.NET.
Updates for Game Development:
Rider 2021.2 continues with its mission to be a great game development IDE, with a lot of treats for developers who are using Unity. Just to mention a few:
Rider’s smart integration with the Unity editor will now check if any scenes are open and unsaved before you commit code. You can be sure that everything is saved before committing!
Rider has long shown a link to Unity’s documentation in the tooltip for a Unity class or method, but now you can use the External Documentation action and shortcut to jump straight to the docs without showing the tooltip first.
Rider can now debug local UWP players by correctly asking Windows to allow incoming connections to the process being debugged.
This release improves the experience of debugging IL2CPP-based players, by automatically disabling “break on unhandledexception” when it connects to a IL2CPP player.
There are also breakthrough improvements to our early-preview Unreal Engine support – it now works on Mac, supports Unreal Engine 5, and is able to open .uproject files. Check out Game Zone in Rider 2021.2 for other improvements.
Import Settings from other IDEs:
For the convenience of first-time Rider users, we’ve come up with a new Import Settings feature. If you’ve never installed or used Rider before, the Welcome wizard now lets you import settings from other IDEs such as Visual Studio, Visual Studio for Mac, or Visual Studio Code. In addition to this, Rider will also recognize settings from ReSharper. Read more about how importing settings from other IDEs works. We’d love to hear from you about your experience with this new feature.
Code Cleanup:
In Rider 2021.2, we’ve merged the Reformat File and Code Cleanup dialogs into one unified view that allows you to perform both steps at the same time. Cleanup profiles will also preview which actions will be executed, and you can easily switch to the profile editing mode with a button.
There is also the option to reformat/cleanup only uncommitted changes in the current file. In the commit dialog, you can now enable automatic code cleanup for your changes with the profile of your choice.
Among other highlights:
There are some improvements for version control. We’ve added a search field to the Local History dialog to help you quickly get to the necessary text in your Local History revisions. Also, it is now possible to enable Git commit signing with GPG via Preferences/Settings | Version Control | Git.
In the editor, we’ve implemented structural removal of code – select and delete code with any kind of structural selection (such as structural navigation, extend/shrink selection, or rearrange code) and let Rider perform the remaining structural modifications. You can remove commas and colons for method call arguments, parentheses in attribute arguments, or braces for empty object initializers.
It is now easier to drag a tool window to the desired place within the main IDE window or in a separate window. You can drag it by clicking and holding the tool window name bar and dropping it in any highlighted area.
There’s a number of updates for Xamarin users. We’ve added support to generate .aab (Android App Bundle) in addition to .apk files, which will soon be the only way to upload your apps to the Google Play Store. XCAssets can now be created and edited for imageset, appiconset, and colorset right inside of Rider.
For developers using F#, we’ve introduced postfix template for let and some new actions for rearranging the code, pattern deconstruction for F# tuples and union cases, optimizing imports, and more.
Apple Silicon support in Rider: we have an early preview version with full native M1 chip support. Check out this page for more information.
Do you practice Behavior Driven Development (BDD) in .NET? With the new SpecFlow plugin for Rider, you can now enjoy a much smoother experience when embedding automated SpecFlow test cases into their projects. Read more about how BDD and Rider help you write better, more maintainable code through the use of automated tests.

New in Rider 2021.2 Build 212.4746.97 EAP 9 (Jul 29, 2021)

New in Rider 2021.2 Build 212.4746.59 EAP 8 (Jul 22, 2021)

New in Rider 2021.2 Build 212.4746.33 EAP 7 (Jul 19, 2021)

New in Rider 2021.2 Build 212.4416.21 EAP 4 (Jun 25, 2021)

New in Rider 2021.2 Build 212.4037.61 EAP 3 (Jun 11, 2021)

Cleanup Code:
You can run Code Cleanup and Silent Code Cleanup on a text selection.
You can run Code Cleanup on Only VCS changed text in a file (that is, changed text fragments that have not been committed to VCS yet).
Code Cleanup now lets you run Code reformat, Optimize imports, and Rearrange code for CSS, JavaScript, and SQL. You can fine-tune the rules in Preferences/Settings | Editor | Code Cleanup.
You can choose a Code Cleanup profile in the Commit Options menu on the Commit tool window before committing your changes to VCS.
We’ve merged the Reformat file dialog with the Code Cleanup dialog. The shortcuts for both actions remain the same. We’ve also added a new preview box to the new Reformat and Cleanup Code dialog to ease the transition, which shows all the actions that will be executed for the selected profile.
Blazor WASM debugging:
Blazor WASM debugging now works for .NET Core 3.1. Please note that it works only if port 9222 is available to run Chrome under the debugger. This restriction comes from the runtime.
Blazor WASM debugging works on Linux. However, you have to manually install dev certificates beforehand; otherwise, it won’t work. If you are using Ubuntu, you can follow this guide.
Rider supports the debugging proxy if either of these NuGet packages are installed: Microsoft.AspNetCore.Components.WebAssembly.DevServer or Microsoft.AspNetCore.Components.WebAssembly.Server. We don’t support any custom debugging proxies for Blazor WASM apps though. If you need this feature, please let us know and describe your use-case. Thanks!
Nullable reference types (NRT):
There are several new inspections with corresponding quick-fixes to update JetBrains.Annotations attributes to NRT syntax and compiler-supported attributes if NRT annotations are enabled:
An inspection with a quick-fix for redundant JetBrains.Annotations attributes such as [NotNull] string or [ItemCanBeNull] List<string?>.
An inspection with a quick-fix to use the type annotation syntax instead of JetBrains.Annotations attributes, for example [>CanBeNull] string to string?
An inspection with a quick-fix to use compiler-supported attributes when the type annotation syntax is not allowed, e.g. [JetBrains.Annotations.NotNull] T param to [DisallowNull] T param (where T: class?); [JetBrains.Annotations.CanBeNull] T to [System.Diagnostics.MaybeNull] T (in C# 8, where the T? syntax is disallowed)
We’ve improved support for generics.
We’ve updated many context actions, quick-fixes, and postfix templates to work properly with nullable warning suppressions, either preserving nullable warning suppressions or producing them for introduced code if the original code suppressed the warning.
An inspection with a quick-fix to replace [DisallowNull/AllowNull/MaybeNull/NotNull] compiler annotations with NRT syntax when possible, e.g. [AllowNull] T t to T? t.
An inspection with a quick-fix for redundant compiler attributes, e.g., when [AllowNull] is applied to a nullable type.
Debugger:
The preview tab is now available in the debugger! When the debugger steps through the codebase, new files are often opened in the editor. After a few stepping iterations, your editor might be polluted with such files. The preview tab can help here! It allows you to view files in a single tab one by one without opening each file in a new tab. You can enable it in Settings/Preferences | General | Editor Tabs | Opening Policy.
By default, JIT does not run for an assembly if a pre-compiled image (NGen, Crossgen, or any AOT) is loaded for the assembly. Not running JIT for such cases helps speed up application startup under debugging. You can enable JIT anytime here: Preferences | Build, Execution, Deployment | Debugger | JIT (.NET/.NET Core only) | Use JIT even if pre-compiled assemblies are available.
Toolbox App:
Now you won’t miss any critical product updates from the Toolbox App. Rider will alert you if there is a new version available for download and will offer to upgrade to it. You’ll need to have Toolbox App 1.20.8804 or later for this.

New in Rider 2021.2 Build 212.3724.19 EAP 2 (Jun 4, 2021)

New in Rider 2021.2 Build 212.3116.52 EAP 1 (May 31, 2021)

Code Analysis:
Do you still use temporary variables to swap variable values? There is a more elegant way! Rider 2021.2 EAP will help you modernize your code with the new Swap via deconstruction quick-fix!
There are two new useful inspections that come with the corresponding quick-fixes:
Replace empty array creation with Array.Empty<T> (or with Type.EmptyTypes in case of new System.Type[0]).
Replace new EventArgs() with EventArgs.Empty.
Rider 2021.2 EAP respects the generated_code property from your .editorconfig file, allowing you to specify which files to ignore in its code analysis.
Code Analysis is getting a couple of performance improvements:
Find similar issues now provides its results faster. This is because Rider no longer runs analyses that are irrelevant for the corresponding highlighting/inspection.
We’ve sped up a code analysis for large and complex switch statements and switch expressions by caching/sharing the data needed for different inspections.
Nullable reference types:
We are improving our support for nullable reference types (NRT) and updating some actions accordingly.
If you use NRT, you may have noticed that an action to use explicit types instead of var always produces a nullable variable. Although that is correct, var being nullable is an implementation detail of the compiler, and using a nullable type might be confusing if developers never store nullable values in it.
Starting from this EAP build, Rider checks whether the variable needs to be nullable, and it will produce a stricter type when possible.
As you adopt nullable reference types, you might use some nullable warning suppressions that are no longer needed, since the suppressed expression is no longer nullable. Rider will help you find such suppressions and remove them.Finally, sometimes we may be too optimistic about some code and suppress an actual problem, thinking it’ll never happen. When this does eventually happen, it’s very hard to backtrack such suppressions, since ! is a very common symbol in source code. If you want to investigate where nullability contracts are violated with suppressions in your solution, you can now enable a new inspection, A suppressed nullable warning might hide an underlying problem, to find every suppression without having to dig through all other usages of the ! symbol. The inspection can be found in the Rider settings. And it will not be triggered by default, since suppressions are a completely valid way to prevent the compiler from nagging you about complex code that it cannot analyze.
Unity support:
Rider now warns you when you are trying to commit changes and Unity has unsaved scenes open.
We’ve also improved our online help in many ways. Importantly, you can now use the F1 (External Documentation) shortcut to navigate to localized documentation, if available locally.
Solution Explorer:
You can now edit File Properties (such as Build Action or Copy to Output Directory) for multiple items selected in the Solution Explorer.
IIS Express support
Rider will warn you when you try to run a 64-bit web application on 32-bit IIS Express (“use64Bit”: false in launchSettings.json) in in-process mode.
Razor:
Razor developers working on large views can turn off the CPU-intensive assistance and automatic suggestions if their editor begins to lag. You can find the settings here: Preferences/Settings | Editor | General | Typing Assistance | Razor | Allow CPU-intensive typing assist.
Navigation:
The Go To Base/Inheritors list shows hidden overrides, as well.
Code Styling and Formatting:
Support for Pico brace (indenting) style is here.
It’s now possible to specify advanced naming rules for records, extension methods, and catch variables.
Dynamic Program Analysis:
The list of issues now supports multi-selection.
On the off chance you’re developing a performance profiler and Dynamic Program Analysis (DPA) is affecting your profiling (i.e. application performance): you can disable DPA when starting a profiling session. To do this, have your profiler set the JETBRAINS_DPA_AGENT_ENABLE environment variable to 0.

New in Rider 2021.1 Build 211.6693.105 (Apr 8, 2021)

Update to Docker Support:
Adding Docker support to a project in Rider is now easier – you can generate the Dockerfile while creating a new project. Just select Docker Support in the New project dialog. If you want to add a Dockerfile to an existing project, use Add | Docker Support in the context menu for a project in the Solution Explorer tool window.
Scaffolding for ASP.NET:
There’s good news for developers who work with ASP.NET MVC, ASP.NET Web API, or Razor Pages: we’ve added a scaffolding mechanism for ASP.NET Core projects. Rider supports scaffolding Areas, Controllers, Razor Pages, Views, and Identity. It even generates boilerplate source code for full CRUD operations to use Entity Framework.
C# support:
We’ve put a lot of effort into better supporting patterns and records. As a result, the Merge into pattern inspection can now be used with many more code patterns. Additionally, a set of new inspections and corresponding quick-fixes are available to help you work with records. The Extract interface and Extract superclass refactorings now work with record declarations, as well.
Debugger:
You can now attach to a .NET process right from the Welcome screen! No need to open a solution with the source code first. Just select the Attach to process tab on the Welcome screen, choose the .NET process you need from the list, and Rider will begin debugging it.
Pull Requests improvements:
This release brings a huge set of improvements for working with pull requests:
The Pull Requests (PR) view now features a drop-down list with all the available repositories for the current project.
PR creation is now straightforward – just click the “+” icon or go to Git | GitHub | Create Pull Request.
Support for PR templates is also here. Add a pull_request_template.md file with the PR description to your project, and every time you create a PR, this description will appear in it.
Web development:
Apart from the scaffolding feature:
We’ve introduced support for route templates. Rider now provides code completion, structural navigation, inspections, and quick-fixes for them.
The option to delete existing files in a folder before publishing is now available.
MDN documentation is now bundled with Rider.
Preview HTML files quickly with the new built-in browser preview.
Unity support:
Rider can show you where Unity is using your code inside animation assets, showing usages of properties and methods as animation callbacks.
Code completion and validation are now available for Unity’s animation state values.
The new release adds menu items that show the methods that are called in the hot path back up to an Update method, or that trace the outgoing calls to finally reach a known expensive Unity API.
You can debug SerializedProperty instances.
Rider has extended its Unity-based unit testing support to include code coverage for play mode tests.
Godot:
Our Godot Support for Rider plugin now supports running NUnit unit tests directly in the game process to ensure everything works as expected.
UI/UX:
Rider now saves the Solution Explorer’s state, including opened nodes, when the IDE is closed and later re-opened.
We’ve improved our XAML Preview tool.
When there are several vertically split editor tabs open, you can now double-click on each one to maximize the editor window for it.
We’ve reworked the folder selection dialogs on Windows. Now it will only show you folders that you are able to select.
Toolbox manager for the Windows Forms designer has been completely redesigned.
On Windows, you can now access your recent projects by right-clicking the Rider icon on the taskbar or on the Start menu.
Editor:
Syntax highlighting is now available in the Quick Documentation window, where it will provide the same highlighting you see in the code editor.
You can fine-tune the weight of your main and bold font styles in Preferences / Settings | Editor | Fonts.
Code styles:
We’ve added a couple of new formatting settings.
We’ve added a new Reindent only action for Format Selection.
We’ve improved how Rider reads settings for naming rules from EditorConfig and how it writes user-defined naming rules to EditorConfig.
F# support:
We’ve added the new Inline Variable refactoring for local let bindings.
Rider can now calculate an allowed language level based on the project and compiler used in a build, and it can suggest improvements to make your F# code more up-to-date.
To Interpolated String, a new analyzer and quick-fix, can help convert a printf-style format string to an F# 5 interpolated string.
Last but not least:
We’ve implemented NuGet Smart Restore on build.
Rider now supports building in parallel on recent versions of Mono.

New in Rider 2021.1 Build 211.6693.83 EAP 10 (Apr 2, 2021)

Docker support:
Adding Docker support to a project in Rider is now easier – select “Docker Support” on the “new project” dialog or use Add | Docker Support, which can be found in the context menu for an existing project in the Solution Explorer tool window.
Out of the box, Rider can now run Dockerfiles generated by Visual Studio.
C# support:
The Merge into pattern inspection can now be used with many more code patterns.
We’ve added more support for C# 9.0 records.
We’ve introduced a new inspection, Inline temporary variable.
You can call the Rename refactoring for named tuples.
For C# 10.0 support, we’ve taken some first steps and taught Rider to work with the "Constant interpolation strings" feature.
Web development:
We’ve added a scaffolding mechanism for ASP.NET Core projects. Rider supports scaffolding Areas, Controllers, Razor Pages, Views, and Identity. This support includes generating boilerplate source code that allows full CRUD operations to use Entity Framework. Learn more about it in this blog post.
We’ve introduced support for route templates. Rider now provides code completion, structural navigation, inspections, and quick-fixes for them. Learn more about them in this blog post.
The option to delete existing files in a folder before publishing is now available.
MDN documentation is now bundled with Rider.
We’ve added a new built-in browser preview that allows you to preview HTML files quickly.
Debugger:
Now you can attach to a .NET process right from the Welcome screen!
Debugger hints in the editor not only show you what’s going on, but also allow you to interact with the debugger process through debugger hints.
We’ve added an option to show raw data for an object if its representation has been changed with a DebuggerBrowsable attribute.
Unity:
Rider can show you where Unity is using your code inside animation assets, showing usages of properties and methods as animation callbacks.
Code completion and validation are now available for Unity’s animation state values.
The new release adds menu items that show all the methods called in the hot path back up to an Update method, or that trace the outgoing calls to finally reach a known expensive Unity API.
You can debug SerializedProperty instances.
Rider has extended its Unity-based unit testing support to include code coverage for play mode tests.
Godot:
Our “Godot Support for Rider” plugin now supports running NUnit unit tests directly in the game process to ensure everything works as expected.
VCS:
The Pull Requests (PR) view now features a drop-down list with all the available repositories for the current project.
PR creation is now straightforward – just click the “+” icon or go to Git | GitHub | Create Pull Request.
Version 2021.1 supports PR templates.
Rider now has a Git commit template, which you can use to create custom commit messages to suit your needs.
In v2021.1, we added the Save to Shelf action that copies your changes to the Shelf while keeping them in the local changes.
UI/UX:
Rider now saves the Solution Explorer’s state, including opened nodes, when the IDE is closed and later re-opened.
We’ve improved our XAML Preview tool. Learn more about that in the blog post.
When there are several vertically-split editor tabs open, you can now double-click on each one to maximize the editor window for it.
We’ve reworked the folder selection dialogs on Windows. Now it will only show you folders that you are able to select.
Toolbox manager for the Windows Forms designer has been completely redesigned.
Editor:
Syntax highlighting has come to the Quick Documentation window, where it will provide the same highlighting you see in the code editor.
In v2021.1, you can fine-tune the weight of your main and bold font styles in Preferences / Settings | Editor | Fonts.
On Windows, you can now access your recent projects by right-clicking the Rider icon on the taskbar or on the Start menu.
Code styles:
We’ve added a couple of new formatting settings.
We’ve added a new Reindent only action for Format Selection.
We’ve improved how Rider reads settings for naming rules from EditorConfig and how it writes the user-defined naming rules to EditorConfig.
F# support:
We’ve added the new Inline Variable refactoring for local let bindings.
Rider can now calculate an allowed language level based on the project and compiler used in a build and suggest improvements to make your F# code more modern and up-to-date.
To Interpolated String, a new analyzer and quick-fix, aims to convert a printf-style format string to an F# 5 interpolated string.
Other updates:
We’ve implemented NuGet Smart Restore on build.
Rider now supports building in parallel on recent versions of Mono.
When performing the timeline profiling of .NET Core applications on Windows, dotTrace collects information about incoming HTTP requests.

New in Rider 2021.1 Build 211.6693.2 EAP 9 (Mar 26, 2021)

Docker support:
Adding Docker support to a project in Rider is now easier – select “Docker Support” on the “new project” dialog or use Add | Docker Support, which can be found in the context menu for an existing project in the Solution Explorer tool window.
Out of the box, Rider can now run Dockerfiles generated by Visual Studio.
C# support:
The Merge into pattern inspection can now be used with many more code patterns.
We’ve added more support for C# 9.0 records.
We’ve introduced a new inspection, Inline temporary variable.
You can call the Rename refactoring for named tuples.
For C# 10.0 support, we’ve taken some first steps and taught Rider to work with the "Constant interpolation strings" feature.
Web development:
We’ve added a scaffolding mechanism for ASP.NET Core projects. Rider supports scaffolding Areas, Controllers, Razor Pages, Views, and Identity. This support includes generating boilerplate source code that allows full CRUD operations to use Entity Framework. Learn more about it in this blog post.
We’ve introduced support for route templates. Rider now provides code completion, structural navigation, inspections, and quick-fixes for them. Learn more about them in this blog post.
The option to delete existing files in a folder before publishing is now available.
MDN documentation is now bundled with Rider.
We’ve added a new built-in browser preview that allows you to preview HTML files quickly.
Debugger:
Now you can attach to a .NET process right from the Welcome screen!
Debugger hints in the editor not only show you what’s going on, but also allow you to interact with the debugger process through debugger hints.
We’ve added an option to show raw data for an object if its representation has been changed with a DebuggerBrowsable attribute.
Unity:
Rider can show you where Unity is using your code inside animation assets, showing usages of properties and methods as animation callbacks.
Code completion and validation are now available for Unity’s animation state values.
The new release adds menu items that show all the methods called in the hot path back up to an Update method, or that trace the outgoing calls to finally reach a known expensive Unity API.
You can debug SerializedProperty instances.
Rider has extended its Unity-based unit testing support to include code coverage for play mode tests.
Godot:
Our “Godot Support for Rider” plugin now supports running NUnit unit tests directly in the game process to ensure everything works as expected.
VCS:
The Pull Requests (PR) view now features a drop-down list with all the available repositories for the current project.
PR creation is now straightforward – just click the “+” icon or go to Git | GitHub | Create Pull Request.
Version 2021.1 supports PR templates.
Rider now has a Git commit template, which you can use to create custom commit messages to suit your needs.
In v2021.1, we added the Save to Shelf action that copies your changes to the Shelf while keeping them in the local changes.
UI/UX:
Rider now saves the Solution Explorer’s state, including opened nodes, when the IDE is closed and later re-opened.
We’ve improved our XAML Preview tool. Learn more about that in the blog post.
When there are several vertically-split editor tabs open, you can now double-click on each one to maximize the editor window for it.
We’ve reworked the folder selection dialogs on Windows. Now it will only show you folders that you are able to select.
Toolbox manager for the Windows Forms designer has been completely redesigned.
Editor:
Syntax highlighting has come to the Quick Documentation window, where it will provide the same highlighting you see in the code editor.
In v2021.1, you can fine-tune the weight of your main and bold font styles in Preferences / Settings | Editor | Fonts.
On Windows, you can now access your recent projects by right-clicking the Rider icon on the taskbar or on the Start menu.
Code styles:
We’ve added a couple of new formatting settings.
We’ve added a new Reindent only action for Format Selection.
We’ve improved how Rider reads settings for naming rules from EditorConfig and how it writes the user-defined naming rules to EditorConfig.
F# support:
We’ve added the new Inline Variable refactoring for local let bindings.
Rider can now calculate an allowed language level based on the project and compiler used in a build and suggest improvements to make your F# code more modern and up-to-date.
To Interpolated String, a new analyzer and quick-fix, aims to convert a printf-style format string to an F# 5 interpolated string.
Other updates:
We’ve implemented NuGet Smart Restore on build.
Rider now supports building in parallel on recent versions of Mono.
When performing the timeline profiling of .NET Core applications on Windows, dotTrace collects information about incoming HTTP requests.

New in Rider 2021.1 Build 211.6432.4 EAP 7 (Mar 11, 2021)

New in Rider 2021.1 Build 211.6305.3 EAP 6 (Mar 5, 2021)

New in Rider 2021.1 Build 211.6222.2 EAP 5 (Feb 26, 2021)

New in Rider 2020.3.3 Build 203.7148.23 (Feb 23, 2021)

New in Rider 2021.1 Build 211.6085.25 EAP 4 (Feb 19, 2021)

New in Rider 2021.1 Build 211.4961.12 EAP 2 (Feb 4, 2021)

New in Rider 2020.3.2 Build 203.6682.21 (Dec 30, 2020)

New in Rider 2020.3 Build 203.5981.141 (Dec 15, 2020)

Here are the most notable new features in this release.
.NET 5:
Rider supports all of the features from the latest versions of .NET including source generators, new NuGet features, and new target frameworks (net5.0-windows and net5.0).
C# 9:
All the new features from C# 9 are finally supported in Rider: record types, updates to partial methods, init-only properties, and attributes for local functions, to name but a few.
Immediate Window:
The new Immediate Window allows you to create synthetic variables when the program stops on a breakpoint, and to experiment with your code without restarting the debugger.
Project Dependency Diagram:
This long-awaited feature from ReSharper helps you visualize project dependencies in your solution and explore its architecture.
Unity support:
Rider 2020.3 includes more Unity support, with updates to Burst analysis, shader support, and unit testing, as well as a handful of helpful fixes.
If you have any questions about the features and improvements listed above, you can learn more on the What’s New in Rider 2020.3 page.
Other awesome updates in this release
I decided not to include all the improvements in the list below, as it would be a bit too long for a blog post. We’ve written down all the features on the What’s New in Rider 2020.3 page, so please refer to it if you want to know all the details.
Other updates include:
Support for F# 5 features: string interpolation, nameof keyword, and open type declarations.
If you want to have several tabs open while working on a project, you can now drag and drop file tabs to split the editor either horizontally or vertically.
Search for all occurrences comes to the Solution Explorer view! It looks through all the nodes in the solution tree (now even in collapsed nodes) including files, folders, projects, references, analyzers, imports, and packages.
We’ve introduced full language support for the Avalonia UI framework.
We’ve added Git Staging support! You can now stage changes directly from Rider.
The Dynamic Program Analysis plugin (previously only available for Windows) is now available on macOS and Linux for .NET Core applications.
In the dotCover plugin, you can now define what projects should be built when a continuous testing session is triggered.
We’ve added a flame graph to the performance profiler. This graph is a visualization of the Call Tree that lets you find slow methods more quickly.
We’ve created a new “Push-to-Hint” mechanism for inlay hints.
You can now specify a template for a file header.
It is possible to sync your IDE and OS themes.
We’ve added a great new feature to detect and configure formatting settings from the code editor.
Blazor support has been improved.
The performance of Solution-Wide Error Analysis has improved by approximately 25% thanks to turning off greedy inspection calculations.
There’s a new rich editor for Info.plist in Xamarin.iOS projects.

New in Rider 2020.3 Build 203.5981.86 EAP 10 (Dec 3, 2020)

New in Rider 2020.3 Build 203.5981.21 EAP 9 (Nov 27, 2020)

New in Rider 2020.3 Build 203.5981.5 EAP 8 (Nov 19, 2020)

New in Rider 2020.3 Build 203.5784.25 EAP 7 (Nov 13, 2020)

New in Rider 2020.3 Build 203.4818.8 EAP 4 (Oct 16, 2020)

New in Rider 2020.3 Build 203.4203.15 EAP 2 (Oct 2, 2020)

C# 9:
First chunk of support for Init-only setters:
Quick-fix to make an init-only property or indexer mutable (when assignment to property is disallowed).
Quick-fix for init-only mismatch when overriding or implementing a property or indexer.
Proper generation of overriding and implementing members.
Code completion for init accessor, generative completion.
Initial support for static lambdas.
Debugger:
We're introducing a new Immediate window with IntelliSense. It allows you to create synthetic variables when the program stops on a breakpoint, and experiment with your code without restarting the debugger.
Project Dependency Diagram:
Our new architecture tool helps you visualize project dependencies in your solution and explore its architecture. Open it from Tools | Architecture | Show Project Diagram or from the context menu in the Solution Explorer. The navigation and File Structure window will help you work with the architecture diagram. Analysis for coupling between projects can be enabled in the diagram toolbar.
Unity:
Unity MenuItem can now be run directly from Rider.
We've added smart backspace for ShaderLab.
We've updated support for shader_target, shader_feature, and multi_compile directives in ShaderLab.
The Remove redundant event function quick-fix is available again.
Other updates:
A template for a file header can now be specified in File | Settings | Editor | File Header Template. You can use it to add a copyright notice, company information, etc.
The IDE theme can be automatically synced with OS settings. Enable the Sync with OS option in Settings | Appearance & Behavior | Appearance | Theme. It's currently available on Windows and Mac.
We've added a flame graph to the performance profiler – this is a visualization of the Call Tree that lets you find slow methods more quickly.
You can now adjust the indentation of the current line in code with the Tab key; assign the key to the Emacs Tab action to use this feature.
The VCS menu is now renamed to match the name of the version control system that you are currently using.
We've made improvements to Markdown editing and Preview.
We've added a quick-fix to create a React component from an unresolved reference.
We've finalized support for the pnpm package manager.

New in Rider 2020.2.4 Build 202.7660.16 (Oct 1, 2020)

New in Rider 2020.3 Build 203.3645.15 EAP 1 (Sep 24, 2020)

New in Rider 2020.2.2 Build 202.6948.24 (Sep 10, 2020)

New in Rider 2020.2 Build 202.6397.244 (Aug 14, 2020)

DEBUGGER:
New Debugger API:
The new release comes with the new debugger API which has been largely rewritten. This is not noticeable from the UI, but it allows more features to come and allows plugins to hook into the debugging process as never before. This includes improved super-lazy value calculations with better interruption and custom value representations. The only thing noticeable from the outside is that debugger tool windows show the correct icons for all variables.
Data breakpoints:
Data breakpoints are useful when you need to focus on a particular object’s properties. You typically use them in scenarios where you know what will change, but have no idea where the change comes from in your codebase. This will be accessible from the Watch tool window, and will even work with array elements. Due to current platform limitations, this feature is only available for .NET Core 3+ on Windows.
Pin-To-Frame:
In Rider 2020.2, we’re adding Pin-To-Frame, which lets you pin values across frames. You can pin parameters for a function, and see them in the list of stack frames. When debugging recursive functions, it lets you watch the state of values in different iterations.
Localization Manager:
The Localization Manager is now available in Rider to help you localize your .NET application or website. You can access it using the Tools menu or by double-clicking on a .resx file.
It allows you to view everything contained in all your project’s .resx files, or a specified selection of files, in a single grid.
You can easily find all resources that are missing localized values or are just not used.
You can add, edit, rename, search for, find usages of, and safely delete any localized resources.
You can easily add a new culture to your application using the predefined list of cultures in the completion list or hide locales you don't need right now.
You can export the whole grid to a CSV format to share with translators and import the final version back into the Localization Manager.
You can add and edit comments for any entity from resource files right inside the grid, and you can also export and import these comments.
You can view the whole structure of .resx files in your solution with different groupings.
GameDev:
Shader support:
Rider 2020.2 adds much-requested support for Cg and HLSL shaders! This includes syntax highlighting, code completion, semantic error highlighting, go to definition, find usages, refactorings, and more.
Rider fully understands the structure of shader files, including macros, and can navigate to macro definitions or unroll them directly in code. Included files are discovered and parsed, and Ctrl+Click on an included file will take you directly to that file.
Pausepoints:
Introducing a new kind of breakpoint! Set a breakpoint in code, convert it to a pausepoint, and when the debugger hits it, Unity Editor immediately switches to pause mode, allowing you to use the Inspector to view the state of your game.
This becomes an even more powerful tool when used in combination with conditional and dependent breakpoints.
Burst analysis:
Burst-enabled code can greatly improve the performance of your Unity application, but it places constraints on what your code can do.
Rider 2020.2 adds smart analysis for all code called within a Burst context, and will highlight any incorrect code usage, such as boxing, use of foreach or try/catch, as well as reading/writing to static fields, and more.
USB debugging for Apple devices:
Rider already has great support for debugging players over the network, including standalone desktop players, mobiles, and consoles.
Rider 2020.2 introduces USB-based debugging for Apple devices (USB debugging for Android devices is planned for a future release).
Bulk quick fixes:
All quick-fixes that can be run on files, projects, and entire solutions have now been upgraded to be able to do so.
Remove redundant Unity attributes, replace string literal comparisons with CompareTag, improve performance by combining object creation with setting the parent transform, and more – all across your entire Unity project, with a single click.
Debugger value extensions:
Rider’s debugger will show you extra contextual values for Unity projects. Get easy access to the active scene, child game objects, and all attached components.
Rider also displays improved summary information for certain types, such as Euler angles for Quaternion, full precision values for vectors, the enabled state of behaviors, and more.
Integrated UnityYamlMerge support:
Rider will automatically use Unity’s Smart Merge tool to merge asset files when performing integrated version control operations.
More features:
Significant reduction in memory usage and improved throughput while indexing text-based assets for code usages in scenes, prefabs, and other assets.
Common Unity API terms have been added as a custom dictionary to Rider’s spell checker.
Code cleanup now recognizes Unity types, and will no longer reorder serialized fields, which is important when showing these fields in the Unity Inspector.
More minor features and fixes.
Rider for Unreal Engine Early Preview:
Are you interested in game development with Unreal Engine? On our way toward making Rider a standalone, all-in-one, universal game development IDE, we have introduced early support for Unreal Engine development in Rider:
Native C++ support powered by the ReSharper C++ engine.
Performance optimized for Unreal Engine projects.
Integration with the Unreal Editor and Blueprints information in the Rider Editor.
Understanding UE reflection and RPC, and enforcement of UE naming rules.
Getting HLSL and C#, JSON, and uproject/uplugin dialects.
Code Analysis:
Nullability code analysis is now aware of more cases and can trace incorrect nullability through deconstruction and the foreach cycle. It also provides a corresponding quick-fix.
Code analysis now takes into account JetBrains.Annotations attributes (both NotNull and CanBeNull) for the API, even in code where nullable reference types are disabled (#nullable disable).
Context actions for converting "foreach to LINQ" and "LINQ to code" are also available on IAsyncEnumerable‹T› if you have the System.Linq.Async NuGet package installed for your project.
Now it’s possible to easily generate IEqualityComparer‹T› and IComparer‹T› implementations with the appropriate quick-fixes.
Code Analysis now takes compiler annotations (such as AllowNull and DisallowNull) into account when verifying the nullability of implemented or overridden members.
There are new inspections and quick-fixes to make variables and return types “not nullable” if they have never held or returned nullable values.
Code analysis is now able to follow the dotnet_diagnostic rules from the .editorconfig file. Specify the severity of inspections in the .editorconfig file, e.g. dotnet_diagnostic.CS1058.severity = hint, and Rider will display inspections accordingly.
Support for the default implementations in interfaces feature has been enhanced in this release. The left-hand gutter in the code editor shows that a method is implemented or overridden, and our refactorings and navigation are aware of this C# language feature.
Inlay hints are now available in XAML code. We provide hints for markup property names and DataContext, as well as for margins and paddings, which is handy if you don’t want to memorize their orders.
The Suppress nullable warning with ! quick-fix can be disabled for a solution via the Alt+Enter menu.
Unit Testing:
We’ve rebuilt our unit test runner from scratch for both .NET Framework and .NET Core to have the same runner for both runtimes which run out of the Visual Studio process. It helps us solve a lot of problems with discovering, running, and debugging unit tests, and gives us full control over unit test hierarchies for .NET Core tests.
The new unit test runner introduces the following important improvements:
Built-in support for MSFakes for NUnit, xUnit, MSTest v2 unit test frameworks.
Built-in support for TypeMock Isolator for NUnit, xUnit, and MSTest v2.
MSTest v2 tests can now be run without Visual Studio installed.
Rider now supports the DisplayName attribute in .NET Core tests for xUnit and NUnit frameworks.
You can select multiple unit test statuses simultaneously to filter them in the unit test tree. Enable or disable multiple statuses by holding down the Ctrl key as you click on them.
There are two different counters for each status when a search or target framework filter is applied to show the overall number of unit tests, and the number of tests that match the filter criteria.
We’ve added support for ANSI escape codes in the Output window, so you can colorize the unit test output if you want.
There is a new action in the Alt+Enter menu to open the Settings dialog if you get a "Visual studio installation folder is not set" status for your MSTest unit test.
Version control:
Enhanced support for GitHub pull requests is finally here! You’ll be able to browse, assign, manage, and even merge pull requests, view the timeline and inline comments, submit comments and reviews, and accept changes.
The new support includes:
A new layout for the pull requests viewer.
Viewing the results of pre-commit checks in the Timeline.
Support for reviews.
Interaction with comments.
Merging pull requests from within the IDE.
Other VCS features:
In addition to full GitHub pull request support, the following new features are available for version control systems:
Support for Git installed in WSL2.
We’ve improved the way the result of the Compare branches action is presented.
You can now select a number of local commits in the Log tab of the Git tool window and squash them into one. This action is available from the right-click context menu.
NuGet:
You can use the NuGet tool window to see all the transitive packages of a solution or project in the new Implicitly Installed Packages section.
Hovering over an implicit package reveals a tooltip that contains information about the implicit package’s version and the referencing package. If the package is referenced in multiple versions, they will all be shown.
We’ve added a new context popup menu that can be invoked via right-clicking or pressing Alt+Enter on a NuGet package. From here you can quickly access all the relevant actions for a single NuGet package, like updating or removing the package, opening it in the Assembly Explorer to examine the API, revealing it in the filesystem explorer, navigating to the related NuGet.org entry, or finding dependent code.
There is also a new Quick NuGet Documentation action to bring up the implicit reference paths to a package.
The search box for packages also received an update. You can either click the magnifier icon or use Alt+Down Arrow to open the history of recent package searches.
We can now also edit values for two of the most commonly changed properties – globalPackagesFolder and repositoryPath.
In the Feeds tab, we can now immediately see whether a feed path is invalid as the path will be highlighted with a red rectangle.
A warning message will also be shown in the search list if we search for a package and it is not found in any of the feeds.
A new warning in the details pane is a visual indication of which packages are still in maintenance or have been deprecated.
F# support:
Refactorings:
The Introduce Variable refactoring is now available for expressions. When invoked, it shows the suitable subexpressions (unless a specific part of code is selected) and offers to replace similar subexpressions. It is also smart about naming the new variable, and suggests a meaningful name according to type and context.
Rename now works on underscore wildcards. Whenever you need to turn a wildcard pattern into a named variable, you can call the refactoring instead of doing it manually. It also takes type and context into account when suggesting names.
Quick fixes and context actions:
Import Type has been significantly improved. It now works in more cases and keeps the parameter count in mind when suggesting a type. Rider can now also suggest referencing a module or another project from your solution and import the type from it.
Other VCS features:
Several new quick-fixes have been added as well: adding parentheses to an application of a function in the list of parameters, adding the Extension attribute to a containing type or module, fixing syntax errors, converting let to use, and others.
Analyzers:
We’ve implemented a fast redundant qualifiers analyzer, as well as a corresponding quick-fix to remove the redundancies.
Editor:
There's now more options for highlighting various symbols differently. In addition, type abbreviations are highlighted as the types they abbreviate, and functions can be highlighted as methods. Both are external contributions, and we thank Igor Bagdamyan for them.
Rider now has type hints for expressions in |> chains. They help you keep track of what’s happening without having to follow the whole chain in your mind. This too is an external contribution, which we’d like to thank Saul Rennison for.
Color references are now highlighted in the code, making them more visible.
Finally, we now have an F# Compiler Service monitor – thanks again to Saul. Whenever FCS is busy, an indicator will be displayed. This is mostly a diagnostic tool: it helps the developer understand the reason why the IDE is thinking, and in the event that the behavior seems suspicious, it can be reported to the Rider team to be analyzed.
x:Bind support:
We have good news for UWP developers – support for compiled bindings with x:Bind is finally here!
Rider resolves x:Bind code correctly and offers several inspections and corresponding quick-fixes. It warns you about missing property setters, BindBack attributes, and when there are overload collisions. In addition, there is a set of Create from Usage quick-fixes to generate a proper field, property, or method inside C# code-behind.
There is code completion and parameter info for propertyPath, BindBack, and UpdateSourceTrigger attributes inside an x:Bind expression
Change Signature and Safe Delete refactorings are now aware of method usage in XAML code and update them accordingly. Also, Make Static/Const and Encapsulate Field refactorings work directly from XAML code and update XAML usages correctly if you call them from C# code-behind.
Nullability awareness is integrated into the x:Bind code analysis. Rider now shows you null-related inspections directly inside the XAML code if there are CanBeNull and NotNull attributes in C# code, for example, “Possible System.NullReferenceException” and “Possible null assignment to non-nullable entity” for arguments in a method used in a propertyPath.
Other Rider features like Find Usages and Go to Declaration are also aware of x:Bind bindings.
Plugins:
dotTrace:
The dotTrace plugin can profile the native part of Mono/Unity applications on Windows. Start a session with the Enable native profiling option and you’ll see both native and managed call stacks in performance snapshots.
Dynamic Program Analysis:
Now, you can filter by process/module/class/method in Settings/Preferences | Build, Execution, Deployment | Dynamic Program Analysis | Filtering to narrow the scope of Dynamic Program Analysis.
If you need to analyze only some specific method/class/etc., add it to the Analyze code only in list.
If you need to hide some specific method/class/etc. from analysis, add it to the Do not analyze code in list.
dotCover dotUltimate:
The new release brings several useful features to the dotCover plugin:
The Unit Tests Coverage window now lets you export coverage reports.
The Unit Tests Coverage window now has a quick search feature.
You can now navigate from a symbol in code to that symbol in the coverage tree (Navigate to | Coverage Tree or using the Navigate from Editor icon on the toolbar in the Coverage tool window).
Azure Toolkit for Rider:
After you install Azurite storage emulator using npm (npm install -g azurite), an Azurite node will be added to the Services tool window. From here, you can start, stop, and clear the storage emulator.
When you’re using timer triggers in Azure Functions, you have to enter a valid NCrontab expression that defines when the function will be executed. The Azure Toolkit for Rider now helps you edit the crontab by providing code completion with several example expressions from which you can start working.
Rider now validates whether an NCrontab expression is valid or not, and gives you extra information about what may be wrong.
Markdown plugin:
Say hello to Markdown support in Rider! Rider 2020.2 comes bundled with the Markdown plugin. It recognizes Markdown files in your solution, provides a dedicated editor for them, and shows the rendered HTML in a live preview.
Godot support:
Godot run configurations have been reworked. You can run, debug, and run with profiling Player and Editor run configurations. In addition, you can edit the command line parameters which is used to run both player and editor.
Also, you can now launch run or debug for individual scenes right from the context menu in the Solution Explorer view.
Database support:
Separate editor for cell values:
Now if you have a huge value in your cell, you can view and edit it in a separate panel. You can also toggle soft wrap mode using the right-hand toolbar. Use all the power of Rider’s code editor for your data!
A new UI for boolean values:
There’s now a more user-friendly way to view and edit boolean values. True values are now marked with a bullet point to distinguish them from all the others.
DML preview in the data editor:
Starting with this version, you can review the query that represents your changes in the data editor. There is now a DML icon that is active if there are pending changes. On clicking on the icon, you will see a dialog with the DML preview. This query is not necessarily the exact SQL that will be run to modify your data, because Rider uses a JDBC driver to update tables, but most of the time it will be the same.
Web development:
Save time with new features for JavaScript:
New smart intentions (Alt+Enter) will help you perform some actions faster. For example, you can now quickly convert a for loop with a numeric index into a forEach array method. Looking through documentation comments in JavaScript and TypeScript files has also become easier as you can now render them right in the editor, minimizing all distractions.
Make Prettier the default formatter in your JavaScript projects:
Want to use Prettier instead of the built-in formatter to tidy up your code? With this update, it has become even easier than before. Install the plugin from the JetBrains Marketplace and then, on the Settings/Preferences | Plugins page, tick the new On code reformat checkbox and the IDE will use Prettier whenever you reformat your .js, .ts, .jsx, and .tsx files. Other file types can be easily added, too.
Enjoy best-in-class support for Vue:
In the past year we’ve added Nuxt.js support, Vue-specific code style settings, improvements around Vue in TypeScript projects, and a lot of other updates. Vue support in Rider has never been so advanced!
Refactorings:
In this release, the Conflicts dialog has been redesigned as a separate step in the Refactorings interface. The plain list from before has been replaced with a tree grouped by file. To return to the plain list, click on the Flatten icon on the right toolbar.
When calling Introduce parameter or Introduce field refactorings on an expression, Rider asks which part of the expression the refactoring should be applied to.
Other updates:
Xamarin:
There are a couple of notable updates:
File Templates are available in both Mac and iOS Xamarin projects.
We’ve improved XCode synchronization – when there's no “.Designer.cs file”, Rider now generates one instead of displaying an error.
Last but not least:
New presentation of the search results in Search Everywhere.
We now support attaching the debugger to .NET Сore runtime hosting configurations and running them with debug.
Run configurations are generated for all runnable projects.
ProjectReferences for website projects are now supported.

New in Rider 2020.2 Build 202.6397.19 EAP 8 (Jul 24, 2020)

New in Rider 2020.2 Build 202.6250.18 EAP 7 (Jul 17, 2020)

New in Rider 2020.2 Build 202.5958.478 EAP 6 (Jul 11, 2020)

Working with resources:
The localization manager is now available in Rider. It allows you to view everything contained in .resx files in a single grid. You can also add, edit, rename, search for, and safely delete any localized resources, in addition to finding all resources that are missing localized values and hiding locales you don't need right now. You can access it using the Tools menu or by double-clicking on a .resx file.
Unity:
The long-awaited Shader support has been implemented! And if something goes wrong, you can disable it with the Disable Shader Support action. Just press Ctrl+A+A and start typing the action's name.
There are new analyses and inspections for Burst compiled code.
Rider now checks that SerialiseField is of the correct type.
We've added support for splitting UnityEditor.dll into separate assemblies.
Run Configurations are now auto-generated for any Run, Debug, or Profile of Unity Standalone Player. Additionally, debugging has been fixed.
We've improved the UX of the Attach to Unity Process dialog, and Rider no longer shows incorrect entries in the processes list.
We've also implemented performance updates for Unity Player discovery and fixes for issues involving players not being listed in the Attach to Unity Process dialog.
Xamarin:
File Templates are available in both Mac and iOS Xamarin projects.
For XCode synchronization, when there's no .Designer.cs file, Rider now generates one instead of displaying an error.
Debugger:
Data breakpoints are here! They are currently available in Windows and .NET Core 3.0+.
DPA:
Configurable filters have been added. They make it possible to include or exclude issues by process name, module name, class name, or method name.
Unit Testing:
We've implemented a new unified test runner for both .NET Framework and .NET Core. It solves a bunch of issues that involve discovering and running unit tests.
We've also added support for MSFakes for NUnit, xUnit, and MSTest on .NET Framework and .NET Core tests (Windows only).
TypeMock for NUnit, xUnit, and MSTest V2 is now supported, as well.
Project Model:
ProjectReferences for website projects are now supported.
Run Configurations:
We now support attaching to .NET core runtime hosting configurations and running them with debug.
Godot (new version is compatible with 2020.2 EAP5+):
Run Configurations have been reworked.
You can now launch run or debug for individual scenes from the context menu.

New in Rider 2020.2 Build 202.5958.170 EAP 5 (Jul 3, 2020)

New in Rider 2020.3 Build 202.5792.135 EAP (Jun 26, 2020)

New in Rider 2020.3 Build 202.5428.8 EAP 2 (Jun 19, 2020)

New in Rider 2020.2 Build 202.5103.14 EAP 2 (Jun 11, 2020)

New in Rider 2020.2 Build 202.5103.14 EAP (Jun 11, 2020)

New in Rider 2020.1.0 Build 201.6668.197 (Apr 16, 2020)

The backend runs on .NET Core runtime:
Finally, the backend runs on .NET Core runtime by default on macOS and Linux, instead of the Mono runtime. Moving to .NET Core runtime delivers noticeable performance improvements, a lower memory footprint, and multithreaded NuGet restore.
This is important for developers using Rider on macOS and Linux, but it is also good news for developers on Windows because bringing it to Windows is the next big step we’re going to take.
Now let’s have a look at the other impressive features and improvements in this first major release of the year.
Xamarin hot reload:
Now Rider automatically applies changes made in Xamarin Forms XAML to the application under debugging on a device or a simulator, without rebuilding and redeploying the whole application.
Dynamic Program Analysis:
Every time you run your project in Rider, Dynamic Program Analysis (DPA) starts collecting memory allocation data. Once you close the application, DPA will show you a list of detected problems: closures, and allocations to large and small object heaps. No need to start any “profiling sessions” and get snapshots – just work as usual and all the data will be collected in the background, with almost zero overhead.
Dataflow analysis of integer values:
Thanks to ReSharper, this version of Rider comes with a new type of analysis that tracks how the values of all int local variables change, and it verifies the correctness of all common operations on such variables to detect unnecessary or possibly erroneous pieces of code.
Deferred asset indexing for Unity projects:
We’ve made significant improvements in the memory usage and speed of asset indexing. Rider will now index all of your code before looking at your assets, meaning that all productivity features, such as code completion, highlighting, and inspections, are available for use sooner than before. And this is just one thing from the heap of improvements Rider Unity team has delivered in this release, which we will mention a bit later.

New in Rider 2020.1 Build 201.6668.112 EAP 8 (Apr 8, 2020)

New in Rider 2020.1 Build 201.6668.91 EAP 7 (Apr 3, 2020)

New in Rider 2020.1 Build 201.6487.145 EAP 6 (Mar 26, 2020)

New in Rider 2020.1 Build 201.6251.35 EAP 5 (Mar 19, 2020)

New in Rider 2020.1 Build 201.6073.104 EAP 4 (Mar 12, 2020)

New in Rider 2020.1 Build 201.6073.85 EAP 3 (Mar 10, 2020)

New in Rider 2020.1 Build 201.5616.21 EAP (Mar 3, 2020)

New in Rider 2019.3 Build 193.5233.39 EAP 7 (Nov 28, 2019)

New in Rider 2019.3 Build 193.5233.34 EAP 6 (Nov 24, 2019)

New in Rider 2019.2 Build 192.5895.673 EAP 6 (Jul 31, 2019)

New in Rider 2019.2 Build 192.5895.291 EAP 5 (Jul 25, 2019)

New in Rider 2019.2 Build 192.5308.1339 EAP 4 (Jul 18, 2019)

New in Rider 2019.1.3 (Jul 11, 2019)

New in Rider 2019.2 Build 192.5308.630 EAP 2 (Jul 5, 2019)

New in Rider 2019.2 Build 192.5308.380 EAP 1 (Jul 2, 2019)

New in Rider 2019.1 Build 191.6733.764 EAP 7 (Apr 19, 2019)

New in Rider 2019.1 Build 191.6733.360 EAP 6 (Apr 11, 2019)

New in Rider 2019.1 Build 191.6674.156 EAP 5 (Apr 5, 2019)

New in Rider 2019.1 Build 191.6487.377 EAP 4 (Apr 2, 2019)

New in Rider 2019.1 Build 191.6487.188 EAP 3 (Mar 28, 2019)

New in Rider 2019.1 Build 191.6349.96 EAP 2 (Mar 21, 2019)

New in Rider 2019.1 Build 191.6062.275 EAP (Mar 15, 2019)

Publishing: support for publishing ASP.NET Classic (non-Core) web apps to local folders or via FTP.
IIS Express support in Rider: you can run and debug ASP.NET Core web applications on IIS Express (Windows only).
Outstanding update for F# support: the Rename refactoring for F#-defined symbols works across your entire solution; there are a heap of new handy features in Navigation, Find Usages, and cross-language interop; and more.
Massive startup performance upgrade: warm startup is now significantly (up to 2x) faster.
IL (Intermediate Language) viewer comes to Rider.
Xamarin support: Xcode integration was introduced, and Android support was extracted to a “non-bundled” plugin in the Plugin Repository.
Breadcrumbs support C#, VB.NET, and F# files.
Parameter info tooltip has been significantly improved.
Initial C# 8 support.
Project Model improvements: better support for web references; the .NET Core version can be defined when creating a new project; and the MSBuild process can be automatically restarted if it was killed for some reason.
Huge unit testing update: performance and memory footprint improvements; new grouping rules introduced; the Session progress bar is available in a Unit Tests session window; new ‘Track Running Test’ and ‘Hide Empty Test Filters’ modes available in Unit Test Session Options; and lots more!
Run Configurations: a static method and a run configuration for a project can be executed directly from the gutter mark in the text editor.
Structural navigation from ReSharper is here to make Tab great again in Rider too.
Improved Unity support: new inspections and quick-fixes available; new notification when the Unity editor plugin is out of sync and automatic update is disabled; new notification to inform user there is no Player.log to open; ECS methods are marked as used; and Performance-critical context works across files.
VCS support: Fixup and Squash actions added to the VCS log; cherry-pick a file from a commit from the VCS log; incoming and outgoing commits are indicated; deleted shelved files can be restored; there’s a new ‘Uncheck all’ checkbox for partial Git commits; and you can switch sides in the diff viewer.
There’s a new navigation popup, ‘Recent Locations’, which shows your recently visited locations as code snippets, with a couple of lines before and after them (read more).
Web development: easier navigation in Angular projects using the Related symbol action; better support for TypeScript inside .vue files; support for Cucumber tests written in TypeScript; improved support for ESLint and TSLint in projects with multiple linter configurations; support for Less 3.0 features; new intentions and inspections.
Database support: Greenplum, Vertica, and Apache Hive are supported; code completion supports combined statements for CREATE and DROP; you don’t have to save the password at all; and more.
Debugger: Rider can be set as a JIT debugger on Windows.

New in Rider 2018.3.4 (Mar 6, 2019)

New in Rider 2018.3 (Dec 19, 2018)

Code Vision: try this new way of seeing useful information about your code right in the code editor. Usages, version control info, derived types, extension methods, and exposing APIs are now in plain sight, with no additional actions required!
Remote Debugging via SSH: need to debug an application on a remote machine? No problem, just call the action “Attach to Remote Process…” to attach to the process. .NET Full/Core, and Mono debuggers are supported.
Rename Project refactoring: no more manual renaming of all usages of a project. Call up this refactoring and you’ll be done before you know it.
Assembly Explorer now allows opening multiple assemblies, as well as traversing and exploring all open assemblies.
Zero-latency typing: even for smart typing assists that perform time-consuming tasks like reformatting code, Rider’s UI doesn’t get blocked and the editor stays smooth and responsive.
Launch Settings: support for launchSettings.json files is now available in ASP.NET Core projects.
We’ve redesigned the Search Everywhere popup and the Plugins pages in Settings.
Updated C# and VB.NET support includes improved C# 7 deconstruction support and language support for VB.NET 15.3 and 15.5.
An integrated performance profiler. Note that for now, the profiling features are only available on Windows.
Type Hierarchy tool window: explore the inheritance hierarchy of types via Navigate | Type Hierarchy.
Web development: from improved Angular support and better auto imports in JavaScript to debugging Node.js worker threads and support for TypeScript 3.1 features, and more.
VCS support: manage GitHub Pull Requests right in the IDE, and work with Git Submodules.
Android Development: lots of embedded tools and features from Android Studio are available, including a WYSIWYG designer, code completion for AXML/Android Manifest files, SDK/AVD Manager, and more.
Inline parameter name hints for C# and VB.NET are here.
Updated NuGet support offers Find this type on nuget.org, a new quick-fix to Install missing .NET Core Adapter, and better and faster search in the NuGet window.
New language injections: SQL and other IntelliJ IDEA language injections now cover C# string literals.
Updated F# support; brand new F# lexers work for both IntelliJ IDEA’s frontend and ReSharper’s backend; Rename refactoring works for local symbols; and there are new grouping types in Find Usages.
Updated Database support delivers one more NoSQL database, Cassandra, and several improvements in SQL code completion.
Unity support updated: New inspections keep a tight watch on the performance of your Unity code; collect method and class usages from scene/prefab/asset files; Unity Explorer is now shown on Linux; and more!
Other features: there’s a brand new engine under the hood of the expression evaluator; Ctrl+Click on an entity declaration now shows the usages; the refactorings Move to Resource, Inline Resource, Move Resource, and Rename Resource are now available; you can now ‘Build only this project without dependencies‘; and, as we love saying, there’s even more!

New in Rider 2018.3 Build 183.5025.20 EAP9 (Dec 13, 2018)

New in Rider 2018.3 Build 183.4704.20 EAP7 (Nov 28, 2018)

New in Rider 2018.3 Build 183.4560.28 EAP6 (Nov 21, 2018)

Debugger:
Remote debugging via SSH: "Attach to Remote Process..." is available, as is support for .NET Full/Core and Mono debuggers.
A brand new engine is now working under the hood of the expression evaluator. It supports most features of the latest stable C# versions.
You can see values in their hexadecimal representation.
Android Development:
WYSIWYG designer and code completion for AXML/Android Manifest files.
Logcat command-line tool and Android Profiler.
SDK/AVD Manager, Device File Explorer, and Layout inspector.
Code Editor:
We’ve added parameter name hints right to the code editor to increase the readability of C# and VB.NET code.
Code Analysis:
Syntax highlighting, inspections, and other analyses in .editorconfig files.
Rider can autodetect the naming style you use in the code.
What used to be a single "Method, Property, Event" naming style is now three separate ones: "Method", "Property", and "Event".
A lot of code inspections, quick-fixes, and context actions for parameterized NUnit tests.
New quick-fix, "Allow unsafe code in this project".
Project Model:
In the Properties dialog, a new NuGet page is available for a project where you can file all the information you need to pack the project to a NuGet package.
Actions:
A new action, 'Build only this project without dependencies', can be handy if you have a custom build system.
A “Copy Reference” action was added to copy a fully qualified name of a code entity (Edit | Copy Reference).
Unity support:
Rider now collects method and class usages from scene, prefab, and asset files.
We’ve refined the notification about auto-saving the document.
If the Unity Editor plugin has been moved to another location, Rider takes this change into account while updating the plugin.
New context actions are available: Move an expression to Start, Move an expression to Awake, and Move an expression outside the loop for.
New “performance-related” highlighting is available for methods that are invoked in each frame.
The API was updated to include Unity 2018.3.0b9.
A solid set of bug-fixes.

New in Rider 2018.3 Build 183.4139.168 EAP5 (Nov 7, 2018)

New in Rider 2018.3 Build 183.3226.312 EAP2 (Oct 16, 2018)

New in Rider 2018.3 Build 183.3226.206 EAP1 (Oct 8, 2018)

We’ve added the long-awaited refactoring Rename project. No more manual renaming of all usages of a project – just use a few clicks and that’s it.
Another long-awaited feature, which exists in ReSharper but was missing in Rider: Assembly Explorer. It allows opening multiple assemblies, as well as traversing and exploring all open assemblies. It is available as a view in the Explorer window in addition to the Solution and the File System views.
We’ve refactored the loading assemblies stage and this optimization has sped up solution loading.
Rider has a newly redesigned Search Everywhere popup and Plugins pages in Preferences/Settings.
You can explore the inheritance hierarchy of types via Navigate | Type Hierarchy.
NuGet support gets more love:
Support for NuGet servers that use NTLM/Windows authentication (on Windows).
Find this type on nuget.org feature, which some of you might be familiar with if you use ReSharper, has been added to the AltEnter menu for unresolved symbols.
A new quick-fix, Install missing .NET Core Adapter, is available in unit tests files in case you missed a required package.
Better and faster packages search in the NuGet window based on NuGet Completion Service.
The NuGet window shows more NuGet Folders based on NuGet.config files.
Improved Angular support.
Multiline Todos support in JavaScript and TypeScript.
The Open in Rider action is available in the context menu of File Explorer. It works only on Windows and only if Rider was installed via the installer (not via Toolbox App).
Tab/Shift+Tab indentation behavior is now the same as that in Visual Studio. Pressing Tab or ShiftTab aligns the code to the closest indentation (when indent is set in spaces).
XSLT Debugger has been added.
Unity support has had another huge update:
A bunch of new inspections and appropriate quick-fixes to improve your Unity code
The spell checker no longer runs on .asmdef files.
Ignored tests are marked with the correct result status.
Unity Explorer is now shown on Linux.
An Editor EntryPoint C# script file template has been added.
Double-clicking a process item in the Attach to Unity Process list will now close the dialog and attach to that process.
Unity Component Data entities are now shown in the Variables window in the list of object’s fields/properties while debugging.
Duplicates are removed from code completion.
And lots more (see the whole list of fixes and improvements)!
P.S.: We would like to say thank you to Jurjen Biewenga for his contribution to the “Unity Support” plugin (PR 823, 822, 772).

New in Rider 2018.2.3 (Sep 14, 2018)

New in Rider 2018.2.2 (Sep 12, 2018)

New in Rider 2018.2 Build 182.4231.193 (Aug 24, 2018)

This release comes with a solid set of bug-fixes, and a bunch of new features and improvements which are highlighted in the list below:
Debugger: call stacks are now displayed in a more understandable way, thread-specific breakpoints have been introduced, and inspecting and expanding unsafe pointers is now supported.
Docker support has reached the debugger: It is now possible to debug ASP.NET Core apps in a local (Linux) Docker container: inspecting variables, the stack frames, threads, as well as stepping through your own or decompiled third-party code.
Publishing: We have added two new run configurations: Publish to IIS and Publish to custom server. Currently, only publishing of ASP.NET Core Web projects is supported.
Code completion: we now use ReSharper’s statistics-based scoring algorithm to provide more relevant items higher in the code completion popup. Moreover, code completion now works in scratch files, debugger watches, and the C# Interactive tool window.
Solution Explorer redesign: a new toolbar with Show all files, Autoscroll to/from source and File Nesting Settings icons. The Solution Explorer now includes Scratches view, handles nested files better, and gets the File System and the Folders always on top modes.
MacBook Touch Bar support for the IDE, new icons, dark window headers on Mac.
dotCover comes to Rider: Unit test coverage and continuous testing are now available out of the box. It is currently only available on Windows for now but it is the first step towards dotCover integration on all supported platforms.
Integrated spell checking: ReSpeller plugin was finally merged to ReSharper and now it comes out of the box. Other updates included from ReSharper 2018.2: C# 7.3 support, initial Blazor support, and more!
Templates editor: You can now manage, add, and modify Live/Surround/File Templates right from the Rider settings.
Frontend development features: TypeScript 2.9/3.0 support, improved support for React, Angular, and Vue.js.
VCS update: Easier resolve of merge conflicts, enhancements in VCS Log tab, favorite branches in Branch filter, Browse repository at revision action, and more!
Unity support: support for .asmdef and csc.rsp files, an option to disable Unity Reload Assembles in Play mode, Unity players in the Attach to Unity Process list, a fix for the invalid warning for this == null in Unity types, improved support for debugging remote players, Packages and Scratches nodes in Unity Explorer, and more!
F# support: File Templates now work inside F# projects, F# 4.5 features like Span support and the match! keyword come to FSharp.Compiler.Service.
C# Interactive: a new Reference in the C# Interactive context menu is available to reference the selected assembly or project in C# Interactive tool window, and the debugger can be attached to C# Interactive tool window.
Unit Testing: Discovering and running tests in SDK-styled projects is now faster, a new lock/unlock icon has been added to the Unit Test Session toolbar, Unit Testing related actions have been added into the default keymap, and more.
NuGet support: We added a filter, format customization, and advanced diagnostics to NuGet logs, support for AutoReferenced packages and TLS-1.2-only NuGet feeds.
Roslyn Analyzers: This release comes with initial support for .ruleset files and stylecop.json settings are now respected.
Other features: Generate GUID, “Custom tools”, the Re-run action on the Find Usages tab, and Runtime arguments for Run/Debug Configuration are just some of the new cutting-edge features we have included.

New in Rider 2018.2 Build 182.4129.120 EAP 7 (Aug 13, 2018)

New in Rider 2018.2 Build 182.3944.254 EAP (Aug 6, 2018)

New in Rider 2018.1.4 Build 181.5550.7 (Aug 2, 2018)

New in Rider 2018.2 Build 182.3894.140 EAP (Jul 27, 2018)

New in Rider 2018.2 Build 182.3797.86 EAP (Jul 20, 2018)

New in Rider 2018.2 Build 182.3458.490 EAP 2 (Jul 9, 2018)

New in Rider 2018.1.3 Build 181.4952.311 (Jul 6, 2018)

New in Rider 2018.2 EAP1 Build 182.3458.147 (Jul 2, 2018)

New in Rider 2018.1.2 Build 181.4952.297 (May 31, 2018)

New in Rider 2018.1.1 Build 181.4952.276 (May 28, 2018)

Among the many bug fixes, you will find some new features as well. Here are some highlights of this build we have prepared for you:
RIDER-15898 — Support for .NET Core 2.1 project templates.
RIDER-15514 — Fixed deployment of Xamarin projects.
Fixed issues with NuGet actions which require HTTP/HTTPS requests (e.g., Restore, Search, and so on).
RIDER-10078 — Fixed invocation of a method with a params argument while debugging.
RIDER-15320 — Fixed drag-and-drop to move folders in C# and VB projects.
RIDER-9174 — Fixed the behavior of Start New Line Before Current.
RIDER-476 — The console on the Run tab displays output with non-ASCII characters correctly.
RIDER-13576 — Step Over works as expected and moves to the next statement in the block.
RIDER-15197, RIDER-15397 — Fixed several issues around XAML Preview.
Here is a bunch of small fixes that should make your experience with Unity even more enjoyable:
The Step and Refresh actions for Unity projects work correctly.
Fixed multiple problems with Unity Test Runner which caused the pending or inconclusive status of tests.
535 — Auto Refresh now works more gently, actuating after refactoring and not bothering you unnecessarily.
The Database tool window is back for Unity projects. It provides full access to functions for working with databases and DDL data sources.
Optimized UI for Unity projects has got a setting to show-hide Solution Configuration in Rider toolbar Settings | Languages & Frameworks | Unity Engine | Hide Solution Configuration. (This menu element is hidden by default.)
RIDER-15909 — Rider is now responsive while the project is running and has a huge number of Unity logs.
RIDER-15934, #523, #562 — Fixed issues with .csproj file generation which caused a variety of bugs for Unity 2017.4.x versions.
561 — Improved search on Linux for Rider installed via JetBrains Toolbox App and via the classic installer.
556 — Fixed bug in detecting corresponding Unity editor instances to Attach Debugger when multiple Unity instances are running.
F# improvements:
RIDER-7148 — Debug in F# Interactive (only on Windows for now) is available under Tools | F# Interactive | Debug in F# Interactive.
8 — Added inline debugger values (thanks to our contributors!).
Improved memory usage and performance in projects with multiple target frameworks (many thanks to our other contributors!).
120+ issues were also fixed.

New in Rider 2018.1.1 Build 181.4952.203 EAP (May 18, 2018)

New in Rider 2018.1 Build 181.4379.1191 (Apr 19, 2018)

Roslyn analyzers: in addition to Rider’s own 2400 code inspections to help you detect errors and code smells in all supported languages, Rider now detects Roslyn analyzers and highlights them in the code editor.
Entity Framework support: enable, add and get migrations, and update database with UI-based Entity Framework 6.x support in .NET Framework projects.
Deeper integration with Unity: this update takes Unity integration to a whole new level. Now you don’t even have to leave Rider to control Play mode, explore Unity logs, or run Unity-specific tests.
XAML preview: WPF application developers can now preview UI as they make changes to XAML code.
Memory view in debugger: Rider allows you to look under the hood of any application and explore the managed heap while debugging.
Exception pop-up, which shows summary of exceptions that occur while debugging and allows you to quickly navigate through the highlighted stack traces.
Even more debugger improvements including Smart Step combined with Jump to Statement, symbol server support, Attach UI that contains process info and suggests elevating permissions if necessary, faster attaching to local processes, and more.
NuGet updates: improved support for authenticating against private NuGet feeds in several ways, and initial support for bulk operations.
JetBrains redistributable of MSBuild to develop and build full .NET Framework applications without a Visual Studio or Visual Studio Build Tools installation on Windows.
Better understanding of projects and solutions: full support for Web References and Web Site projects, and more.
F# support brings file ordering and improves F# scripting in many ways, including code completion, highlighting and navigation.
Changes from ReSharper 2018.1: full understanding of C# 7.2 and improved support for previous C# versions, inspections and quick-fixes for formatting problems.
More frontend features: support for the latest TypeScript 2.7 features, handy updates for configuring package managers, improved Rename refactoring, better navigation in HTML files, and refined code completion.
Changes from IntelliJ IDEA 2018.1: support for multiple Docker Compose files, regex replacement preview in the Replace in Path dialog, a new lightweight documentation popup, and more.
VCS improvements: partial Git commits, new Group by icon to group local changes, and more.
More changes: a new MSTest setting dialog and customization settings for C# Interactive, Ideolog plugin available for download from the IDE, and more.

New in Rider 2018.1 Build 181.4379.974 EAP8 (Apr 11, 2018)

New in Rider 2018.1 Build 181.4379.788 EAP7 (Apr 10, 2018)

New in Rider 2018.1 Build 181.4379.538 EAP 6 (Apr 4, 2018)

New in Rider 2018.1 Build 181.4379.360 EAP 5 (Mar 31, 2018)

New in Rider 2018.1 Build 181.4379.104 EAP 4 (Mar 27, 2018)

New in Rider 2018.1 Build 181.4035.533 EAP 3 (Mar 19, 2018)

New in Rider 2018.1 Build 181.4035.96 EAP 2 (Mar 7, 2018)

New in Rider 2018.1 Build 181.3782.222 EAP (Feb 27, 2018)

New in Rider 2017.3.1 Build 173.3994.2442 (Feb 6, 2018)

New in Rider 2017.3 Build 173.3994.1125 (Dec 28, 2017)

Debugging third-party code: you can now step through and set breakpoints in assemblies that Rider decompiles on-the-fly.
Smart Step Into: when you debug method chains or nested method calls, choose a particular call to step into, while stepping over all other calls in a line.
Return values in locals: function return values are displayed in the Variables view, which is useful when the result of a method call is not stored in a local variable.
More debugger improvements: debugger actions are available in the Alt+Enter menu, you can now drag-and-drop the execution pointer to an earlier or later location in code, and callers of async functions are now displayed in the Frames view.
New project wizard: Rider introduces a different grouping of project templates, allows creating repositories along with new solutions, and streamlines installing additional project templates.
Unit testing improvements, including new actions, local shortcuts, and more reliable filtering in the unit testing view.
C# Interactive tool window to execute C# statements without having to wait for compilation.
Unity support improvements, such as new context actions and code inspections, improved usability of code completion, and syntax highlighting in compute shaders.
Config transformations to modify settings in Web.config and App.config when packaging applications.
Reworked formatter: Rider learns to align code in columns, apply other new code styles, as well as disable or enable formatting for selected blocks of code.
More changes from ReSharper 2017.3, including a C# 7 ready Extract Method refactoring, more C# typing assists, and improved support for VB.NET.
More frontend features: notably, Rider bundles more IntelliJ platform plugins for frontend development (such as TSLint, CoffeeScript, Karma and Stylus).
Changes from IntelliJ IDEA 2017.3, including a new editor-based REST client, version control and database tooling updates, and a reworked Docker configuration system.
Performance improvements on loading and reloading projects, in debugger and code completion.
More changes related to NuGet and MSBuild support, keymaps, settings, and Find Usages.

New in Rider 2017.3 Build 173.3994.932 EAP 4 (Dec 20, 2017)

New in Rider 2017.3 Build 173.3994.576 EAP 3 (Dec 13, 2017)

New in Rider 2017.3 Build 173.3801.283 EAP 2 (Dec 4, 2017)

New in Rider 2017.3 Build 173.3801.283 EAP 1 (Nov 24, 2017)

New in Rider 2017.2.1 Build 172.4144.1873 (Nov 14, 2017)

New in Rider 2017.2 Build 172.4144.1459 (Oct 13, 2017)

New in Rider 2017.2 Build 172.4144.808 EAP 3 (Sep 30, 2017)

New in Rider 2017.2 Build 172.4144.486 EAP 2 (Sep 23, 2017)

New in Rider 2017.2 Build 171.4456.3271 EAP 1 (Sep 5, 2017)

New in Rider 2017.1.1 Build 171.4456.2813 (Aug 28, 2017)

New in Rider 1.0 Build 171.4456.1432 RC (Jul 14, 2017)

New in Rider 1.0 Build 24 EAP (Jun 30, 2017)

New in Rider 1.0 Build 23 EAP (Jun 17, 2017)

New in Rider 1.0 Build 22 EAP (May 19, 2017)

New in Rider 1.0 Build 21 EAP (Apr 28, 2017)

New in Rider 1.0 Build 20 EAP (Apr 14, 2017)

New in Rider 1.0 Build 19 EAP (Mar 23, 2017)

New in Rider 1.0 Build 18 EAP (Feb 24, 2017)

New in Rider 1.0 Build 17 EAP (Feb 16, 2017)

New in Rider 1.0 Build 16 EAP (Jan 18, 2017)

New in Rider 1.0 Build 15 EAP (Dec 21, 2016)

New in Rider 1.0 Build 14 EAP (Dec 5, 2016)