What’s New in Rider

Rider 2022.3 offers support for the .NET 7 SDK, including the latest features from C# 11. This version boasts significant performance improvements, with a particular focus on startup time and the ability to run Rider on WSL 2 (Windows Subsystem for Linux 2) through remote development. We’ve also introduced several significant UX/UI changes, such as the ability to dock tool windows for multi-monitor setups. Last but not least, this release deepens the integration with the Unity and Unreal editors.



We’ve made several changes to increase Rider’s startup speed and reduce the time it takes to open a solution and get to work:

  • The Rider installer is now able to add executable files to the Windows Defender exclusion list, providing a significant startup speed boost.
  • Rider can now load a solution file and build its project tree instantly without having to wait for the backend to initialize.
  • We’ve removed all loading bars 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.
  • We’ve introduced a new C# parser, which provides basic syntax highlighting during startup and the full experience once Rider is started and your solution is loaded completely.
  • We’ve also introduced several improvements to Rider’s backend performance. We’ve enabled server garbage collection (GC) to get better memory throughput for the backend process. Additionally, we’ve updated the runtime for the Rider backend language service from .NET 6 to the latest .NET 7 version. And last but not least, we now run design-time builds in parallel when projects have no interdependencies. Combined, these changes make loading a solution with many projects noticeably faster.

Learn more about Rider’s performance improvements here.

WSL 2 support

Rider now supports WSL 2 (Windows Subsystem for Linux 2) through the IDE’s remote development functionality. This means you can use Rider on a WSL 2 instance to browse your solutions and sources as well as to build, debug, and run apps as if they were stored locally.

A simple setup process can be initiated right from Rider’s Welcome screen. The UI will be delivered via the remote development functionality, meaning there’s no need for WSLg and a local RemoteDev client will automatically be installed. For more information, please refer to the remote development documentation.


Docking tool windows

The highly requested option to dock tool windows to floating editor tabs is finally here! To make arranging your working space and interacting with Rider on multiple monitors more convenient, we’ve implemented the option to drag tool windows out of the main window and dock them to floating editor tabs.

Updated Search Everywhere

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).

New Attach to process dialog

We’ve introduced a new Attach to process dialog to improve your user experience, particularly when attaching to a process via SSH. Our goal is to help you find and select the correct process faster, as well as make the IDE remember the chosen debugger.

Reworked paste action

Reworked paste action

We’ve improved the editing experience by reworking the behavior of the paste action (⌘V / Ctrl+V). Now when you copy (⌘C / Ctrl+C) or cut (⌘X / Ctrl+X) a line without any code selected, the paste action will add the contents of the clipboard above the current line, not at your caret as it did in previous versions.

Paste JSON as Classes

Paste JSON as Classes

There’s now an Edit | Paste Special: JSON as Classes action that lets you “smart paste” objects. For example, if you were to copy a JSON and paste it using this action, it would auto-generate C# classes based on that JSON.

New UI Early Preview

We invite you to switch to the new UI for IntelliJ-based IDEs in Preferences/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.


We’re also continuing to implement small optimizations for Rider’s UX and 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.
  • 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 when you switch.

NET 7 SDK support

NET 7 SDK Support

Rider 2022.3 officially provides support for the .NET 7 SDK including:

  • Updated project templates.
  • NuGet Central Package Management.
  • Support for ASP.NET minimal API route groups in the Endpoints tool window.
  • New C# 11 features, including file-local types, UTF-8 literals, ref fields, and scoped keyword.
  • The ability to create, run, and debug projects targeting the new SDK.

C# support

C# 11

UTF-8 literals

UTF-8 literals

We’ve added basic support for UTF-8 literals. The code analysis now suggests using a u8 suffix for a literal instead of the System.Text.Encoding.UTF8.GetBytes() method or a byte array with proper UTF8 symbols. There is also a set of compiler warnings and errors for UTF-8 literals.

File-local types

Basic support for file-local types includes understanding of the new syntax, a file accessibility modifier for types, and compiler warnings and errors with corresponding quick-fixes, like Move class to outer scope when the file modifier is specified for a nested class. There is also a useful context action to convert a general type to a file one.

Raw strings

Raw strings

Rider can now convert regular and verbatim strings into their raw counterparts. This also means that numerous existing features for strings are now available for raw strings.

List pattern suggestions

List pattern suggestions

In this release, we’ve introduced suggestions to use the new C# 11 list pattern syntax (instead of conventional collection length checks with subsequent indexer access expression) to check the corresponding items of the collection.

Static virtual members

Starting from C# 11, you can use abstract and virtual modifiers for static members in interfaces and use such members in generic code with type parameters constrained by this interface. Rider has been updated to handle polymorphic static members the same way ordinary polymorphic members are handled:

  • Inheritance marks on the gutter.
  • Navigation to implementing/super members.
  • Generation of missing implementations.
  • Code completion suggestions after the override keyword also include interface members, so now you can easily implement abstract or virtual static members.
