What′s New in Rider

Rider 2019.3 offers outstanding support for T4 templates, a cross-platform profiler for .NET Core, and cross-platform test coverage for Unity. Startup is faster, the debugger supports Docker Compose, and Version Control support and Xamarin support are enhanced across the board.

Free 30-day trial

Rider 2019.3

Support for T4 templates

Support for T4 templates

You asked us to support T4 text templates, and we’ve delivered! Based on our own generator and available as a pre-installed plugin, T4 templates support is here. 

Now you can easily execute, process, and debug all your T4 templates in Rider. We hope you enjoy the new in-editor assistance, which includes:

  • Feature-rich C# support in code blocks, including code highlighting, navigation, code completion, typing assistance, refactorings, context actions, inspections, formatting, and more.
  • Support for T4-specific features such as inspections, typing assistance, folding, and brace matching.
  • Extensive support for include directives to make resolving C# code as correct as possible.
  • Support for all kinds of directives, including inspections, quick-fixes, code highlighting, navigation, and more.

All these features work on Windows, macOS, and Linux.

Cross-platform profiler for .NET Core

Cross-platform profiler for .NET Core

Rider 2019.1 brought the performance profiler to macOS and Linux, but it only supported Mono and Unity Mono applications at the time. With this release, we’ve taken a huge step forward, and it’s now possible to profile .NET Core applications on Linux and macOS using the embedded dotTrace plugin. This means that you can profile any .NET applications on Windows, macOS, and Linux.

Note that only projects targeting .NET Core 3.1 are fully supported. Because of some .NET Core limitations, profiling of projects targeting .NET Core 3.0 or earlier may, in rare cases, cause the profiled application to hang or crash.

Test Coverage for Unity

Test сoverage for Unity

We really enjoy trying to improve the Unity scripting experience, and we strive to deliver something outstanding with every release. This time, we are introducing cross-platform test coverage and continuous testing for your Unity Edit mode tests!

These are some of the new features to get excited about:

  • Play mode unit tests are now supported in the Unit Test runner.
  • Rider supports UIElements with syntax highlighting, code completion, and schema validation of UXML and USS files.
  • Support for .asmdef files is back!
  • The project name is shown for Unity Editors when listing processes for debugging.
  • We’ve improved performance parsing assets when the project loads initially.
  • “Clear on play” supported in Rider’s log viewer tool window.
  • That annoying bug when Rider would suggest C# 8 features is now fixed.
  • We’ve fixed various edge cases keeping .meta files up-to-date during refactorings.

These are just the highlights. As always, there are plenty of other smaller fixes and features in this release. Check out the full list in the changelog!

Better performance

Better performance

Rider 2019.3 automatically includes all the performance optimizations that we added to the IntelliJ Platform during our recent Quality Marathon. Here are just a few of the key improvements: startup performance has improved a lot, smooth mouse scrolling is here, and we’ve eliminated a lot of UI freezes. If you’re interested, you can read more about all the performance improvements on the IntelliJ IDEA blog.

Docker Compose reaches the debugger

Docker Compose reaches the debugger

In the 2018.2 release, we introduced Docker support into the debugger to let you debug containers built from a Dockerfile in Rider. However, debugging containers created using Docker Compose (docker-compose.yml) was not supported at the time.

Well, the wait is over! Docker Compose support has finally reached the debugger! Now you can debug multi-container Docker applications with the click of a mouse.

Edit & Continue becomes even better

Edit & Continue becomes even better

Edit & Continue can now apply changes to a running (not suspended) application, and the application does not need to be stopped at a breakpoint. You can apply changes anytime by clicking the “Apply Changes” link on the tooltip at the top of the editor tab. Additionally, you can disable the automatic application of Edit & Continue changes from the “Step”/”Resume”/”Jump to Statement” actions by going to “Settings | Build, Execution, Deployment | Debugger | Editing during debug”.

Please note Edit & Continue is still only supported on Windows.

Debugger improvements

Debugger improvements

We have made lots of changes to other parts of the debugger. First of all, the Exceptions tree in the Breakpoints view has had a big update:

  • Search now works on collapsed nodes.
  • Exceptions are grouped by both a type (User/System) and a namespace.
  • The main node has a new name, “CLR Exceptions”.

Secondly, Remote Debugging has received a couple of updates:

  • There are now better descriptions and notifications for errors that might occur when you use it.
  • If a password or passphrase for Remote Debugging is not specified, it will prompt you for one when you connect to a remote server.

And finally:

  • Lots of debugger actions were given new names that better explain what they do.
  • The “Pin to top” feature supports recursive evaluation.
  • The “Jump to Type Source” action is now available.
  • The “Just my code” option for exception breakpoints works much better on Mono.
Updated VCS support

Updated VCS support

We’ve started experimenting with user interface and user experience improvements when working with version control systems like Git. In this release, a new live diff preview opens right in the code editor tab to provide a much better user experience.

We’ve also introduced a new Commit tool window, which is shown on the left by default so as to leave more vertical screen space for change lists, commit descriptions, and so on.

If you can’t find the Version Control tab on your first launch of Rider 2019.3, don’t worry; it’s still there, but it has a new name: Repository.

Besides that, we’ve improved the “Compare with Current” view, reworked the Clone dialog, and made it possible to push a non-active branch.

To learn more, check out the blog post A New Way to Commit! Introducing the Commit and Repository Tool Windows in Rider 2019.3.

The AWS Toolkit plugin comes to Rider

The AWS Toolkit plugin comes to Rider

In this release cycle, we’ve put a lot of effort into optimizing the AWS Toolkit plugin for .NET developers and making it compatible with Rider.

  • Use a predefined project template to create a new AWS serverless application.
  • You can create, run, and debug an AWS Lambda locally and remotely. What’s more, you can do all of it right from the editor, using just the gutter icons.
  • You can deploy your Serverless app to AWS.
  • Cloud Debugging support is here! You can debug your cloud .NET Core applications running on Amazon ECS with AWS Fargate directly inside a remote container in a cloud, without any local emulation.
  • The plugin is available for both Rider v2019.2 and v2019.3.

After installing the AWS Toolkit for Rider plugin, you’ll have everything you need to start working instantly with your AWS serverless applications.

Leveled up Xamarin support

Leveled up Xamarin support

We’ve continued to make Rider a great IDE for Xamarin development and delivered some sweet improvements for both Xamarin Android and Xamarin iOS:

  • Apple devices and simulators now discover better on Macs thanks to integrated JetBrains AppCode components.
  • You can find the list of connected Apple devices on the toolbar.
  • We now support mtouch (Mono Compiler for iOS) device builds.
  • “Publish Android APK” is available for Xamarin Android projects (look for the “Archive or Publish” action in the context menu for a project).
  • You can edit Android-specific project properties in the Project Properties.

Also, we haven’t forgotten about Xamarin Forms support, which has a couple of important fixes such as x:DataType and Class attribute support.

Even Better C# 8 support

Even Better C# 8 support

The new Rider release handles C# 8 even better. It now includes:

  • A better understanding of Nullable Reference types including support for notnull constraints.
  • Target-typed switch expressions.
  • Early support for default interface methods.
  • A new "Local function can be static" hint with an accompanying quick-fix.
  • A new quick-fix to enable nullable annotations and warnings in a file, project, or all projects in a solution.
  • A new quick-fix to add the EnumeratorCancellation attribute to CancellationToken parameters of async iterators.

Additionally, the code inspection "Type or type member is never used" has been split into two separate options, one for types (Type is never used) and another for type members (Type member is never used).

Code Generation

Code Generation

The Generate action knows more about C# 8 and helps you learn, too, with:

  • A new quick-fix "Add missing arms" to check enum values exhaustively.
  • A new quick-fix and context action to generate type patterns in switch expressions.
  • Nullability being taken into account when generating equality/relational members/comparers.

Also, there is a new Option to use System.HashCode to implement GetHashCode when generating equality members or equality comparers for C# and VB.NET, which will help make your code cleaner.

Type Name Hints

Type Name Hints

We hope you like the Parameter Name and Code Annotations hints we introduced in the Rider 2019.1 release. This release we go further and are ready to give you Type Name Hints. They are available for:

  • A lambda’s parameters.
  • All var occurrences, including pattern matching and tuples deconstruction.
  • Range variables inside LINQ statements.
  • At the end of a line in a method call chain.
Navigation and Find Usages

Navigation and Find Usages

Most of us want to know where a particular reference is used in our code. For a long time, you could run the “Find dependent code” action on a reference to find all the places where types or type members from that reference appeared. However, there were some limitations. With this release, we eliminated a couple of them: Find dependent code works for NuGet references, and it can be run for a whole solution instead of just a project.

Now Rider definitely has more to offer:

  • The Quick definition overlay tooltip is available for any symbols in the code editor, allowing you to quickly review a symbol’s definition without leaving the current context.
  • Consuming APIs extends “Navigate to” actions and might be helpful if you want to list all methods that receive objects of a specific type in their parameters.
  • The Find results window for Find dependent code has new filters.
  • You can now navigate to the external sources of NuGet packages that have a source symbols package.
Code Style

Code Style

In this release, we’ve delivered on one more long-awaited request. C# naming settings now support reading from/exporting to EditorConfig.

In addition to this huge change, there are several smaller changes that give you more control over the style of your code:

  • For those who prefer to use `var` instead of explicit types only when the type of initializer expression is evident, Rider can now detect the more evident cases. There is also a “compatibility” mode to match the Roslyn behavior.
  • There is a new code style option, which is compatible with StyleCop and Roslyn, to add parentheses that clarify precedence only for a group of operators nested with others from the same group. For example, if you can’t remember whether && or || takes precedence, this option will help you clarify it with parentheses.
  • Comment Code now adds an indent to a comment by default. There’s a new setting to “Place comments at first column when commenting out code” if you want to turn it off.
  • The options pages to set up indentations now display the appropriate notification when the Autodetect indent size and value setting is ON.

There is also a notification tooltip explaining the Configure formatting and Autodetect formatting features on the C# formatter options pages.

Project model improvements

Rider’s project model now extends any refactorings you make in your web language files, such as TypeScript files, to all your project files. For instance, “moving a TS class to a separate file” updates the corresponding .csproj file with the change. We’ve also improved the UX for the “Not Built” project state in the Solution Explorer.

