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:
Learn more about Rider’s performance improvements here.
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.
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.
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).
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.
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.
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.
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:
File | New at the top menu has been renamed
File | New Solution to better reflect the actual action it will execute.
Rider 2022.3 officially provides support for the .NET 7 SDK including:
We’ve added basic support for
UTF-8 literals. The code analysis now suggests
u8 suffix for a literal instead of the
System.Text.Encoding.UTF8.GetBytes() method or a byte array with
UTF8 symbols. There is also a set of compiler warnings and errors
for UTF-8 literals.
Basic support for file-local types includes understanding of the new syntax,
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.
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.
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.
Starting from C# 11, you can use
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
override keyword also include
interface members, so now you can easily implement abstract or
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
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
Rider now suggests using
instead of lots of
ref fields and
Starting from C#11, you are allowed to declare
ref fields inside
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 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
rules. The changes govern what operations are available for by-
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.
This build brings a number of language injection improvements:
We've added support for language injections using the
(from .NET 7) and
[LanguageInjection] (from JetBrains.Annotations)
attributes, as well as support for the
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.
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.
Rider also presents global imports from
_Imports.razor and allows
navigation to corresponding import definitions.
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
Settings/Preferences | Editor | General | Code Completion | Machine
With the addition of
UInt128 numeric types in
.NET 7, we've updated our code completion format specifier suggestions.
We’ve also added missing support for
types from .NET 6, as well as the
Half half-precision floating point
numeric type introduced in .NET 5.
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.
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
void hint item over this type of
void-returning invocation to give
you immediate feedback about the type resulting from the invocation. Accepting
void item will add a semicolon after the invocation if the semicolon
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.
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
IIS command name from the
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
The .NET User Secrets action has been added for ASP.NET projects.
Rider now auto-generates an
npm run configuration for
.esproj) referenced by
the solution (
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
cache folder from global searches to help provide better search results.
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
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
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
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
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.
Rider already provides the option to add CoreRedirects when renaming Unreal classes or properties via the Rename refactoring. This now also works for:
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!
Rider 2022.3 introduces a new Blueprints-specific Code Vision metric. You
can now quickly check how many Blueprints use the
function and get the list of all usages from the Code Vision context menu.
The Generate GUID tool now supports the Unreal Engine GUID format.
Whenever you need to quickly
generate a GUID,
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
Settings/Preferences | Languages & Frameworks | C++ | Unreal Engine.
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.
For Unreal Engine–based projects, Rider
works with both
.uproject projects. We are continuing to
enhance the support for the native
.uproject model to make it more
accurate and comfortable to work with:
.Build.cs files for
files are now supported when using the
.uproject project model.
.uproject model is used.
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.
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:
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 (DPA) has new inspections that let you find various issues related to database usage, namely:
The new inspections are available for all applications that use Entity Framework Core and .NET Data Provider for SQL Server.
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.
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.
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.
Central Package Management (also known as the
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.
Rider 2022.3 brings support for F# 7, provides a variety of fixes for small issues, and adds some quality of life improvements.
< inside a comment will now add a documentation template.
Additionally, syntax highlighting and code completion make editing
documentation comments much easier.
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
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.
Here are some highlights of Rider 2022.3’s new features for working with databases:
Learn more: What's New in DataGrip 2022.3
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 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.
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.
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.
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.
Free 30-day trial available