Unsigned right shift (>>>) operator

Unsigned right shift (>>>) operator

Rider now recognizes the cumbersome code pattern that C# developers have to write to perform an unsigned right shift for signed data types and suggests using the unsigned right shift (>>>) operator in C# 11 instead.

Pattern matching over spans

Pattern matching over spans

If you parse Spans of characters you probably use the MemoryExtensions.SequenceEqual method a lot. C# 11 introduces a shorthand for this kind of check. You can now simply pattern-match Spans of characters against string literals with is or switch expressions.

Rider now suggests using is or switch expressions instead of lots of if statements.

ref fields and scoped keyword

Starting from C#11, you are allowed to declare ref fields inside ref structs. Rider supports this new syntax rule, provides all compiler errors and warnings, shows a ref keyword in the code completion, and allows such fields to be initialized in a constructor.

Rider is also aware of a new scoped keyword which you can use on by-ref or ref struct arguments and local variables. The support includes correct parsing of the new syntax, the scoped keyword in code completion, and preservation of the scoped keyword when generating method overrides. It also verifies the compatibility of scoped modifiers and offers quick fixes for mismatched scoped parameters on overrides, interface implementations, and delegate conversions.

C# 11 and .NET 7 also introduced changes in the language's ref safety rules. The changes govern what operations are available for by-ref and ref struct variables in order to provide ref safety in managed code with the introduction of ref fields. Rider is aware of the changes and will help you find the parts of your project that need to be updated and annotated with the new scoped keyword to accommodate the changes when migrating to C# 11 or .NET 7.

Language injections

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 using either string interpolation or concatenation with arbitrary expressions. 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.

General C# updates

Global imports gutter mark

Global imports gutter mark

There is a new gutter mark icon to notify users about implicit namespace imports in C# and Razor files.

By hitting Alt+Enter on the corresponding line, you can observe the full list of implicit imports and information about the source file where the corresponding global using directives are located. If you select a particular imported namespace, Rider can navigate you to where it's declared, including navigation to <Using Include="Some.NameSpace" /> tags in the .csproj project file.

Global imports gutter mark

Rider also presents global imports from _Imports.razor and allows navigation to corresponding import definitions.

Machine Learning-Assisted Completion for C#

Machine learning-assisted completion for C#

In an effort to help you streamline and speed up your development process, we’re introducing ML-assisted element sorting for code completion options in C#.

To enhance your experience using this feature, there are two options you can enable in Settings/Preferences | Editor | General | Code Completion | Machine Learning-assisted Completion:

  • Mark position changes in the completion popup
  • Mark the most relevant item in completion popup
Format string completion

Format string completion

With the addition of Int128 and UInt128 numeric types in .NET 7, we've updated our code completion format specifier suggestions.

We’ve also added missing support for DateOnly and TimeOnly date/time types from .NET 6, as well as the Half half-precision floating point numeric type introduced in .NET 5.

Trivial patterns to expressions

Trivial patterns to expressions

Sometimes after refactoring, your pattern-matching expressions may turn into trivial recursive patterns. At this point it may not be worthwhile to use the recursive pattern syntax at all, so Rider now offers the action of rewriting patterns into simpler expressions while preserving the original pattern-matching semantics.

Code completion hints for a void expression

Code completion hints for a void expression

Sometimes when you type after an invocation, you see hardly any meaningful suggestions. This can happen if the invocation resulted in no value being produced when the void-returning method was invoked. Usually it takes a few IDE actions to realize that (going back and navigating to the method declaration, or hovering the mouse over the invocation). In this release we’ve introduced the void hint item over this type of void-returning invocation to give you immediate feedback about the type resulting from the invocation. Accepting this void item will add a semicolon after the invocation if the semicolon is missing.

Web development



Rider 2022.3 introduces Hot Reload for Blazor Server Apps. When you modify source code in your Blazor Server app while the app is running, Rider will ask you whether you want to apply this change to the running app without restarting it. Look out for the yellow Sources are modified notification bar at the top of the text editor. If you accept the change, your app will be updated on the fly and you can continue working with the updated app.

Welcome screen

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.



We continue to improve our Endpoints support and the Endpoints Viewer. The viewer now correctly recognizes and collects endpoints for ASP.NET Core 7 minimal API route groups. This means that you can search, navigate through and use smart code completion on the endpoints declared with MapGroup() API, in addition to the features that were already available.

.NET User Secrets

.NET User Secrets

The .NET User Secrets action has been added for ASP.NET projects.

JavaScript/TypeScript web projects

JavaScript/TypeScript web projects

Rider now auto-generates an npm run configuration for JavaScript and TypeScript web projects (.esproj) referenced by the solution (.sln).