Please note that we’ve dropped our support for .NET Core 1.* SDK, as these versions have reached their end-of-support dates.

Initial MongoDB support

Rider has added some initial support for MongoDB (read more). Additionally, we’ve extended Rider’s database support to the Oracle PL/SQL debugger and added new inspections and warnings, an inline query progress indicator, and an easy way to Google a connection error.

To learn more, check out the page What’s New in DataGrip 2019.3.

Web development

Web development

As usual, there are a lot of goodies for web developers:

  • Significant improvements in code completion for Vue.js.
  • Quick documentation in Vue.js projects.
  • Better support for props in React components without propTypes.
  • Enhancements in Angular support.
  • Support for TypeScript 3.7 and other improvements in JavaScript/TypeScript support.
  • Several updates in CSS/SASS support.
  • Support for the upcoming Yarn 2 release.

To learn more, check out What’s New in WebStorm 2019.3.

Other features

Other features

  • We’ve improved Rider’s support for project files (like .csproj files) by making code completion aware of various MSBuild items. You can also use an inspection and a quick-fix for <TargetFramework>/<TargetFrameworks> validation.
  • We now generate the predefined run configuration in a smarter way, so that you can run it without any additional movements or adjustments. It also has an appropriate auto-generated name instead of the boring “Default”.
  • More MSBuild properties specified in a launchSettings.json file, such as $(ProjectDir), are now supported.
  • The Parameter Info popup is available for tuples.
  • Typing assists for deleting new lines, and for backspacing before a new line, now leave a space in order to separate tokens, or when this is required by the formatting rules.
Yet more features

Yet more features

  • Identifier highlighting has been completely reworked with a separate page for C#, separate colors for preprocessor directives, static methods, fields, etc.
  • New NUnit inspections cover combinatorial unit tests and individual parameters of parameterized unit tests.
  • The Expand All button is back on the left-hand toolbar.
  • A new reactive TFS client has been released in an experimental mode. To enable it, you just need to open Settings | Version Control | TFVC and turn it ON. This provides a dramatic speed improvement for the "Checking for changes" action (it’s now about 100~1000 times as fast in our tests). Many operations, such as Commit and History actions, will be ported to the new client after the initial release.
Free 30-day trial

Rider 2019.2


Debugger improvements

The “Variables” tab has a new feature called ‘Pin to Top’. Use it to star any of an object’s properties or fields you are most interested in, to keep them at the top of the list. 

The ‘Run to Statement’ and ‘Jump to Statement’ actions now have icons following the cursor in the editor.

We’ve also added many performance improvements for stack calculation and stepping.

To learn more, see Debugger additions for Rider 2019.2: Pin to Top, Floating Actions, and Redesigned Stack Frames.

Xamarin support

Xamarin support

This release adds a couple of useful features you’ll appreciate in your Xamarin iOS development.

First, you can publish an .ipa (iOS App Store Package) file for a Xamarin iOS project to an iOS device right from the IDE. Select an iOS project in the Solution Explorer View, call the context menu, and click on “Archive for Publish” item.

Second, you can manage provisioning profiles from the Properties window (Configurations | Bundle Signing) for a Xamarin iOS project.

Windows Forms designer

Rider 2019.2 adds support for third-party controls from Telerik, DevExpress, Syncfusion, ComponentOne, and Infragistics. You can load a suite of controls into the Designer Toolbox, and then use them in the application’s forms and user controls. Please note that some DevExpress controls that heavily use Visual Studio API won’t work. We are currently working on a workaround.

Apart from that, we’ve added support for 32-bit controls, so now you can use your 32-bit components in the designer.

To learn more, see Using third-party Windows Forms controls with Rider.

Code coverage of Mono applications and unit tests

Code coverage of Mono applications and unit tests

In addition to coverage analysis of .NET Core applications and tests, we’ve added support for the Mono Framework. Go ahead and cover your .NET Framework unit tests using the Mono runtime on Linux, macOS, and Windows..

Enhanced C# support

Enhanced C# support

Take full advantage of C# 8 with ReSharper’s enhanced support:

  • Supports the latest changes in indices and ranges such as indexable and rangeable types.
  • The context action Add range check now supports indexing by System.Index/System.Range and produces correct checks.
  • Supports unmanaged generic structs.
  • Two new inspections, ‘Convert switch statement to switch expression’ and ‘Convert chain of ternary expressions to switch expression’, with a corresponding ‘Convert to switch expression’ quick-fix.

You asked and we delivered: the context action Convert concatenation to interpolation can now be applied in scope.

F# support

F# support

Code Vision comes to F#! It shows you inferred types for functions, values, and members, and VCS author for declarations, right in the code editor.

Other changes include:

  • ReSharper’s spell-checker now works for F# symbol declarations, strings, and comments.
  • Escape sequences are highlighted in strings.
  • Better highlighting is available for never-matched rules in match expressions.
  • Find Usages and Go to Declaration work for record construction and copy-and-update expressions.
  • The New Instance kind of occurrences is shown for expressions that create exceptions.
  • F# Interactive can be run from .NET Core SDK 2.2.300+.

For more details please see the GitHub repo.

UI update

UI update

The editor and debugger tabs in the Light themes have been redesigned to align with the Darcula/Dark themes. We do hope you will like the UI of these new tabs.

The UI of the code completion popup is now clearer and more consistent, and provides better highlighting on selection in the Light theme.

This release lets you commit directly from the Local Changes, so there is no longer any need to go through a separate Commit dialog.

Solution Explorer

Solution Explorer

The Solution Explorer view adds a few updates:

  • Solution folders can now be renamed.
  • Auto-scroll to source” is disabled for solution/project files.
  • Filtered solutions (*.slnf) introduced in Visual Studio 2019 can be opened in Rider.
NuGet support

NuGet support

Rider 2019.2 delivers lots of updates for the built-in NuGet client:

  • It displays a package’s readme.txt to help determine the next steps after installing a package.
  • When XDT transformations are run, entries are automatically added/removed from configuration files when required by the package.
  • Rider supports native cross-platform credential providers, such as the one available for Azure DevOps/Artifacts, for accessing private feeds.
  • We have made several updates to upgrading multiple packages in multiple projects, to make package upgrades easier.

For more details please see the Readme.txt support, XDT transforms, native credential providers and more Rider 2019.2 NuGet updates .

Rearrange code

Rider has implemented one more highly-anticipated feature from ReSharper – File Layout patterns can be modified via the XAML View (with code completion and code highlighting) right in Rider’s Settings/Preferences: Editor | Code Style | C# | File Layout.

ASP.NET support

We’ve implemented our own ‘ASP.NET code-behind files’ generator for aspx/ascx files. Now, when you add a new control to an .aspx file and access it from the code-behind (.aspx.cs), the generator creates the corresponding .designer.cs file.

Unity support

Rider’s excellent integration with Unity keeps getting even better with every release. Here’s what v2019.2 has in store for you:

  • Shows serialized field values directly in the editor.
  • Added completion and validation of scene, tag, layers, and input values.
  • New file and live templates to create custom editors, attributes, and more.
  • Generate event functions from an Alt+Enter context action anywhere in a class.
  • New context actions to add Inspector attributes such as `Space`, `Header` and `Tooltip`.
  • New inspection for duplicate keyboard shortcuts in menu attributes.
  • Use the Navigate To menu to find usages of symbols in Unity.
  • Greatly improved performance of text-based asset handling.
  • Unity Editor plugin now ships as a bundled package with Unity 2019.2 – no more dlls in the project!

For more details please see the repo on GitHub.

VCS update

VCS update

  • Prompt to add files to the version control that were copied into a project externally. 
  • Prediction of files you may be forgetting to check-in.
  • Improved handling of ignore files.
  • Show history for directory works through Git log.
  • View the Git file history for multiple directories selected from the Project View.
  • Update Info after Update Project action is shown as Log tab.
  • Improved Compare Branches action.
  • Show Diff with Working Tree action.
  • Improved “Collapse Unchanged Fragments” mode of Diff.
  • Customize VCS Log columns.
  • Abort Git merge and cherry-pick processes.

Read more: What's new in IntelliJ IDEA 2019.2.

Web development

Web development

  • Improvements for the Rename refactoring.
  • Searching for duplicate code in JavaScript, TypeScript, CSS, Sass, SCSS, and Less.
  • Improvements in Angular support.
  • Updated presentation of completion suggestions in JavaScript.
  • Code completion for mistyped keywords and names.
  • Support for the Pipeline Operator.
  • New intentions for the JavaScript destructuring.
  • Updated Smart step into in the debugger.
  • Type hints in the editor.
  • Hide frames from libraries in the debugger.

Read more: What's new in WebStorm 2019.2.

Database support

Database support

  • A notification to set up a LocalDb connection if there is a proper connection string in a configuration file.
  • Full-text search with SQL preview.
  • Query live timer.
  • ‘Unnecessary usage of CASE’ inspection.
  • Quick table backup.
  • Table comments.
  • New option to control the behavior of Move Caret to Next Word.
  • New combined items, IS NULL and IS NOT NULL, are included in code completion.
  • New intention actions.
  • Force Refresh action.

More details: What's new in DataGrip 2019.2

Other features

Other features

  • New Services tool window: a single control panel for all connections, configurations, and more
  • Syntax highlighting is available for over 20 different programming languages, thanks to the built-in TextMate language grammars. The full list of languages can be found in Preferences/Settings under Editor | TextMate Bundles.
  • Now you can exclude members from the "import namespace" suggestion and the code completion list.
  • A new system notification tells you when the ‘Build Solution’ or ‘Run Unit Tests’ action has been completed.
Yet more features

Yet more features

  • All filters are available for Timeline Snapshots including Memory allocations, exceptions, and more.
  • The Scope Chooser in the Find in Path dialog has added new scopes: Recently Сhanged files, Recently Viewed files, and Data Sources.
  • Predefined options now exist for the “Visual Studio path” field on the MSTest setting page under Build, Execution, Deployment | Unit Testing | MSTest.
  • Now there's a button to show all external types in an opened hierarchy.
Free 30-day trial

Rider 2019.1

WinForms designer

WinForms designer

In this release, we’ve introduced the long-awaited WinForms designer to help you create, observe, and modify the UI of your Windows Forms application.

