What’s New in Rider

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.

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.

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.

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.

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

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

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

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.

An indent guide separating the indentation from the actual value is now displayed on raw strings.

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.

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

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

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

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

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.

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

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

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

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.

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.

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.

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.

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.

Auto-import

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.

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.

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.

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.

Typing < 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 previously.

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:

• 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

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.