Code Vision for JavaScript and TypeScript

Code Vision for JavaScript and TypeScript

Code Vision inlay hints now also work for JavaScript and TypeScript. These hints will make it easier to track the usages of various classes, methods, type aliases, and interfaces in your code.

CSS support

CSS support

The IDE now understands the @supports at-rule, which associates a block of statements with an @supports condition. This build also includes support for viewport units, range media queries, container queries, @layer (Cascade layers), and color modification functions.

Updates for Angular

Updates for Angular

We’ve added support for type narrowing in Angular templates, which will provide more precise type information and better code completion suggestions.

Additionally, Rider now excludes the .angular cache folder from global searches to help provide better search results.

Game Development

Unity support

Unity support in Rider is getting another great update, with some new features, improvements to existing functionality, and a few fixes, too.

We’ve added support for Unity’s new Input System package. Rider will recognize when methods are used as event handlers for inputs and will no longer show them as unused. Find Usages also works on these methods, showing where they’re used in code or in the .inputactions file.

It’s great to be able to load game resources at runtime, and Rider can now help ensure you’re using the correct path in Resources.Load methods. It displays code completion as you type and highlights any unknown resources with a warning.

Rider has offered completion and verification of tag names for several releases, and version 2022.3 adds new support for the GameObject.FindWithTag group of methods. It provides code completion while you type and warns you if you try to use a tag that doesn’t exist in the project.

In Unity projects, it’s very important to keep meta files in sync with files and folders. Rider 2022.3 will warn you if you’re trying to commit a meta file for an empty folder into source control. Even more usefully, if the Unity editor is open, Rider will warn you if there are any unsaved scenes or assets, helping you make sure you don’t miss changes when you commit.

Of course, there are plenty of smaller improvements and fixes, too. We’ve reduced the time it takes to load exceptionally large projects, added a notification that appears if you try to edit a read only package file, and improved Find Usages so it can be used for methods in nested prefabs and arrays of event handlers.

In DOTS support, Rider now knows not to mark classes implementing IBaker or IAspect as unused.

You can disable the naming inspections for serialized fields and have them treated just like normal fields, and links to online documentation are now pointing to the right places.

We’d also like to thank Unity for providing a fix to help debug players on Nintendo Switch.

Unreal Engine support

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 will be updated automatically.

It is now much harder to break your game accidentally by renaming things!

Updated Code Vision for Blueprints

Rider 2022.3 introduces a new Blueprints-specific Code Vision metric. You can now quickly check how many Blueprints use the BlueprintCallable function and get the list of all usages from the Code Vision context menu.

Generate GUID

The Generate GUID tool now supports the Unreal Engine GUID format. Whenever you need to quickly generate a GUID, just choose Tools | Generate GUID... from the menu, and the preferred hexadecimal format will be pre-selected.


The auto-import on completion feature can save you tons of time. But if it adds an incorrect #include directive, the problem may be tricky to detect. We’ve worked hard to polish this functionality and make sure it doesn’t suggest unwanted entities from system headers in auto-import. 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.

UnrealBuildTool Log

We've improved the presentation of UnrealBuildTool logs. To make sure you do not miss any warnings about or errors involving project configurations, the log panel now includes timestamps and keeps logs from the previous runs of UnrealBuildTool.

Native .uproject support

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 respects additional source locations specified in .project, specifically AdditionalRootDirectories and AdditionalPluginDirectories.
  • It also supports custom programs placed in the game location and generates all the programs' project files correctly.
  • Rider now supports modules with several .Build.cs files for platform-specific modules.
  • Completion and inspections in .uplugin and .uproject files are now supported when using the .uproject project model.
  • Run configurations are now auto-generated for C++ programs whenever the .uproject model is used.

Attach to Unreal Editor

We’ve implemented an Attach to Unreal Editor action for Unreal Engine projects. It allows you to quickly attach to an Unreal Engine process instead of having to manually search for the right one. Currently, you can only attach to the same process that UnrealLink is connected to, meaning the project running in Unreal Editor should correspond to the one you’re working on in Rider. We’re working on improving this workflow in future releases.

ARM64 support Early Preview

Early preview for ARM64 support

Rider 2022.3 can now run on Windows and Linux ARM64. All of the basic development workflows are supported, including running and debugging your .NET applications and running unit tests. However, while we continue working and running tests to make sure Rider works smoothly with ARM64 processors, we’d like you to be aware of the following limitations:

  • Currently, there are no plans to support Unreal Engine development on Windows ARM64, as Epic Games does not support Unreal Engine for this architecture.
  • Support for Unreal Engine for Linux ARM64 is still in development.
  • Basic support is available for Visual C++ projects on Windows ARM64, though it still does not cover debugging natively built applications. You can follow the progress on this issue here.