The WinForms Toolbox window displays controls that you can add onto a form surface. The Toolbox has the same default set of components as Visual Studio. You can copy/paste different controls from the Toolbox tab onto the surface of the designer, and resize and move the controls. In addition, you can easily search for components using the search field at the top of the tab.

A new Windows Form Application project template is available, as well as file templates for forms, user controls, and components.

As for limitations, please note that drag&drop of components from the Toolbox onto a form, VB.NET WinForms applications, and 3rd-party controls is not supported.

See more: Developing Windows Forms Applications in Rider

Edit & Continue

Edit & Continue

The next long-awaited feature implemented in this release is Edit & Continue (Windows only). This feature will help you apply changes to the source code while the application is halted on a breakpoint. On resuming, the changes will be automatically applied to the code. This will save you a lot of time since you don’t need to restart the debugging session after recompiling everything.

To learn more, see Edit & Continue, Just-in-time Debugging, and more debugger improvements

Cross-platform code coverage

Performance profiling and code coverage on macOS and Linux

Great news for everyone who uses Unix systems: code coverage and performance profiling come to macOS and Linux. Not without some limitations: In 2019.1, coverage analysis of unit tests including continuous testing is available for .NET Core 2.0+ applications (no Mono / Mono Unity). The performance profiler currently supports Mono 5.6+ and Mono Unity 2018.3+ applications (but not .NET Core).

See more:



Editor breadcrumbs now support C#, VB.NET, and F# files. The breadcrumbs help you quickly understand where your cursor is with regard to the structure of the current document, and help you navigate that structure.

To jump to a parent element in the source code, click the breadcrumb with its name. If you click the namespace element in a C#, VB.NET, or F# file, you will be able to navigate to all the files where that namespace is used.

Breadcrumbs can be shown either at the bottom (default) or at the top of the editor.

To learn more, see Breadcrumbs, structural navigation, parameter info tooltips and more editor improvements in Rider


IL Viewer

We’ve brought ReSharper’s IL Viewer tool window to Rider! The IL Viewer displays IL instructions for the class or method you currently have open in the editor. The editor and the IL Viewer are synchronized: placing the caret on a symbol in your code highlights the matching IL, and the other way around. When hovering an IL instruction, Rider shows a tooltip with its description, taken from MSDN and the ECMA-335 standard (Partition III: CIL Instruction Set).

To learn more, see Run static methods from gutter, IL Viewer, install SDKs and more improvements in Rider

Xamarin support

Xamarin support reaches the new level

Excellent news for all Xamarin app developers – we’ve built our own JetBrains Xamarin SDK which lets you develop Xamarin on Windows/macOS without having Visual Studio licenses/installation on your machine. It uses the same sources as the original MS one, so you will have the same experience using JetBrains Xamarin SDK as you have with the original one.

Another piece of good news is that Rider integrates directly with Xcode! Thanks to this integration, you can use the Interface Builder in Xcode to create user interfaces of your macOS project in your Xamarin application.

There are a couple of changes in the Xamarin Android support. First, the functionality has been extracted to a non-bundled plugin available from the Plugin Repository. You’ll need to install this plugin first to get all the goodies.

Second, the new Android SDK wizard is here to help you install all of the required SDKs for Android development if you open an Android project in Rider the first time.

Performance improvements

Performance improvements

After releasing Rider 2018.3, we received a lot of feedback about performance, so we focused on improving this area:

  • Since we moved the Xamarin Android support to a separate, non-bundled plugin, the time between clicking on the Rider icon and showing the splash screen with the progress bar has decreased a lot. As another plus, the installer is now 150 MB smaller in size.
  • In one of the previous releases, launching NGen (The Native Image Generator) for Rider binaries was broken. As a result, opening a solution in Rider took an additional 8 seconds on Windows because the JIT compilation process needed to be run at runtime. Now, we’ve returned running NGen and won back 8 seconds on every solution open.
  • We’ve made a couple of warm startup optimizations: stopped using the ReSharper engine in JavaScript/TypeScript support, and made the loading of the project model asynchronous. As a result, warm startups are now significantly (up to 2x) faster.
  • We’ve implemented an Early Backend Load to speed up the loading of the ReSharper language service by 3 seconds. You will notice the difference if the “Reopen last solution on startup” setting is enabled, or if you are blazingly fast and able to click on a solution on the Welcome screen in less than a second.
Razor support

Razor support

Everything about web-related languages (like JavaScript or CSS) on Razor pages was moved from the ReSharper engine to the WebStorm engine. It means that you will get better support of cutting edge front-end technologies and frameworks – enjoy Emmet support and advanced coding assistance for Angular, React, Vue.js, and Meteor right in your Razor views.

Since Razor views were the last place where ReSharper web support was used, right now only WebStorm engine analyzes your JavaScript and CSS. Because ReSharper-related assemblies are no longer loaded when Rider is launched, both solution loading and Rider startup times have become faster.

IIS Express support

IIS Express for ASP.NET Core

This release can run and debug your ASP.NET Core apps in IIS Express. The launchSettings.json support has been extended to support IIS Express as well. There is a settings page to help verify IIS Express is installed, including prerequisites.

Rider also checks whether a trusted SSL certificate has been set up, and allows you to generate a self-signed certificate if it isn’t.

To learn more, see Running and debugging ASP.NET Core apps in IIS Express with Rider

Rename for F#

Solution-wide Rename for F# symbols

The Rename refactoring for F#-defined symbols now works across your entire solution, even with usages in C# and VB.NET projects. Rider is the first IDE ever to provide this feature.

Besides this long-awaited Rename refactoring, F# in Rider has been given a heap of handy new features in the other subsystems like Navigation and Find Usages, but it is not limited to just them. You can find the full list of updates on the GitHub page.

Initial C# 8 support

Initial C# 8 support

Most of the new language features are already supported, including:

  • Ranges and index from end expressions
  • Null-coalescing assignment
  • Switch expressions
  • Tuple expression in a switch statement
  • Static local functions
  • Async streams
  • Nullable reference types
  • Recursive patterns
  • Using declarations

Typing assists for nullability annotations have been enhanced to support the features from the latest language version.

Code Editor update

Code Editor update

Let’s have a quick look at the changes we’ve made around the code editor. An enhanced Parameter Info tooltip now shows XML documentation for the selected overload, and has more colors, among other improvements. Intentions coming from WebStorm and DataGrip are now first-class citizens in the Alt+Enter menu for files with language injections.

Finally, Structural navigation from ReSharper is here to make Tab great again in Rider, too. Use the Tab and Shift+Tab keys to quickly move the text selection to the next or previous code element, respectively, without having to use the mouse or the cursor keys.

The code formatter gets several very handy improvements:

  • A new typing assist to unindent the code when you press Backspace (like in IntelliJ IDEA).
  • An “Export settings to .editorconfig” button lets you store code formatting settings in the EditorConfig file, so that you can share the same settings with colleagues who do not use Rider.
  • You can sort all using directives alphabetically, including System.
  • Sorting using directives is compatible with Visual Studio and StyleCop behavior.

To learn more, see Breadcrumbs, structural navigation, parameter info tooltips and more editor improvements in Rider

Huge Unit Testing update

Huge Unit Testing update

In every release we enhance Rider’s unit testing support, and 2019.1 is no exception:

  • Unit Testing support gets a performance boost and a smaller memory footprint.
  • All Unit Tests related windows have new grouping rules to group the tree of unit tests.
  • Unit Test Session windows now have the Session progress bar, as well as new ‘Track Running Test’ and ‘Hide Empty Test Filters’ modes.

See more: Unit Testing Improvements

Improved Unity support

Improved Unity support

As usual, we’ve made Unity support in Rider even more outstanding:

  • dotTrace performance profiling for the Unity editor.
  • Renaming a method or property used as a Unity event handler will now also rename usages inside text based scenes, assets, and prefabs.
  • One-click debugging of edit mode unit tests running in the Unity editor.
  • Performance-critical context and indicators (introduced in Rider 2018.3) now work across multiple files. Any method indirectly used from a method such as Update is now highlighted.
  • Improved indexing performance for Unity projects with extra folders at the root of the project.
  • Find in files can now search inside referenced packages.
  • Initial ECS support – types and fields used implicitly by ECS are now marked as in use.
  • New inspections, such as making sure that multiplication of vectors is performed in the most efficient order.
  • Plus many more small improvements and fixes, such as making event function code completion more robust, automatically launching the Unity editor when clicking debug, and refreshing assets after getting the latest from version control and before running tests.

More details can be found in the changelog.

IDE improvements

IDE improvements

  • Use the new Environment page in Settings/Preferences to choose additional components to download and install right from IDE, like .NET Core and Mono SDK/runtimes.
  • Native file dialogs now are used on Windows OS.
  • Rider supports Custom Themes.
  • The new navigation popup “Recent Locations” shows your recently visited locations such as code snippets, with a couple of lines before and after them. (blog)
  • All Rider settings can be synced via JetBrains Account Cloud.
  • The toolset settings page has been redesigned.
  • MSBuild global properties can be set in the settings.

To learn more, see Run static methods from gutter, IL Viewer, install SDKs and more improvements in Rider

VCS support

VCS support

Version Control support has become better in several ways:

  • The Fixup and Squash actions were 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.
  • You can switch the sides of compared files in the differences viewer.
Web development

Web development

If you are interested in web development, you will be happy to learn about these new features and improvements:

  • Easier navigation in Angular projects using the Related symbol action.
  • Better support for TypeScript inside .vue files.
  • New debugger console.
  • 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 for JavaScript and TypeScript.

See more: What's new in WebStorm 2019.1

Database support

Database support

  • Support for new databases: Greenplum, Vertica, Snowflake, and Apache Hive.
  • Code completion supports combined statements for CREATE and DROP
  • There’s a new option not to save the password at all.
  • New inspections are available.
  • Several updates for the database’s tree view.

More details: What's new in DataGrip 2019.1

Azure Functions

Azure Functions

Over the past few weeks, we have been busy making a number of improvements to the release of the Azure Toolkit for Rider. Rider 2019.1 introduces support for Azure Functions (V2), with project and item templates for C# and F#, debugging and deployment right from the IDE.

We’ve also improved SQL Database functionality with support for adding a firewall rule, and creating new database servers and new databases.

Tutorials on the Welcome Screen


We introduced a new way to get started with Rider: tutorials which guide you through the most important Rider functionality. In this release, you will find tutorials on editor shortcuts, debugging, using run/debug configurations, VCS, and unit testing.

The tutorials are available on the Welcome Screen after the first Rider launch. You can also run the tutorials via the menu Help | Tutorials.

Other updates

Other updates

  • Publishing now supports publishing ASP.NET Classic (non-Core) web apps to local folders or via FTP (Windows only).
  • Rider can be set as a JIT debugger on Windows.
  • Run Configurations: a static method and a run configuration for a project can be executed directly from the gutter mark in the text editor.
  • Profiling configurations are now more flexible thanks to more advanced profiling settings.
  • Better support for web references.
  • The .NET Core version can be defined when creating a new project.
  • The MSBuild process is automatically restarted if it’s killed for any reason.

To learn more, see Run static methods from gutter, IL Viewer, install SDKs and more improvements in Rider

Free 30-day trial

Rider 2018.3

Code Vision

Code Vision

Code Vision is a new way to see useful information about your code right in the editor, with additional actions required. In this release, Code Vision shows usages, version control info, derived types, extension methods, and exposing APIs, as well as a couple of Unity-specific metrics. We are going to add more metrics in future releases.

Learn more: Code Vision in Rider: Enriching the Editor with Contextual Information and Navigation.

Remote debugging via SSH

Remote debugging via SSH

Rider 2018.3 makes it possible to remotely debug .NET Framework, .NET Core, and Mono applications. Use the new action Attach to Remote Process... to see all processes running on the remote machine. Once you select a remote process, Rider will attach the debugger to it letting you pause execution, place breakpoints, and so on.

In addition to remote debugging, the debugger in Rider provides:

  • A brand new engine for the expression evaluator under the hood, which lets you use the latest C# syntax in debugger watches.
  • Support for pointer operations in the Watches tool window, including arithmetic, dereferencing and others.
  • When inspecting variables, the context menu helps you switch between decimal and hexadecimal for numeric values.

Read more: Remote debugging comes to Rider 2018.3.

Rename Project refactoring

Rename Project refactoring

Renaming a project manually can be a nightmare – lots of things need to be updated to reflect the new name, and you have to remember them all. To alleviate this pain, we have a solution (no pun intended) – the brand new Rename Project refactoring! Get it done automatically with a minimum effort and never look back.

To learn more, see Renaming projects the easy way – new refactoring in Rider 2018.3.

Assembly Explorer

Assembly Explorer

This is a long-awaited feature that existed in ReSharper for some time but was missing in Rider until now. Use it to open multiple assemblies, and to traverse and explore all open assemblies. It is available as a view in the Explorer window, in addition to the Solution and the File System views. Note also the View in Assembly Explorer context action for referenced assemblies, which can help you open them in the Assembly Explorer view.

To learn more, see Rider 2018.3 assembly explorer and cross-platform .NET decompiler.

Launch settings

Launch settings

If a project contains one or more launchSettings.json files, Rider 2018.3 auto-imports the launch profiles defined in these files and creates run/debug configurations for them.

This release also comes with editor support for launchSettings.json files. Syntax highlighting, code analysis, and code completion are available.

To learn more, see Using .NET Core launchSettings.json to run/debug apps in Rider.

IDE update

The Search Everywhere popup has been completely redesigned and now looks more modern.

The new Plugins pages in Preferences/Settings gets updated:

  • It makes managing IDE plugins easier: search, install, update, or uninstall.
  • Search for plugins works not only by name but also by tags, and the results can be sorted by downloads, name, rating, featured, or updated date.

To learn more, see Redesigned Search Everywhere, Plugins, Templates and more in Rider 2018.3.

C# language support

C# language support

C# language support has been significantly improved:

  • Inline parameter name hints made it right to the editor to make C# code more readable.
  • Improved C# 7 deconstruction support includes new/updated inspections, quick-fixes, and context actions. Go To Declaration/Implementation now supports deconstruction declarations.
  • A lot of code inspections, quick-fixes, and context actions for parameterized NUnit tests.

Learn more: What's new in ReSharper 2018.3.

Visual Basic .NET support

Visual Basic .NET support

The following features of VB.NET 15.3 and 15.5 are supported:

  • Named tuple inference.
  • Leading hex/binary/octal separator.
  • Non-trailing named arguments.
  • Private Protected member access modifier.

We added inline parameter name hints and a quick-fix Set Visual Basic language version which behave similarly to their C# counterparts.

Learn more: What's new in ReSharper 2018.3.

Web development

Web development

This release has a solid set of new features for web development:

  • Improved Angular support.
  • Multiline TODOs in JavaScript and TypeScript.
  • TypeScript 3.1 features: mappable tuple and array types, and new property assignments.
  • Better null and undefined checks.
  • You can now debug Node.js worker threads.
  • Newly added intentions: Extract ruleset, Replace var() with its fallback value, and Convert a function to a variable holding arrow function.
  • Option to use a custom severity level for linters.

Read more: What's new in WebStorm 2018.3.

VCS support

VCS support

With better Version Control support, now you can:

  • Manage GitHub Pull Requests right in the IDE.
  • Work with Git Submodules. Rider fetches all git repositories in the project in parallel during the project update.
  • Use advanced navigation in the VCS Log.
  • See a Diff Preview on the File History tab of the Version Control tool window.

Learn more:  IntelliJ IDEA 2018.3: GitHub pull requests and more.

Android development

Android development

If you are developing Xamarin or Unity solution with Android as the target platform, Rider has got you covered! It includes a lot of tools and features from Android Studio to help you develop for Android:

  • 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.
NuGet support

NuGet support

Most of the improvements in this version’s NuGet support were made under the hood. The visible ones include:

  • Support for NuGet servers that use NTLM/Windows authentication (on Windows).
  • Find this type on nuget.org action, which you may know from ReSharper, is now an available in the Alt + Enter menu for unresolved symbols.
  • A new quick-fix, Install missing .NET Core Adapter, is available in unit test files if you missed a required package.
  • Better and faster package search in the NuGet window is based on NuGet Completion Service.
  • The NuGet window shows more NuGet Folders based on NuGet.config files.
  • 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.

Check out the blog post: Add missing packages, faster search and more NuGet improvements in Rider 2018.3

Language injections

Language injections

SQL, CSS, HTML, JSON, regular expressions, JavaScript, and many other language injections now cover C# string literals. SQL language injections are automatically added based on the string content, and you can now manually mark any string literals with //language=LANGUAGE comments.

To learn more, see SQL inside C# strings, fragment editor, run query in console – Language injection updates in Rider 2018.3.

Integrated performance profiler

Rider gets an integrated performance profiler. For now, the profiling features are available on Windows, while on Linux you can only analyze performance snapshots.

To learn more, see Performance profiling .NET code in Rider with integrated dotTrace.

F# support

F# support

We introduced brand new F# lexers for both IntelliJ IDEA’s frontend and ReSharper’s backend. Required for several existing features, these lexers will help us further improve language support.

In this release, the new backend lexer helps us get rid of a lot of hacks. It implements the following cool features the right way, using the full power of ReSharper’s backend:

  • New typing assists for brackets, quotes, and auto-indent on pressing Enter.
  • Rename refactoring works for local symbols.
  • New inspection to find Unused opens and the corresponding quick-fix.

Finally, new grouping types are available in Find Usages: New instance creation and Pattern when you search for usages of Discriminated Unions cases, and Type specifications when you search for type usages.

Project and file templates

Project and file templates

New project and file templates are available:

  • UWP project templates added.
  • Xamarin-related project templates updated.
  • New file templates for app.config / web.config / appSettings.json files.

To learn more, see Redesigned Search Everywhere, Plugins, Templates and more in Rider 2018.3.

Azure Toolkit for Rider

Azure Toolkit for JetBrains Rider is an open-source plugin that helps .NET developers easily create, develop, configure, test, manage, and deploy web apps to Azure directly from Rider, and work with such resources as storage, Redis cache, and virtual machines.

You can now work with Azure SQL Database, and we’ve also added support for Cloud Shell.

To learn more, see:

Database support

Database support

Courtesy of JetBrains DataGrip, Rider’s database support is enhanced in the following ways:

  • We’ve added support for one more NoSQL database - Cassandra.
  • Generate SQL files for the selected objects.
  • Support for extensions in PostgreSQL.
  • Several improvements in SQL code completion.
  • Postfix completion has been introduced.
  • Single connection mode.

More details: What's new in DataGrip 2018.3.

Other features

  • Zero-latency typing is here! Even for smart typing assists that do long tasks like reformatting code, Rider UI won’t be blocked and the code editor stays smooth and responsive. All asynchronous changes from Rider’s backend will be merged in a magical way later when they are complete.
  • We refactored and optimized the loading assemblies stage to speed up solution loading.
  • The High-contrast color theme is available.
  • Ctrl+Click on an entity declaration now shows usages.
  • Four new refactorings added: Move to Resource, Inline Resource, Move Resource, and Rename Resource.
  • You can set environment variables for executing unit tests under File | Settings | Build, Execution, Deployment | Unit Testing | Test Runner.
  • XSLT Debugger is now available.
  • To-do color settings are finally applied to the code editor, and To-do items can now be grouped by project.

To learn more, see Redesigned Search Everywhere, Plugins, Templates and more in Rider 2018.3.

Yet more features

Yet more features

  • You can explore the inheritance hierarchy of types via Navigate | Type Hierarchy.
  • Roslyn Analyzers properly run on .NET Core if MSBuild is not installed.
  • Syntax highlighting, inspections, and other analyses in .editorconfig files.
  • A new action, Build only this project without dependencies, can be handy if you have a custom build system.
  • Projects get reloaded if an MSBuild import was changed.
  • Both Directory.Build.props and Directory.Build.targets are supported.
  • Copy Reference to help you copy the fully qualified name of a code entity (select Edit | Copy Reference).
  • Tab/ShiftTab indentation now behaves like it does in Visual Studio. Pressing Tab or ShiftTab aligns the code to the closest indentation (when the indent is set in spaces).
  • Open in Rider action was added to the File Explorer context menu. It works only on Windows and only if Rider was installed via the installer (and not via Toolbox App).

To learn more, see .editorconfig updates, more build options, better Roslyn support in Rider 2018.3.

Another huge update for Unity

Another huge update for Unity