Memory Profiling on macOS and Linux dotUltimate

In addition to Windows, dotMemory is now available for JetBrains Rider on Linux and macOS. Two new profiling modes are available in the Run widget and in the Run | Switch profiler configuration menu – Memory (sampled allocations) and Memory (full allocations). You can learn more about the differences between these in dotMemory’s Help.

You can attach the profiler to a running process from the Run menu and watch the Timeline Graph unroll in real time. Select an interval to open the Memory Allocations view, which is the same as in dotMemory Standalone. It lets you analyze allocated objects and the allocation call tree for a specific time frame.

Unfortunately, it is not yet possible to collect memory snapshots in this version.

Dynamic Program Analysis

Dynamic Program Analysis

Dynamic Program Analysis (DPA) has new inspections that let you find 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.

dotCover dotUltimate

Dynamic Program Analysis

Easier navigation to tests

We’ve added the Show Covering Tests action to the dotCover context menus in both the code editor and Unit Test Coverage window. This action shows a popup with all covering tests together in the same place. The popup also lets you create a new coverage session.

Faster shadow copying

Now dotCover copies only the assemblies and symbol files required for continuous testing in JetBrains Rider. This improves dotCover’s overall performance, especially on large projects, as it no longer needs to copy the entire working directory. If necessary, you can adjust the shadow-copy file filter in the dotCover settings.

Improved Unity support

Previously, to analyze the coverage of Unity tests you had to restart Unity with coverage support enabled. Beginning with this release, restarting Unity is no longer required and test coverage is supported out of the box.

NuGet support

Central Package Management (also known as the Directory.Packages.props file) is an evolving feature of the .NET technology stack, and as it improves, it should make managing solutions easier moving forward. With the addition of CPM in Rider, developers should have more control over their dependencies.

You can learn all about Central Package Management, including tips and caveats, in this blog post.

Whenever you’re using open-source NuGet packages in your solutions, there’s a risk of exposing your project to security vulnerabilities. To mitigate this risk, we're introducing vulnerable dependency detection in Rider. The IDE will alert you to vulnerable dependencies associated with the use of NuGet packages by providing notification popups, which can be further investigated in the Security section of the Problems view. Information about vulnerable dependencies associated with packages included in the solution can also be found in the NuGet Package Management window by selecting a particular package.

We’ve also improved the scrolling experience inside the Packages list in the NuGet tool window.

F# support

Rider 2022.3 brings support for F# 7, provides a variety of fixes for small issues, and adds some quality of life improvements.

Better XML documentation support

Better XML documentation support

Typing < inside a comment will now add a documentation template. Additionally, syntax highlighting and code completion make editing documentation comments much easier.

Code completion for records

Code completion for records

A new code completion rule simplifies typing record expressions, as it emphasizes fields from the inferred record type, hides any that are already used, and fixes various cases where no suggestions would be shown previously.

Signature files

Signature files

We’ve added new quick-fixes, Update parameter name and Update record field, which update signature files, making it easier to use them when changing code. A huge thanks goes to Florian Verdonck for implementing them!

These were just the highlights of the F# support improvements. You can find the full list of F# features included in the 2022.3 release here.

Database support

Here are some highlights of Rider 2022.3’s new features for working with databases:

  • Quick filter – You can filter results and hide non-matching objects when using quick search.
  • Pattern-based schema filtering – You can now choose databases or schemas for introspection based on regular expression patterns.
  • Formats for date/time fields – You can customize how fields of date and time types will be displayed in the data editor.
  • Multiple edits in the Modify window – You can now edit several objects at a time.

Learn more: What's New in DataGrip 2022.3


IL Viewer

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.

Code highlighting

Code highlighting

Code highlights and squiggles in Rider 2022.3 received an overhaul. Due to a difference in internal logic, Rider used to come into conflict with Microsoft Roslyn’s code style analyzers, causing it to display overlapping highlighting, draw the same highlight in different spots, or double the squiggles. The differences in logic behind the majority of such instances have now been resolved, and for the rare outlier cases, there are errors with clear suggestions on how to resolve the conflict.

Additionally, Rider will now show Roslyn Analyzer ID and URL Reference in a Quick Documentation tooltip for inspections produced by Roslyn Analyzers.

C++ formatting

C++ formatting

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.


We’ve drastically improved the debugger’s performance with the Allow property evaluations and other implicit function calls option disabled. It can now evaluate many more expressions in no-side-effects mode for .NET, .NET Framework, and .NET Core projects.

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.


  • We’ve enabled default server garbage collection for .NET Core 17+ MSBuilds.
  • Rider can now detect when the 32-bit version of MSBuild is out of memory and switch to using the 64-bit version from Visual Studio.


Solution Wide Analysis and the Find usages command have been refactored. According to internal tests, their performance is on average 20-40% faster than before.