Our Unity support took one more giant leap in this release, with some very exciting new features.

First, we’ve introduced performance indicators. Rider will highlight event functions that are called each frame, such as Update, FixedUpdate, and LateUpdate, as well as coroutine methods.

Second, we’ve extended our Find Usages with data pulled from Unity scenes, assets, and prefabs. If you search for a class or method used as an event handler, Rider will show where it’s used in your Unity files, grouped by type, component name, and parent game objects. Even better, double clicking the item will highlight the usage directly in the Unity Editor.

Pulling this information from Unity files also means that Rider will now correctly highlight event handler methods as being implicitly used. We’ve moved the implicit usage highlights from the text editor gutter icons and turned them into Code Vision links, so you can see at a glance what classes, methods, and fields are implicitly used by Unity. And clicking the link will find those usages, even inside Unity files.

The debugger learned more about Unity, too, and is now able to show extra data for Unity objects. It can also give you data for raw pointers, which is helpful for examining native containers in ECS jobs.

Free 30-day trial

Rider 2018.2

Debugger enhancements

Debugger enhancements

Rider now displays call stacks that make use of modern C# features in an understandable way, including generic types, async function names, constructors, static methods, and other type information.

We’ve added thread-specific breakpoints to simplify the debugging of multi-threaded code. You can edit a breakpoint (using the context menu) and suspend only on a specific thread. The breakpoint will then only be hit when it is reached in the particular thread you are interested in.

The debugger includes a few other updates, too:

  • Inspecting and expanding unsafe pointers is supported.
  • Smart Step Into now correctly handles methods that are decorated with the [DebuggerStepThrough] attribute.
  • Debugger.NotifyOfCrossThreadDependency is supported.
  • We’ve added an option to automatically refresh all watches in the debugger tool window on every debugger pause.
  • Types in the Memory View window are now formatted in C# style instead of the CLR style

To learn more, see More meaningful call stacks, thread-specific breakpoints and other debugger improvements.

Publishing to IIS or FTP

Publishing to IIS or FTP

Rider introduces two new run configurations: Publish to IIS and Publish to custom server. Both serve the purpose of deploying our ASP.NET Core web application to a local or remote server, but they use different means to do this:

  • Publish to IIS uses MSBuild and MSDeploy to package and publish our application. This run configuration type can deploy our ASP.NET Core web application to local and remote IIS and to Kudu (Azure Web Apps), as well as create an MSDeploy package. Publish profiles come as .pubxml files.
  • Publish to custom server uses MSBuild and Rider’s built-in tooling to upload our application artifacts. This run configuration type supports using FTP and FTPS/SFTP to get our application out there. It is supported on Windows, Mac OS X, and Linux.

Right now, only publishing of ASP.NET Core Web projects is supported. Additionally, using the Publish to IIS run configuration type to deploy to IIS will only work on Windows.

To learn more, see Publishing ASP.NET Core web applications to IIS, FTP, and more with Rider.

Docker support has reached the debugger

Docker support has reached the debugger

Rider now supports debugging ASP.NET Core apps in a local (Linux) Docker container. Attaching the debugger to a Docker container helps validate our application locally in a Linux Docker container, which should closely resemble production.

Just like with debugging on our local machine, Rider allows inspecting variables, stack frames, and threads, as well as stepping through both our own code and decompiled third-party code.

Right now, only ASP.NET Core web applications may be debugged on Linux Docker containers. While Rider allows debugging containers that are built from a Dockerfile, it does not yet support debugging containers that are created using Docker compose (docker-compose.yml).

To learn more, see Debugging ASP.NET Core apps in a local Docker container.

Solution Explorer redesign

Solution Explorer redesign

A new toolbar lets us easily toggle the option to show all files, which will reveal all other files that are not part of the project model (highlighted in brown). The next two buttons allow us to synchronize the solution explorer and editor. Autoscroll to source reveals the selected files in the editor, while autoscroll from source selects files whenever we navigate from one file to another.

Rider 2018.2 introduces the File-system view in addition to the Solution view, which shows the actual file-system structure underneath our solution file. Items marked with no index are excluded from index-based features such as global text search or todo indexes. We’ve also merged the scratch view into both Solution and File-system views, which makes for easier access to recently created scratch files.

We’ve added a dialog to make configuring custom file nestings a lot easier. They work with SDK-based project files and the older format equally well, without any further requirements. With Rider 2018.2, file nestings can also be applied by using drag & drop from the file that should be nested to the new parent file.

With the latest version, there is also an option to show folders always on top, which may be a more natural presentation for some of us.

To learn more, see Solution Explorer and Project Model updates in Rider 2018.2.

Code completion

Code completion improvements

Rider now uses ReSharper’s statistics-based scoring algorithm to provide code completion. One of the key aspects of this is that Rider now keeps track of how many times a given code suggestion was used. The more a suggestion is used, the more likely it will be to show up in code completion.

We’ve expanded code completion to several places where it would be handy to get some help from Rider: scratch files, debugger watches, and C# Interactive. Just like when writing code in a regular C# or VB.NET file, Rider provides code completion as well as method info and parameter hint popups.

We’ve also added a handy feature for when you are trying to access a pointer type’s members in an unsafe context and the -> operator must be used instead of the . (dot). To help prevent unsafe code, Rider will detect it whenever we use the wrong operator, and when completing code, will use the correct one instead.

To learn more, see Code completion improvements in Rider 2018.2.

Unit test coverage and continuous testing

Unit test coverage and continuous testing

With each Rider release, we do our best to bridge the gap between Rider and the ReSharper Ultimate bundle. The top in-demand feature has certainly been Rider + dotCover; integration. In addition, Rider 2018.2 has unit test code coverage and support for continuous testing. dotCover is provided as a bundled plugin for Rider and installed along with Rider automatically.

All critical functionality is available:

  • “Classic” unit test code coverage analysis using Coverage Tree and code highlighting. Everything looks and feels exactly the same as in Visual Studio with ReSharper Ultimate.
  • Continuous testing in Rider is no different from ReSharper Ultimate. Simply enable it for the desired session, change the code, and build or save the project (depending on the preferences).

Please note that only Windows is supported at this time. Support for Mono is still a work in progress and not included in 2018.2.

To learn more, see Unit test coverage and continuous testing. Now in Rider!

Templates Explorer

Templates Explorer

One of the most wanted features which has been missing from ReSharper is finally added to Rider. Now, you can manage, add, or modify Live/Surround/File Templates right in the Rider settings under Editor | Live Templates and Editor | File Templates.

Please note that creating multifile templates is not yet supported.

MacBook Touch Bar support

MacBook Touch Bar support

Just like the other JetBrains IDEs, Rider has support for the MacBook Touch Bar. You can do lots of actions directly from the Touch Bar: run, build and debug your project, commit changes, and update the project. The context-dependent buttons are displayed in the app-specific area in the middle of the Touch Bar interface. You can customize the Touch Bar contexts and buttons under the Preferences | Appearance & Behavior | Menus and Toolbars | Touch Bar page.

Besides this, you can make the Rider title bars darker on macOS (Preferences | Appearance & Behavior | Appearance | select Use dark window headers).

Additionally, Rider also comes with brand new icons. The main goal of these new cleaner, simpler icons is to reduce visual mess and increase the readability of the toolbar and tool windows.

C# 7.3 support

C# 7.3 support

Rider finally supports all features from the latest C# 7.3:

  • Declaration expressions in initializers and queries.
  • Tuple equality.
  • Ref assignments.
  • Unmanaged, System.Delegate, and System.Enum constraints.
  • Stackalloc array initializers.
  • Pattern-based fixed statement.
  • Indexing movable fixed buffers.

Besides supporting the syntax, we’ve added new inspections and appropriate quick-fixes to make your code compatible with C# 7.3.

To learn more, see C# 7.3 in Rider and ReSharper.

Frontend development features

Frontend development features

TypeScript support was improved and now supports all the language features from the latest TypeScript 2.9/3.0 releases. Besides that, Rider now offers more quick-fixes provided by the TypeScript language service itself.

The following features were also added:

  • Extract and convert React component.
  • New integrations with Angular CLI.
  • Completion for events in Vue.js.
  • A bunch of new context actions in the AltEnter menu, e.g., Implement interface, Create derived class, Implement members of an interface or abstract class, Generate cases for switch, and Iterate with for..of.

To learn more, see WebStorm 2018.2.

Integrated spell checking with ReSpeller

Integrated spell checking with ReSpeller

This release comes with the ReSpeller extension to provide spell-checking functionality out of the box. Just like with code analysis, ReSpeller scans for spelling mistakes and typos in identifiers, comments, string literals, and more, and provides quick-fixes to resolve each detected problem. By default, ReSpeller is enabled for many of the languages Rider supports. A simple way to enable/disable individual inspections and change the severity of what it detects is to search for “typo” in the settings (you’ll end up in Preferences | Editor | Inspection Settings | Inspection Severity).

We can then invoke the AltEnter menu where ReSpeller gives us several options to fix our mistakes. In the menu, we can either fix the typo or add a new word to ReSpeller’s dictionary.

By default, the spell checker comes with a built-in dictionary for English (United States). It uses a dictionary based on Hunspell, which means you can install additional languages if you like.

To learn more, see Integrated spell checking with ReSpeller in ReSharper and Rider.

Unit testing

Unit testing

In this release, we’ve added several new features and made a few optimizations:

  • Discovering and running tests in SDK-styled projects has become faster.
  • A new lock/unlock icon has been added to Unit Test Session toolbar, now you can lock a Unit Test session to prevent adding more tests.
  • Run and debug tests are now possible even on Mono on Windows.
  • It is possible to open the Unit Test Explorer window from the Navigate To menu
  • Unit testing related actions have been added into the default keymap.
NuGet support

NuGet support

NuGet support in Rider 2018.2 includes filter and format customization in NuGet logs, and advanced diagnostics which will help you to understand what happened if something with a NuGet package went wrong.

As well as this, we’ve added support for the AutoReferenced packages and TLS-1.2-only NuGet feeds.

Support for project.json-based projects has been discontinued since such kinds of projects are quite outdated and we think it is time for us to move forward.

C# Interactive update

C# Interactive update

In Rider 2018.2, a new Reference in the C# Interactive context menu is available for projects and assemblies. It does exactly what it says: references the selected project or assembly in C# Interactive. Rider will generate the load statement for us and execute it at once. The C# Interactive tool window also comes with its own toolbar button to help reference projects in the current solution.

Rider now supports attaching the debugger to C# Interactive and steps through our own code when invoked from C# Interactive. No more need to write a console application or a unit test to quickly debug a snippet of code. All we have to do is reference our project and start debugging it with C# Interactive!

To learn more, see Add references and debug code snippets in Rider C# Interactive.

F# support

F# support

File Templates now work inside F# projects, generating files with boilerplate code is now as easy as it is in C#.

FSharp.Compiler.Service has been updated to receive several F# 4.5 features/changes, the most notable of which are:

  • Span support.
  • match! keyword.

And last, but not least, the interop with C# projects has been improved, including the following F# 4.1 features:

  • Struct annotations for Records and Unions.
  • Implicit Module suffix.
Improvements in Unity support

Improvements in Unity support

Outstanding Unity support in Rider becomes even more outstanding!

We’ve introduced full support for Unity Assembly Definition Files (.asmdef): JSON schema validation, code completion, Find Usages, Rename refactoring, Navigation on references elements, AsmDef file templates, and inspections/quick-fixes for self-reference and file name/assembly name mismatch. Also, Rider now supports Roslyn C# compiler response files (csc.rsp)

We’ve added an option to disable Unity Reload Assembles when Unity receives focus in Play mode (only for Unity prior to 2018.2, as 2018.2 has the same option natively).

From now on, you can open a Unity Editor/Player log directly in Rider, and here you have the actions available to filter and collapse similar log entries. All commands are available under the cog menu in the Unity Log tool window

Code Analysis has been significantly improved. There are lots of new inspections and appropriate quick fixes to improve your Unity code, and we have made a bunch of bug-fixes, most notable of which is the invalid warning for this == null in Unity types.

In addition to all this, support for debugging remote players has been improved, and Packages and Scratches nodes have been added to Unity Explorer.

Other features

Other features

  • A new Generate GUID action is available.
  • We’ve introduced initial support for .ruleset files. Enable it by going to File | Settings | Editor | Inspection Settings and selecting the check-box Read settings from editorconfig and project settings.
  • Settings from stylecop.json are no longer ignored and are taken into account during analysis.
  • VCS support now has several new features, such as: Resolve of merge conflicts with a new Merge Conflicts node in an easier way, enhancements in VCS Log tab, and explore the state of the repository based on any given revision.
  • Custom tools can now be specified for a file extension in Settings.
  • We’ve added more colors to the Parameter Info popup and the Summary tooltip for IntelliSense in C# and VB.NET
  • The Build settings icon is available on the toolbar in the Build tool window, leading you to the settings page Build, Execution, Deployment | Toolset and Build.
  • A Runtime arguments field has been added to .NET-related templates on Run/Debug Configuration for passing custom parameters to runtime.
  • The Re-run action is now available on the Find Usages tab.

To learn more, see Generating a GUID in Rider, colored parameter info, custom runtime arguments in Rider 2018.2.

Free 30-day trial

Rider 2018.1

Roslyn analyzers support

Roslyn analyzers

Rider provides over 2400 code inspections in all supported languages to help you detect errors and code smells. In this release cycle, we have added even more power to improve your code quality – with Roslyn analyzers. If you have Roslyn analyzers installed in your projects via NuGet or .csproj references, Rider will highlight them in the editor and let you apply quick actions (if available) via the AltEnter menu.

Support for Roslyn analyzers is enabled and included in Solution-Wide Analysis by default. Related settings can be configured under Editor | Inspection Settings | Roslyn Analyzers. All analyzers have configurable severity levels, which can be adjusted to your needs via a context menu or the AltEnter popup. The light bulb in the gutter will show the Roslyn logo so you can distinguish between Roslyn's and Rider's code analysis.

To learn more, see Roslyn analyzer support in Rider 2018.1 EAP.

Entity Framework support in Rider

Entity Framework

Rider 2018.1 brings initial Entity Framework support in .NET Framework projects. It is available under Tools | Entity Framework and includes the following functionality:

  • Support for the most popular versions of Entity Framework: 6.0 to 6.2;
  • Initial Setup, Enable Migrations, Add Migration, Get Migrations, and Update Database actions available as dialog boxes;
  • Smart code completion for fields in the dialog boxes filters the suggestions list and shows only applicable projects, types, and names.

To learn more, see Entity Framework support in Rider 2018.1.

Unity game view toolbar and Unity Logs tool window

Deeper integration with Unity

Rider's support for Unity gets better with every release. In this release cycle, we've focused on reducing the time you spend on context switching between Rider and Unity Editor.

You can now switch into and out of Play mode, and pause and step a single frame without leaving Rider! A new toolbar includes game view buttons Play, Pause, and Step, which correspond to the same buttons in Unity Editor and control the same behavior as Unity Editor does. A new small Unity icon in the status bar will indicate whether Unity Editor is connected, refreshing, or in Play mode. Any changes applied in Rider in Edit mode will be instantly delivered to Unity Editor.

The new Unity Logs tool window with hyperlinked stack traces lets you explore the same events that are logged in the Unity Editor console. It allows filtering by category (error, warning, or message), hides events based on when they were logged (in Play or Edit mode), and lets you easily navigate to any source file, class, method, or property mentioned in the log entry. Unity Logs cleans its output automatically after every switch to Play mode.

Rider 2018.1 also provides seamless integration with Unity Test Runner. Explore the results of your Unity-specific tests, filter by result, and click on stack traces to navigate to your code — all from within Rider.

Last but not least, we've added a Unity Explorer view that duplicates Unity Editor's view of assets, to make you feel right at home.

To learn more, see:

XAML preview

XAML preview

The WPF Application project type implemented in Rider 2017.3 has received a missing fragment — a built-in mechanism to preview the results of any change you make in XAML code.

XAML Preview settings are available under Tools | XAML Preview. It is possible to turn the preview off, set the quality of the rendered image, and configure transparency.

To learn more, see XAML preview tool window for WPF in Rider.

Memory view in debugger

Memory view in debugger

A new debugger feature called Memory View allows you to look under the hood of an application and explore the managed heap while debugging, to understand the effect of code on the application's memory space.

When the debugger hits a breakpoint, you can open the Memory View in a separate tab of the Debugger tool window. Rider will show the total number of objects in the heap, grouped by type name and bytes consumed. Double click on a class item to see all instances in a separate window. You can also get there from the code editor by hitting AltEnter on any class declaration and selecting Show instances of class.

Memory View works with the full .NET Framework (4.5+) as well as .NET Core. Mono is not supported yet.

To learn more, see Memory View – Exploring .NET memory while debugging with Rider 2018.1.

Exception popup in action

More debugger updates

Debugging in Rider gets quite a few more lovely improvements:

  • Exploring exception details gets easier with the new exception popup. It shows basic information about a thrown exception and helps you quickly navigate through the highlighted stack traces of the exception. In addition, you can change exception breakpoint settings right inside the popup.
  • Smart Step Into has been combined with Jump to Statement, which means that already executed calls can be executed again.
  • Symbol server support allows you to configure the behavior of symbols and symbol servers. Set this up in Build, Execution, Deployment | Debugger | Symbols.
  • Rider learns to display the source code for return value locals in the Variables view (a.k.a "locals") of the Debug tool window.
  • Debugger's Attach window displays process names and IDs and suggests elevating permissions when elevation is required. (Note: right now this works only for .NET Framework on Windows.)
  • Attaching to local process gets faster.

To learn more, see Exception popup, improved Smart Step Into, symbol servers, and more Rider 2018.1 EAP debugger updates.

NuGet improvements

We've improved support for authenticating against private NuGet feeds in several ways:

In a related change, we've added initial support for bulk NuGet operations. You can update all packages in solution with a click of a new button on the toolbar in the NuGet Packages tab. It is also possible to update any installed package for all or several projects up to a required version, as well as remove it in one click.

To learn more, see Credential providers for private NuGet feeds in Rider 2018.1 EAP.

Custom MSBuild in toolset and build settings

Better understanding of projects and solutions

In this release, Rider has learned to:

  • Let you develop and build full .NET framework applications without an existing Visual Studio or Visual Studio Build Tools installation on a Windows machine using JetBrains redistributable of MSBuild. You can specify the Custom MSBuild under Build, Execution, Deployment | Toolset and Build | Use MSBuild version.
  • Support Web References: view web references in the Solution Explorer, discover and add WCF web references by URL, and remove existing web references.
  • Open and run Web Site projects with full support, including navigation, refactoring, code analysis, and so on.
  • Provide UI for editing project properties in .NET Core solutions.
  • Discover and auto-detect MSBuild more accurately.

To learn more, see:

Solution Explorer for F# project in dependency order

Evolving F# support

In F# projects, files are now arranged in dependency order, and you can drag-and-drop to reorder files in Solution Explorer. File re-ordering works for multiple files, so you can also move files before or after an existing directory.

F# scripting has been improved, too:

  • Code Completion, highlighting, and analysis work as expected.
  • Navigation commands such as Search Everywhere, Go to Symbol, Go to File Member, Find Usages, and Viewing File Structure all support scripts.
  • Smart Code Completion for files in #r and #load directives provides all the applicable files from subdirectories and inserts the relative path.

To learn more, see:

Support for C# 7.2

More changes from ReSharper

Rider doesn't forget about its roots and continues in the footsteps of its big brother, ReSharper. The list of features adopted from ReSharper 2018.1 includes:

  • Full understanding of C# 7.2 and improved support for previous C# versions.
  • Using EditorConfig to set inspection severities for any scope: solution, project, or a specific file. Use the option Read settings from editorconfig and project settings available under Settings | Inspection Settings | Enable Code analysis.
  • Code formatting inspections: Rider can now highlight code formatting violations right in the editor as you code. Not everyone is a fan of this behavior, which is why these inspections are disabled by default; to turn some or all of them on, go to Editor | Inspection Settings | Inspection Severity.
  • StyleCop support configurable under Editor | Code Style | StyleCop. Note that StyleCop configuration may override Rider's own code style settings.

To learn more, see:

Docker compose services

Even more changes from IntelliJ platform

Features inherited from IntelliJ IDEA 2018.1 include:

  • Docker support is now aware of multiple Docker Compose files, including docker-compose.override.yml, and allows choosing the services right away after choosing the configuration files in the run configuration.
  • Preview of regex replacement in the Replace in Path dialog.
  • New compact and lightweight documentation popup.
  • Better HiDPI support on multiple displays for Windows.
More frontend development features

More frontend development features

Rider continues to expand the functionality that it inherits from WebStorm and provides out of the box.

This update supports the latest TypeScript 2.7 features, improves the Implement Members action, and adds a new Surround with type guard quick-fix for unresolved properties.

Courtesy of our great colleagues on the WebStorm team, configuring package managers in Rider is now much easier. In Node.js and npm preferences, you can select between npm and Yarn and then have Rider use the preference when installing dependencies and running scripts. If you open a new project with a yarn.lock file, Rider will use Yarn in it if it's installed.

The Rename refactoring for classes now offers renaming a file if it has the same name as the class.

Ctrl/Cmd-click on a class name in HTML will navigate to its declaration in Sass, SCSS, or Less source code. In addition, code completion will suggest classes and IDs from all style sheets if there are no matching symbols in the linked CSS file.

Support for partial Git commits

Version control improvements

Everyone knows that small commits make it easier to review and track changes, and roll them back if something went wrong. Partial Git commits (git add -p) let you easily commit only selected changes from a file. Use checkboxes in the diff view of the Commit Changes dialog to select chunks of code you want to commit. Also, change markers in the left gutter let you move a change to any existing changelist or create a new one.

There's now a new Group by icon available in the Local Changes tab in the Version Control tool window, which allows you to group local changes by their directory, module, or repository.

In addition, Rider now highlights hashes in the commit details, and allows you to one-click jump to this commit in the Log tab.

Finally, Abort Rebase, Continue Rebase, and Skip Commit actions are now available from the Git Branches pop-up.

Ideolog plugin

Other changes

Smaller changes in Rider 2018.1 include:

  • New MSTest settings dialog: File | Settings | Build, Execution, Deployment | Unit Testing | MSTest.
  • New customization settings for C# Interactive: set focus to tool window on open/Send Line, or move the caret down on Send Line (adjustable in Settings | Language & Frameworks | C# Interactive).
  • The Ideolog plugin is available for download from the IDE: go to Settings | Plugins | Install JetBrains plugins…
  • The Scratches view is working as expected with a fully-fledged context menu.
Free 30-day trial

Rider 2017.3

Debugging third-party code

Debugging third-party code

Sometimes, you want to debug an assembly that you don't own source code for: a control library or a legacy module that doesn't quite work as expected. Other times, you just want to know better how the .NET Framework operates.

Rider 2017.3 makes debugging external code an automatic, pain-free process. You can now step through and set breakpoints in assemblies that Rider decompiles on-the-fly. Rider already had both a .NET debugger and a .NET decompiler inside, we just had to make them interoperate seamlessly, which we did.

Whenever you're only interested in debugging your own code, you can change debugger settings to make it step over any library calls.

To learn more, see Debugging third-party code with Rider.

Smart Step Into

Smart Step Into

Debugging method chains and nested method calls gets way easier with a new debugger action, Smart Step Into.

The action helps you choose a particular call to step into, while stepping over all other calls in a line. For example, when debugging a line like Print(Filter(people, BuildPredicate(x => x.Feature, "smth")));, you can pick to specifically step into Filter().

To learn more, see Smart Step Into debugging in Rider.

Debugger shows return values in Variables view

Return values in locals

Following popular demand, Rider learns to display function return values in the Variables view (a.k.a "locals") of the Debug tool window as you step through your code.

This is useful when the result of a method call is not stored in a local variable, for example when the method returns another method's return value, or when using method chaining.

To learn more, see Async call stack and more debugger improvements in Rider 2017.3.

More debugger improvements

Debugging in Rider has improved in many other ways, such as the following:

  • You can now drag-and-drop the execution pointer to an earlier or later location in code, letting you retry or skip certain logic without having to restart the application.
  • Callers of async functions are now displayed in the Frames view, restoring the async causality chain.
  • Debugger actions like Force Run To Cursor and Set Next Statement are now available via AltEnter during debugging sessions.
  • Code completion items in Variables and Watches views get a refreshed presentation.
  • Lambda expressions and extension methods are now supported when you debug Mono-based applications such as Xamarin or Unity.
  • Values of numeric types — decimal, float, double — are now evaluated and presented as expected.

To learn more, see Async call stack and more debugger improvements in Rider 2017.3.

New project wizard

New project wizard

Rider's UI for creating projects and solutions has been improved in many ways.

  • Project templates are now grouped by framework, with languages, flavors and target framework versions selectable in properties of each framework template.
  • Git or Mercurial repositories can be created along with new solutions.
  • You can search the wizard for a particular type of application or programming language.
  • More project templates are available by default, such as WPF Application and Unity Class Library.
  • Additional project templates based on dotnet new can be easily installed.

To learn more, see Project templates in Rider 2017.3.

Unit testing improvements

Unit testing improvements

Rider's .NET unit test runner gets a serious usability boost, as well as a set of new functionality:

  • Two new actions are available: Repeat Tests Until Failure and Rerun Failed Tests In Current Session.
  • All actions now respect the currently selected filter (such as Failed tests only). Filters themselves are now presented in a more compact manner: if a test status doesn't occur in the current test session, the filter for that status is not displayed.
  • Local shortcuts for unit test trees are introduced: for example, Del removes selected tests from a session, and AltShiftInsert creates a new session.
  • When you search for tests in the unit test tree, you can now find results in collapsed nodes.

To learn more, see Unit testing improvements in Rider 2017.3.

C# Interactive

C# Interactive

We have added a new C# Interactive tool window that helps you run C# statements without having to wait for compilation. This is a quick REPL-based way to draft code and get immediate feedback on what a given expression will return.

To start a new interactive session, open the tool window directly, or send a code selection from the code editor via AltEnter.

To learn more, see C# Interactive in Rider.

Unity support improvements

Unity support improvements

In addition to the new Unity Class Library project template mentioned above, the Unity plugin receives an array of all-around improvements:

  • New context actions to annotate fields as serializable or not serializable, as well as to convert auto-properties to properties with serialized backing fields.
  • New code inspections around Unity attributes, such as signature checks in methods marked with [PostProcessScene] and other Unity attributes.
  • Code completion starts to show Unity event functions at the top of the list, and works again before attributed fields.
  • Syntax highlighting and coding assistance are available in compute shaders in addition to regular shaders.
  • Unity debugger learns to break on user-unhandled exceptions, evaluate locals in coroutines and tasks, and reliably hit breakpoints when attached to local Unity processes. pdb2mdb is now integrated to enable the Mono debugger to handle assemblies that come with Windows-specific PDB files.
  • Quick Documentation pop-up provides links to external documentation for Unity symbols.
Config transformations

Web.config and App.config transforms

Rider learns to execute Web.config and App.config transformations that are commonly used to modify settings when packaging applications.

From the context menu, you can add a transformation, select a configuration that it is applied to (Debug or Release), and choose whether you want the resulting transform file to be nested under its parent in Solution Explorer.

To learn more, see XDT configuration transformations in Rider.

Reworked formatter

Reworked formatter

Similar to ReSharper, Rider's code formatting engine receives a major update. As a result, Rider learns to align code in columns and apply other new code styles. It also gets a way to disable or enable formatting for selected blocks of code with comments, or for entire files with EditorConfig.

To learn more, see:

More changes from ReSharper

Other updates that Rider received from ReSharper 2017.3 include:

  • Reworked Extract Method refactoring that supports returning tuples instead of out parameters when you're using C# 7.
  • New C# typing assists to add multiline comments, indent methods in chains, and surround code selections.
  • Support for tuples and documentation inheritance via <inheritdoc/> in VB.NET.
Running Karma tests

More frontend development features

Rider continues to expand the set of WebStorm functionality that it provides out of the box.

This release bundles a set of plugins for frontend developers that were formerly only available on demand, and weren't easily discoverable. This set of plugins includes support for TSLint, CoffeeScript, LiveEdit, Polymer and web components, Pug (ex. Jade), Handlebars, Karma, Stylus, AngularJS, spy-js, Gherkin, and Cucumber. (In related news, Vagrant plugin is now also available by default.)

Thanks to recent updates made by the WebStorm team, support for JavaScript, TypeScript, CSS and Vue.js gets a boost as well, and a preview panel is now available whenever you edit SVG files.

Finally, we have improved detection of package.json files in projects, which lets Rider suggest installing or updating npm packages in more cases.

Properties for .NET Core projects

MSBuild and NuGet

Rider's NuGet tooling learns to handle fallback folders, restore packages based on PackageReference directives in .csproj files, and ignore disabled NuGet package sources.

Speaking of its project system, Rider now provides UI to edit .NET Core project properties, and applies additional heuristics when dealing with linked files: it lets you choose between copying, moving files and adding links to them when you add an existing item, and suggests to exclude linked files from a project instead of deleting them from file system.

In a related change, we have enabled IntelliSense in .NET Core project files.

Reworked Docker run configurations

IntelliJ platform changes

Rider continues to take full advantage of its IntelliJ platform roots. In this release cycle, changes inherited from IntelliJ IDEA include:

  • Editor-based REST client based on scratch files with the .http extension. (The UI-based version of the REST client continues to be available, and even gets a few cosmetic updates.)
  • Version control updates including interactive rebase from Git log, preserving workspaces when switching between branches, and improved handling of Git and Mercurial merge commits.
  • Database updates: grouping data sources, XQuery/XPath coding assistance in .sql files via language injections, and more.
  • Docker support updates, most importantly revised Docker run configurations.
Null checking preferences


Rider's settings have been reworked in several ways:

  • You can now reliably export and import Rider settings via Import Settings, Export Settings and Manage Layers dialogs.
  • C# code style settings were extended with a Null Checking tab that helps choose a default null checking style in code that Rider generates for you.
  • Inspection severity configuration is now separated into per-language pages.
  • A new page with JetBrains Annotations settings was added under Inspection Settings.

Even more changes

  • Find Usages learns to work asynchronously to show available results while a search is still running, and offers a new grouping by usage type.
  • We have introduced a new Xcode keymap for long-time Mac users.
  • Designer files are now automatically regenerated on saving the associated .resx files.
  • Context menu on Solution Explorer nodes has been restructured for a clearer, more compact presentation of actions.
  • JetBrains annotations were ported to .NET Core, which makes entire categories of code inspections (nullability, LINQ, purity inspections) work more reliably.

Performance improvements

We have improved performance in many aspects, including:

  • Loading and reloading projects: thanks to a new asynchronous handling of MSBuild tasks, the synchronization stage of loading projects is now up to 5 times faster on large solutions that we used for testing.
  • Code completion performs faster on huge solutions.
  • In terms of debugging, the debugger launch time in some scenarios has been optimized, as well as rendering of large call stacks.
Free 30-day trial

Rider 2017.2

.NET Core 2.0

.NET Core 2.0

Rider 2017.2 adds support for .NET Core 2.0 in addition to .NET Core 1.1.

All Rider's code inspections, navigation actions, quick-fixes and refactorings are now available for .NET Core 2.0. Rider can run and debug your .NET Core 2.0 projects, manage NuGet packages that are used in them, as well as run unit tests based on xUnit, NUnit or MSTest.

Inspect This menu for call and value tracking in Rider

Call and value tracking

We've implemented some of the most insightful features that ReSharper has to offer: Call Tracking and Value Tracking.

Where does this value come from? Where is this value used? What are the call trees that this method is involved in? Using the new Inspect This action (CtrlAltShiftA) in Rider, you can now figure this out. On member and parameter declarations, Call Tracking and Value Tracking actions are even directly available from the AltEnter menu.

Both features are currently available in C# and VB.NET.

Running MSTest-based unit tests from the editor

MSTest support

Rider's unit test runner already supported running and debugging xUnit and NUnit tests. With Rider 2017.2, based on popular demand, we are adding MSTest to the list of supported frameworks. This includes classic MSTest (a.k.a Visual Studio Testing Framework) as well as the emerging cross-platform MSTest V2.

MSTest V2 will work out of the box on Windows, Mac or Linux. As to classic MSTest, due to the way it's licensed, you need to have a Visual Studio instance installed on your machine in order to run classic MSTest-based tests in Rider. The path to Visual Studio needs to be configured in Rider settings under Build, Execution, Deployment | Unit Testing | MSTest.

Open folder or file with Rider

Open folder or file

Not all code is in a solution or project. With that in mind, we added a command to open an individual file or folder from the Rider start screen and the File | Open menu.

When you open a file or folder, you can use a lot of Rider features, including HTML/JavaScript/TypeScript support, version control, Go to File, Search Everywhere, as well as Find in Path.

Attach existing folder to solution

Attach folder to solution

Along with opening folders or files, Rider can now do something extra: attach any folder to a solution. This doesn't modify any project or solution files; instead, it simply makes the folder visible in Solution Explorer alongside your current solution.

This can be useful if you're working with a web application that has distinct frontend and backend parts, and they're maintained in separate repositories. In this case, attaching the frontend part to your .NET backend solution will let you edit both parts in Rider, without integrating the frontend into your solution structure.

Parallel stacks, lambda evaluation and more debugger updates

The Debug tool window gets a new tab: Parallel Stacks. When debugging multithreaded applications, it lets us visualize the various threads that are active while debugging, as well as their call stack. Hovering over a thread displays all child threads. From the toolbar, you can jump to the active frame. Double-clicking an entry in the call stack will jump to source. And when stepping through code, the diagram will be updated depending on threads that are being started/joined.

Rider's debugger now lets you add lambda expressions as watches. The debugger will evaluate and execute the expression, visualizing the results.

When debugging applications that have lots of variables, you may want to mark variables with custom colors. This can now be done using the context menu or with a shortcut. Marking a variable makes it really easy to discover where it's used, for example in fields of other objects.

Finally, we enabled adding watches for nested items, such as properties of a property of an object, or an element in a collection.

Transform Parameters refactoring

New refactorings

We keep adding more items from the broad set of refactorings originally available in ReSharper.

One of them is Transform Parameters. It lets you create a new class or struct and converts parameters of the selected method into encapsulated fields of the newly created type. After applying the refactoring, usages of parameters are converted into usages of properties of the type being created. This refactoring also allows getting rid of out parameters by introducing a tuple object return type.

Another new refactoring is Invert Boolean. It helps automatically invert a boolean member and transform true to false and rewrite all usages to invert the boolean logic.

Enabling C# 7.1 support in Rider

Code analysis updates from ReSharper 2017.2

Rider 2017.2 comes with ReSharper 2017.2 as its engine for providing .NET support. This means a number of features announced with ReSharper 2017.2 are now available in Rider.

Examples include improved support for C# 7.0 (including pattern matching and out variables), and initial support for C# 7.1. Rider now supports the default literal, tuple projection initializers, async main and pattern matching with generics. Simply reference the latest compiler package and make sure to set the language level in your project file. By the way, Rider can also detect if language features from a higher language level are used, and provide a quick-fix to make a switch.

Rider also adds some new code inspections around IEnumerable, and will check XML documentation inheritance to make sure it is valid. This ensures documentation in the IDE as well as generated API documentation is correct.

Code folding and documentation tooltips in F#

Evolving F# support

Rider 2017.2 comes with a series of new features and improvements around F#.

For example, it's now possible to work with .NET Core F# projects, for both SDK 1.0 and 2.0. For F# projects that use Paket instead of NuGet, Rider now disables its automatic NuGet restore on loading such projects. This ensures that projects like Fable load properly in Rider.

We've addressed a set of issues that you faced working with mixed C# and F# code bases, ensuring that F# code is exposed correctly in C# projects.

Rider now enables code folding in the editor. Pretty much any multi-line expression/statement can now be folded or unfolded.

We've also implemented the Comment with Block Comment action, which comments out the current selection with (* and *).

Looking up the documentation never hurts when writing code, and Rider now displays XML doc comments in a tooltip when hovering over documented code.

When you debug, Rider now supports evaluating expressions on hover, allowing us to inspect a variable from within the editor.

Bettere code highlighting in Unity shaders

Unity development

For game developers, we added support for debugging different Unity processes. You can now create a Mono Remote configuration to remotely debug standalone games, such as those running on an Android device. The IDE and debugger now also support working with modularized UnityEngine dll's.

In other notable Unity support news, we've significantly improved our ShaderLab parser, which results in better code highlighting in .cginc files and injected Cg fragments in .shader files. As an additional nice touch, Rider now highlights color values in ShaderLab files, and if you press AltEnter, you can modify the color using a color palette picker.

Generating Unity code is now easier, with file templates for new MonoBehaviour scripts, shaders and tests. Additionally, code completion and generation of event functions are now available in recent versions of Unity.

For mode details on Unity updates, see Rider blog.

JavaScript code arrangement settings in Rider

Better JavaScript and TypeScript support

Courtesy of a newer version of bundled WebStorm, Rider 2017.2 now offers richer support for JavaScript and TypeScript:

  • When you hover over an object while holding Ctrl, the inferred type for the object is displayed in a tooltip.
  • Reworked JavaScript code style settings allow configuring how to order members of a class, such as constructors, fields and methods. To apply these settings, use the Code | Rearrange Code command.
  • When using CSS modules and importing them into a JavaScript file, Rider provides code completion and navigation support for class names in that module.
  • Rider now detects tsconfig.json and takes it into account when analyzing TypeScript files.
  • Code completion and navigation for Angular Material attributes is now available.
  • When using webpack, Rider better understands complex configurations and properly resolves paths in import statements and import suggestions.
Reword a local Git commit

Version control improvements

When you work with Git, Rider now lets you revert and reword local commits. To do this, use the context menu under the Log tab in the Version Control tool window.

From the settings under Version Control | Commit Dialog, you can now customize commit message rules and inspections. Do you put a blank line between the subject and the body? Should the maximum length of a commit message be defined? You can set these and similar rules. In addition, Rider provides quick-fixes for these rules, and reformatting code can also be done inside the commit message.

Make code changes directly from search results

Make changes from search results

In Rider 2017.2, we improved the way you work with results of a textual search using Find in Path (CtrlShiftF).

Search results from the same lines are now merged together. Also, the Preview pane now has a left-hand gutter that displays line numbers, navigation icons, context actions and local change markers. This makes it easy to make small changes directly from a search!

Unit test framework settings

More unit testing improvements

There's more than MSTest support in terms of unit testing in this release. Here's a few more highlights:

  • NUnit tests are now supported for full .NET Framework, .NET Core 2.0, and .NET Core 1.1.
  • All unit test providers now have their own settings pages where framework-specific settings can be tweaked. In addition, it's possible to disable frameworks that are not in use.
  • We've also made performance improvements for solutions that contain large test sets, as well as tests that produce a lot of output (including word wrap).
NuGet tool window in vertical layout

NuGet updates

A number of updates went into Rider's NuGet client. We're now using NuGet 4.3 under the hood, which brings full support for SemVer2 and .NET Core 2.0. Rider adds support for wildcard versions in package references, too.

When referencing packages that are not targeting .NET Core 2.0 (but are known to work with it), the AssetTargetFallback property can be used to define "fallback" target frameworks for project's dependencies. By default, .NET Core 2.0 projects will have this property set to net461, meaning that any NuGet package that is compatible with .NET Framework 4.6.1 or higher can be used without additional configuration. Rider now also includes initial support for this.

You can now install CLI tools packages right from within the NuGet client, without manually editing the .csproj file. For example, this is useful with Entity Framework Core's database migration commands from Microsoft.EntityFrameworkCore.Tools.DotNet.

We made some UI changes as well: for example, you can now toggle position of the package details pane, which is useful if you prefer to keep the NuGet tool window vertically oriented. And when possible, package icons will be rendered in high DPI making everything look more crisp.

Descriptions of base members in the Generate dialog

Even more changes

Here's a short list of other notable changes in this Rider release:

  • More and better code completion suggestions in CSS, JavaScript, TypeScript, .config, .csproj and XML files.
  • Improved Multi-line completion: for instance, import completion in C# is now available when you invoke code completion with multiple text carets set.
  • When generating code, such as overriding or missing members, Rider now shows descriptions of base members that are being overridden or implemented.
  • Import and export of all global settings is available, including both settings coming from ReSharper and the IntelliJ platform.
  • Solution-wide analysis (SWEA) is automatically paused during NuGet restore when running it doesn't make a lot of sense.
Free 30-day trial