dotUltimate Releases

• Gameplay Tag in Blueprints usage counter in Code Vision breaks after referencing this tag in more places.
• UE_DECLARE_GAMEPLAY_TAG/UE_DEFINE_GAMEPLAY_TAG_COMMENT usage is not counted.
• Debugger stepping and Watches/Threads refresh take seconds after upgrade to 2026.2.
• Updating multiple NuGet packages via new UI Update button fails: NullReferenceException.
• Fixed RiderLink compatibility with UE <= 5.5.
• .NET Framework + NRT: "Return type can be made non-nullable" warning.
• IDE 2026.2 EAP 8 breaks compatibility with BigData plugin.
• Disabled vfs.windows.use.buffered.directory.stream in platform

Preview of ACP agent support in ReSharper starts with Junie

• JetBrains is building an ecosystem where .NET developers control their AI experience in Visual Studio - no vendor lock-in, no forced choices, just the freedom to use the agents and models that work best for you. The goal is to let you connect agents through the Agent Client Protocol (ACP) and pair them with JetBrains' deep code intelligence without being locked into a single vendor.
• ReSharper 2026.2 takes the first step in that direction with preview support for Junie, JetBrains' own LLM-agnostic agent, now available via ACP in Microsoft Visual Studio. You can switch from AI Chat to Agent mode in the AI Assistant tool window and ask Junie to generate and edit code, refactor complex implementations, run terminal commands, manage Git workflows, explain legacy code, and suggest architectural improvements.
• To bring Junie to Visual Studio, be sure to select the AI Assistant plugin for installation when updating ReSharper. A free trial is available if you don't have a JetBrains AI subscription yet.
• Regional restrictions on the availability of AI features in Mainland China apply.

Debugging for VS Code-compatible editors

• The most requested feature for ReSharper in VS Code is here. The latest update introduces the initial version of debugging for VS Code-compatible editors, including VS Code, Cursor, Google Antigravity, Devin Desktop, and Kiro. Built on the same core engine that powers JetBrains Rider, it brings breakpoint management (including conditional, hit-count, dependent, and tracepoints), real-time variable and expression inspection, full step navigation, and launch-and-attach support directly to your editor.
• This makes ReSharper the most complete .NET option available on Cursor, Antigravity, Devin Desktop, and Kiro, as well as other VS Code-compatible editors.

Code analysis and refactoring

• C# support updates - ReSharper 2026.2 improves its C# code analysis with more cases where collection expressions can be used. The new inspections help you keep code concise and, in some scenarios, avoid creating intermediate collections. Support for upcoming C# 15 language features is also being actively developed as the compiler evolves, with complete language understanding planned for the next major release.
• Enhanced Extract Method refactoring - Extract Method now detects exact and parameterized duplicates of the selected code within a file and lets you choose which occurrences to replace as part of the refactoring. This makes it easier to consolidate repeated logic into a single, well-named method without cleaning up each duplicate manually.
• '.editorconfig' and Roslyn analyzer integration - You can now adjust .editorconfig settings for compiler warnings directly from the Alt+Enter menu as warnings appear in the editor. ReSharper's code analysis also follows Roslyn analyzer configuration more accurately, including settings defined in .editorconfig files and suppression rules applied with #pragma directives.
• Enhanced Import missing references popup experience - The Import missing references popup has been revamped for a smoother experience. JetBrains have optimized its placement, got rid of flickering, and ensured it stays out of the way while you type, so it no longer interrupts your workflow.

C++ updates

• C⁠+⁠+⁠26 reflection: Initial support for C⁠+⁠+⁠26 reflection, laying the groundwork for next-generation compile-time metaprogramming.
• 'constexpr' evaluation updates: Support for memory allocations and exceptions during evaluation of compile-time code.
• ISPC support: Syntax highlighting, code analysis, and navigation for files using the ISPC language.
• Code analysis: New inspections for applying internal linkage, using designated initializers in aggregate initialization, and detecting qualified calls to overridden virtual functions.

Performance

• Processing of .cshtml and .razor files is now faster and more memory-efficient, thanks to cached parsed syntax trees, improving the performance of features such as Find Usages and refactorings. Memory allocations have been significantly reduced in multiple areas, speeding up indexing during startup.

Improved tool support in Out-of-Process mode

• dotTrace, dotMemory, and the Monitoring tool now work when ReSharper runs in Out-of-Process mode.
• With Monitoring available in OOP mode, the transition announced in the previous release is complete: Dynamic Program Analysis (DPA) has been retired in 2026.2, and its core capabilities continue through the new Monitoring experience.

ReSharper now includes integrated profiling and coverage tools

• Starting with ReSharper 2026.2, the tools for performance and memory profiling, and code coverage are installed automatically as part of your ReSharper installation. There's nothing extra to select or download; the tools are set up for you and ready to use inside Visual Studio from the moment you install. You can profile performance, track memory, and check coverage without ever leaving your workflow.

Updated dotUltimate offline installer for Windows

• The dotUltimate offline installer for Windows is intended for administrators who deploy ReSharper and other dotUltimate tools across teams, managed environments, or machines with limited internet access. In 2026.2, this offline installer is distributed as a .ZIP archive instead of a standalone .EXE file. The lightweight online installer remains available for users who do not need the offline package.
• After downloading the offline package, extract the archive and run the included dotUltimate installer. The .ZIP archive contains two files: the dotUltimate installer executable and a companion .dat file. The installer executable contains the product binaries except Rider; Rider binaries are stored in the .dat file. The installation flow and supported scenarios remain the same, but deployment scripts or internal instructions may need to include the extraction step and keep both files together before running the installer.

C++ support

• C⁠+⁠+⁠26 reflection - ReSharper C⁠+⁠+ 2026.2 introduces initial support for C⁠+⁠+⁠26 reflection. Reflection is widely considered one of the most transformative features coming to C⁠+⁠+, enabling compile-time introspection and code generation. With this update, ReSharper C⁠+⁠+ recognizes the core reflection primitives:
  • The ^^ (reflect) operator, which produces a std::meta::info value representing the reflected entity.
  • The [: ... :] (splice) syntax, which converts a reflection value back into a language construct.
  • Compile-time queries on reflected types, members, enumerators, and other entities.
  • Note: Of the major C⁠+⁠+ compilers, currently only GCC 16 supports C⁠+⁠+⁠26 reflection.
• Related C⁠+⁠+26 features - Support for reflection is complemented by two related C⁠+⁠+26 language features:
  • ReSharper C⁠+⁠+ now supports consteval { ... } blocks, which are evaluated at compile time and can inject declarations into the enclosing scope. consteval blocks provide a clean way to trigger compile-time side effects, making them particularly useful for practical metaprogramming with reflection.
  • User-defined annotations can now be attached to declarations and queried through the reflection API, enabling custom metadata-driven code generation.
• 'constexpr' evaluation - ReSharper C⁠+⁠+ 2026.2 extends its constexpr evaluator with two important capabilities:
  • The evaluator now supports dynamic memory allocation during constant evaluation - a feature introduced in C⁠+⁠+20. This enables correct evaluation of constexpr code that uses new/delete or standard containers like std::vector and std::string.
  • The evaluator now supports C⁠+⁠+26 constexpr exceptions and handles try/catch and throw expressions during constant evaluation.

ISPC language support

• ReSharper C⁠+⁠+ 2026.2 adds support for ISPC (Intel SPMD Program Compiler), a language designed for high-performance parallel programming on CPUs. ISPC is widely used in game engines, rendering systems, and scientific computing, including Unreal Engine projects.
• ReSharper C⁠+⁠+ now provides syntax highlighting, code analysis, navigation, and coding assistance for ISPC files, bringing the same quality of editor support you expect for C⁠+⁠+ to your ISPC code.

Unreal Engine

• Performance - This release brings major performance improvements during startup in Unreal Engine projects. ReSharper C⁠+⁠+ now uses the project information from UnrealBuildTool to speed up initial indexing by analyzing only files included in the Unreal Engine project model. Combined with other optimizations, including improvements in multithreaded indexing, this results in a significant speedup. According to the measurements on the Lyra sample solution, initial indexing of C⁠+⁠+ code is up to 55% faster, and loading C⁠+⁠+ caches from serialized data during a warm IDE startup is up to 35% faster. You can disable the new indexing behavior by unchecking the Index only files in Unreal Engine project model option on the Code Editing | C/C⁠+⁠+ | Unreal Engine settings page.
• Blueprint support - ReSharper C⁠+⁠+ now also discovers usages of gameplay tags inside Blueprint assets and shows them in Code Vision and Find usages results, giving you a complete picture of where your gameplay tags are used across the project.

Code analysis

• Internal linkage - The new Entity can have internal linkage inspection detects functions, variables, and classes that are not used outside their translation unit. You can use the provided fixes to mark such entities static or move them into an anonymous namespace, which helps the compiler optimize and prevents unintended linkage conflicts.
• Designated initializers in aggregate initialization - ReSharper C⁠+⁠+ now suggests adding designators to braced initializer lists in aggregate initialization. Designated initializers, available since C⁠+⁠+⁠20 and C99, make it explicit which member each initializer corresponds to, improving code readability and reducing the chance of errors when members are reordered. A corresponding context action is also available and can be used even when the inspection is disabled.
• Calls to overridden base functions - Another new inspection detects qualified calls to base virtual functions that are overridden in a derived class. Calling a base-class virtual function directly rather than through virtual dispatch can be a source of subtle bugs, and this inspection helps catch such cases.
• [[jetbrains::used_implicitly]] attribute - ReSharper C⁠+⁠+ now recognizes the [[jetbrains::used_implicitly]] attribute, which can be applied to symbols to suppress inspections that would otherwise suggest changing their signature or linkage. This is useful for symbols that are used through reflection, code generation, or other mechanisms not visible to static analysis.

Coding assistance

• Refactoring improvements
  • Invoking Inline Function on a function declaration now inlines all usages of the function throughout the codebase, not just the usage under the cursor.
  • The Extract Method refactoring is now available inside lambda bodies, letting you factor out parts of a lambda into a separate function.
• Context actions
  • A new context action lets you easily toggle the const qualifier on a member function.
  • You can now quickly insert a #pragma clang diagnostic ignored directive to suppress a specific Clang diagnostic on the current line.
  • In Unreal Engine projects, you can now copy the include path for the currently opened header file from the Copy Code Reference menu, making it easy to paste the correct #include directive.

AI integrations

• GitHub Copilot now built into Rider - GitHub Copilot is now a natively integrated agent in JetBrains IDEs, as the result of a direct partnership between JetBrains and Microsoft. Unlike the previous ACP Registry setup, Copilot is available out of the box and provides a more cohesive experience. You can access Copilot directly from the agent picker in the AI chat. Authentication is handled through OAuth with your GitHub account, and an active GitHub Copilot subscription is required.
• AI completion now supports third-party providers - AI completion is an in-editor code suggestion experience that combines inline completion and edits that go beyond the cursor. Available to all JetBrains AI users out of the box, it's powered by JetBrains-trained models, without spending AI credits. With the recent update, you can now connect your own AI completion model, configured independently from your agent provider. Supported providers include OpenAI-compatible endpoints, such as LM Studio or llama.cpp with models like Zeta or SweepAI, and Mercury by Inception Labs.

Agent skills

• Rider 2026.2 deepens what your AI agents know about your stack. Bundled skills ship with the IDE as built-in workflows, helping agents handle specific tasks without working out every step themselves. Other skills you add through the agent skills manager, so you stay in control of what your agents can do. Both give agents reusable, IDE-grade knowledge for more relevant suggestions and more reliable results.
• Support for .NET Agent Skills - Rider now makes it easy to discover and install official Microsoft Agent Skills directly from the IDE. In 2026.2, Rider includes three Microsoft-maintained skill repositories:
  • .NET Skills for common .NET and C# development tasks.
  • Aspire Skills for cloud-native application development with .NET Aspire.
  • Azure Skills for working with Azure services and infrastructure.
• Code quality check hooks for Claude Code - Rider now ships quality-check hooks for Claude Code in any language supported by Rider. Enable the skill in the Settings, and Rider will validate every change an agent makes before it's allowed to continue, catching code issues, inspection findings, and even formatting inconsistencies. Errors will block the task from being marked complete, while warnings come back as feedback the agent can act on. You and your IDE set the quality bar, not the agent.
• Safer refactoring skills - Agents can now drive Rider's refactoring engine for renaming symbols, moving types, extracting methods, and reorganizing namespaces, working from Rider's understanding of symbols and usages instead of brittle text search. Broad changes become safer to make and easier to review.
• Game-aware skills for Unreal Engine - Rider 2026.2 adds three Unreal Engine skills to the agent skills manager, so your agent approaches Unreal projects as Unreal projects, not just large C++ codebases:
  • ue-code-authoring handles UE C++ changes. The agent inspects existing project patterns, edits your .h and .cpp files, and uses Rider's diagnostics, linting, build checks, and formatting to catch Unreal-specific traps around reflection macros, generated headers, module dependencies, includes, API macros, and UObject conventions.
  • ue-live-debugging tackles crashes and runtime issues, using Rider's symbol search, call hierarchy, breakpoints, stack and frame inspection, and expression evaluation to investigate what actually happened.
  • ue-test-authoring picks the right testing approach, whether Automation, CQTest, Functional, Gauntlet, or LowLevel, and writes tests that follow your project's conventions.

Performance

• Starting up and launching the debugger - Rider 2026.2 makes the early moments of a session quicker on Windows, from opening a solution to hitting the debugger for the first time. JetBrains have optimized how Rider enumerates project files at startup, so the IDE discovers directories and filesystem changes faster. Project model updates become available sooner, and opening large solutions feels smoother. Launching the debugger is quicker, too. In the benchmarks, Rider cuts about 2.8 seconds from debugger launch time for .NET applications on Windows. The difference is especially noticeable in smaller projects, where app startup should feel nearly immediate.
• Switching branches and recovering from big file changes - Once you're working on a project, the slowest moments tend to come when a lot changes at once, such as switching Git branches. Rider 2026.2 improves these in two independent ways. First, branch switching itself is considerably faster thanks to improvements in Rider's Roslyn integration. In tests, it's generally 2-3x faster, with one previously problematic case improving from 8 minutes down to 5 seconds. Second, whenever Rider has a lot of files to take stock of at once, whether after a branch switch or when opening a large project for the first time, it needs to see what's on disk before its project view, search, and navigation are fully reliable again. JetBrains have made file discovery faster, so you spend less time waiting for Rider to sync up. In internal testing on a large solution of around 300 projects, simulating a Git branch switch, this step ran roughly a third faster. File discovery is just one part of the catch-up process, so how much you feel it depends on the workflow. You're most likely to notice it on projects with deeply nested folder structures.
• Lower memory use on the backend - Rider's backend now holds onto less memory, freeing it up for the rest of your work. In internal tests, backend processes used around 7%-8% less, with the relief most noticeable on larger solutions where memory pressure is highest.
• Performance enhancement for Unreal Engine - If you open an Unreal Engine project using the generated .sln, you will see much faster initial indexing times, in line with opening the project through .uproject. In this scenario, Rider now uses the project information from UnrealBuildTool to speed up initial indexing by analyzing only files included in the Unreal Engine project model. Initial indexing of C++ code is twice as fast in 2026.2 compared to 2026.1 when opening the .sln from the Lyra sample solution, with a similar speedup when loading C++ caches from serialized data during a warm IDE startup.

UX/UI

• The ability to preview suggested code changes - Rider now gives you a clearer way to evaluate quick-fixes and context actions before applying them. The new intention previews show what the selected action will change directly from the code actions menu, helping you understand the result at a glance and choose the right fix with more confidence. The preview supports diff-based output with syntax and identifier highlighting, so you can quickly compare the before and after states without interrupting your flow. This is especially helpful for broader changes, including fixes that affect multiple files, where seeing the exact impact upfront makes code actions feel safer and easier to trust.
• Improved NuGet tool window - Rider's NuGet tool window has been redesigned to make dependency management clearer in larger solutions. Browsing for new packages, scrolling and loading them, managing installed dependencies, and reviewing available updates now have separate, more focused paths, so it's easier to see what needs attention and update packages when you're ready.

.NET development

• File-based C# app templates - Rider 2026.2 adds a dedicated C# file-based app template, making it easier to create, edit, and run file-based C# apps directly from the IDE. It's a lightweight workflow for scripts, repo utilities, CI helpers, and quick tasks that don't need a full project setup.
• Hot Reload for WPF projects - Rider 2026.2 introduces WPF Hot Reload, letting you edit XAML while your WPF app is running under the Rider debugger and see saved changes applied in place. You can tweak layouts, styles, templates, and resources without rebuilding, restarting, or navigating back to the same screen.

Code analysis and refactoring

• C# support - Rider's C# code intelligence is powered by ReSharper. Rider 2026.2 includes the latest ReSharper updates for .NET code analysis, refactoring, analyzer configuration, and language support. For the full breakdown, see the What's New in ReSharper 2026.2 page.
• C++ support - Rider 2026.2 introduces initial support for C++26 reflection, the most anticipated addition to the C++ language in recent years. The reflect operator (^^), splicing ([: ... :]), and consteval blocks are now recognized by the editor, providing syntax highlighting, code analysis, and coding assistance for reflection-based metaprogramming. Additionally, Rider extends its constexpr evaluator with support for dynamic memory allocations and exceptions during constant evaluation. Other updates to C++ support include new code inspections and refactoring enhancements. Rider's C++ intelligence is powered by JetBrains ReSharper C++.
• F# support - Rider 2026.2 brings several F# improvements. A new action lets you quickly disable and restore compiler warnings; importing types and other symbols from errors is more reliable; C# 14 interop is smoother; and F# debugging has received additional fixes.

Game development

• Performance breakthroughs: Large Unreal Engine projects should open and become ready to work with faster. Opening a generated .sln now benefits from the UnrealBuildTool project model, with C++ indexing running roughly twice as fast in the benchmarks. See the Performance section.
• Game-aware AI agent skills: Code quality hooks can validate agent-generated changes in game projects, while Unreal Engine-specific skills help agents with UE C++ code authoring, live debugging, and test authoring. See the Agent skills section.
• First-class debugging: Natvis support arrives on Linux and macOS, so inspecting native data structures works consistently across platforms, alongside expression evaluator enhancements. See the Debugging section.
• Better navigation for UInterface - Tracking Unreal Engine UInterface implementations is now more direct. Usage information is shown for the I-prefixed implementation interface, where Unreal interface functions are declared and implemented by gameplay classes. Find Usages also now includes Blueprint usages for Unreal interfaces, not just C++ references, making it easier to track where an interface is used across code and assets.
• Find Unreal Engine Gameplay Tag usages in Blueprints - Gameplay Tags are easier to follow across both C++ and Blueprints. Usages inside Blueprint assets now appear in Code Vision and Find Usages results, so you can see where a tag is used across the project without leaving Rider. This is especially useful for projects built around the Gameplay Ability System, where tags often drive ability activation, blocking, cancellation, effects, and gameplay events. Rider detects tag usages in key Gameplay Ability System Blueprint nodes and GameplayAbility asset properties, and now shows Code Vision for both Gameplay Tag declarations and definitions in C++.
• ISPC support - High-performance CPU code gets first-class editor support with ISPC (Intel SPMD Program Compiler), a language used in game engines, rendering systems, and scientific computing, including Unreal Engine projects. ISPC files now get syntax highlighting, code analysis, navigation, and coding assistance, bringing the same quality of editor support you expect for C++ to your ISPC code.
• Professional Godot support - Godot development in Rider feels more complete, polished, and reliable in 2026.2. The release adds new project templates, better GDScript support and formatting, improvements for working with scenes, and many fixes based on direct feedback from the Godot community.
• New configurable GDScript formatter - Keeping GDScript code consistent is now easier with one of the most capable and configurable GDScript formatters available today. Built directly into the IDE, it handles spacing, indentation, wrapping, tabs, and common GDScript layout rules, with language-specific code style settings available in Rider's standard settings UI. Unlike many external formatters, Rider lets you reformat exactly what you need: a selected fragment, a single file, or the whole project. The formatter also powers smarter editing behavior as you type, including indentation on Enter, smart outdent after control-flow statements, and splitting long string literals across lines. The result is a native GDScript formatting experience that feels consistent, flexible, and ready for real Godot projects.
• Drag Godot scene nodes into code - Referencing Godot scene nodes from GDScript takes less manual wiring. Drag nodes from the Scene Preview tree directly into the editor, and Rider will insert the right node path or variable declaration for you. The behavior follows Godot Editor conventions: drag a node normally to insert its path, hold Ctrl to generate an @onready variable, or hold Alt to generate an @export variable. Multi-selection is supported too, including nested nodes, with paths resolved relative to the script you are editing.
• JetBrains Rider Integration add-on on the Godot Asset Store - The official JetBrains Rider Integration add-on is now available on the brand-new Godot Asset Store. It simplifies setting up Rider as an external editor for Godot projects, giving you direct access to Rider's code insight, navigation, inspections, and debugging support while working on Godot games and add-ons.
• Support for Godot Autoloads and UID references - Godot project-wide APIs and resources are easier to navigate from GDScript. Autoloads and uid:// resource references are now resolved more accurately, with proper highlighting, documentation, and navigation for globals configured in the Godot project settings, so singleton-style project APIs feel like first-class symbols in the editor. Rider also resolves uid:// references in load and preload calls, making resource links created by Godot work more naturally in code insight and navigation.
• Project templates for game development - Getting started with a new game project is now easier in Rider. The New Project dialog features a dedicated Game Development category that brings game-engine-specific templates directly into the IDE. Godot projects and add-ons now have ready-made starting points in the IDE, including templates for Godot Asset Store add-ons such as script-based assets, editor plugins, and native C++ GDExtensions. Each template comes with a preconfigured project structure, build settings, and run configurations, helping you get up and running faster. JetBrains have also added a new CMake game project template for native game development workflows, laying the foundation for a growing collection of game development project templates in future releases.
• CMake support is now out of Beta - Native game development workflows get a more complete CMake experience now that Rider's CMake support is out of Beta. CMake projects benefit from fixes across the workflow and convenient gutter actions for running and debugging targets directly from the editor. JetBrains have also added support for project files that are not explicitly listed in CMakeLists.txt, helping Rider understand more of the code that belongs to your project. Because enabling this for very large projects can increase indexing scope and affect performance, the option is turned off by default and can be enabled manually in settings.

Debugging

• Improved source generator debugging - Debugging source generators should now work more reliably with newer SDKs on Linux and macOS. Starting a debugging session no longer requires a successful build of the target project, and target project files are no longer compiled before startup, which should make the workflow faster.
• Basic Natvis support on Linux and macOS - Rider 2026.2 brings basic Natvis type visualization to the C++ debugger on Linux and macOS, expanding its availability beyond Windows. Existing Natvis files, including visualizers that ship with popular C++ libraries, can now be used with LLDB on Linux and macOS systems. This also improves Godot C++ debugging: Rider now supports the godot-cpp.natvis, making Natvis the recommended visualization path for Godot types in Rider across supported platforms. If you previously registered GodotFormatter manually in .lldbinit, remove that registration and use the Natvis visualizers instead.
• Improved C++ expression evaluation on Windows - Rider 2026.2 improves C++ expression evaluation when debugging on Windows. The update makes more expressions work reliably with watches, conditional breakpoints, and Evaluate Expression operations, including function calls (with parameters) from Natvis visualizers and a number of fixes around comparisons, persistent variables, intrinsics, and function calls. One practical improvement is smoother string comparison during debugging. Unreal Engine string types such as FString and FName, as well as standard library string types, now handle common comparison scenarios (e.g. myFString == "Hello"), including comparisons in conditional breakpoints.
• Debugger stepping improvements - Stepping is more predictable in Rider 2026.2. Step Into now lands where you expect, instead of dropping you into runtime or standard-library code, and clearer highlight ranges make it easier to pick which method to step into. When a statement has several method calls, already-visited ones stay highlighted as you step out, so you can always see where you are in the statement. Return values shown after stepping over or out are cleaner and more accurate, and debugger hints now keep a stable, consistent order instead of reshuffling on each step, so the ones you care about no longer get pushed off the right edge of the screen.

Cloud-based development

• Built-in Azure Functions support - Azure Functions support for local development is moving from the separate Azure Toolkit plugin directly into Rider. You can now work with Azure Functions projects without installing any additional plugins, including creating projects and triggers, running and debugging functions, using Azurite integration, and more. Rider 2026.2 also adds the ability to create an Azure Functions trigger from the project creation dialog. In addition, Azure Functions projects can now be debugged inside a Docker container, extending the Docker debugging workflow that was previously available only for regular .NET projects.
• New in Azure DevOps support: Pull requests - Rider 2026.2 expands Azure DevOps support with the introduction of pull requests. The new Azure DevOps tool window lets you list and filter pull requests, review changed files, vote, complete existing PRs, and create new ones without having to switch to any external tools. You can review PRs in the context of your project with full access to Rider's code insight, navigation, and editing features.

Web development

• TypeScript 7 support for faster workflows with large codebases - Large TypeScript codebases don't have to feel slow. TypeScript 7 rewrites the compiler and language server in Go, and the difference is noticeable immediately. In testing, project load time on the Kibana codebase dropped from 12 seconds to 3 seconds, which means editor responsiveness has improved roughly fourfold. Rider 2026.2 supports TypeScript 7 as the default for projects already using it, with an opt-in upgrade path for those still on earlier versions. You get the full speed benefit immediately - no full project migration required on day one. For teams on large TypeScript monorepos, this is a day-one upgrade.

• AI Licensing
  • Error message "AI Free license cannot be used when AI Pro Trial is available".
• Installation
  • Provide feedback button does nothing.
• IntelliSense (Code Completion)
  • Completion window width is not collapsing back if it was scrolled by mouse wheel.
• Licensing and Evaluation
  • ReSharper attempts to refresh License Vault ticket offline and shows an error before 48 hours.
  • License Vault: Only one VS instance receives a valid offline ticket when starting two instances offline.
  • License Vault: Offline ticket from one VS version is not reused by another VS version.
  • License Vault: ReSharper requires license authentication for each active VS instance.
  • ReSharper loses authentication on restart.
• Live Templates
  • Templates Editor: "Choose Macro" dialog is not styled properly.
• Platform - VS Integration
  • The specified option is not valid in this scope: TextViewHost[PATH].
  • System.ObjectDisposedException: Cannot access a disposed object. Object name: 'LeftEdgeSpacerMargin'.
• UI
  • AI Assistant tool window in VS 2026 doesn't draw the corners properly.
  • Wrong Test Pass Icon in Visual Studio 2026.
  • Indents for selection are not symmetrical.
  • "Invisible" fluent icons on the R# settings page with dark theme in VS.
  • Incorrect corner radius in JPM.
• XAML
  • Xaml intellisense incorrectly sees Maui Community Toolkit AppThemeColor bindings as invalid (Maui).

• NuGet
• "Open the NuGet PMC" action doesn't work.

• IntelliSense (Code Completion)
  • Completion window width is not collapsing back if it was scrolled by mouse wheel.
• Live Templates
  • Templates Editor: "Choose Macro" dialog is not styled properly.
• Platform - VS Integration
  • Noticeable resizing of Alt-Enter submenus on non-main display with different scaling.
  • "Middle-click to scroll" locks cursor in hand mode for the file.
  • Visual Studio becomes topmost window after opening Find Results tool window.
• UI
  • AI Assistant tool window in VS 2026 doesn't draw the corners properly.
  • Wrong Test Pass Icon in Visual Studio 2026.
  • "Invisible" fluent icons on the R# settings page with dark theme in VS.
• XAML
  • Compiled bindings: adding x:DataType breaks the code analyzer.
  • MAUI Binding data source is not recognized by IntelliSense.

• Android Plugin
  • Running Release builds directly from within Rider causes the app to crash on launch due to missing symbols.
  • Error XA5300 : The Android SDK directory could not be found.
• Build
  • Rider doesn't rebuild/apply changes in referenced library when building a dependent project.
  • MAUI App Deployment: Failed to find application bundle after deployment.
  • Metadata file 'MauiApp7/MauiLib1/obj/Debug/net10.0-ios/ref/MauiLib1.dll' could not be found.
  • Fix failed MAUI solution build via Console because of APK file isn't found.
  • "Unable to evaluate the APK file path" error after building the solution.
• Code Analysis
  • 'and!' in task expression gives error in F# script.
  • Provided types from F# type provider are not detected.
• Quick Documentation
  • Quick documentation is not shown on hover (HtmlProvider)RIDER 135675 Issue not yet fixed.
• VCS - Git
  • Show diff preview on single click still available in settings of Commit tab.
• No subsystem
  • Inlay rename refactoring works slow with AI suggestions.

ReSharper

• XAML
  • Avalonia: Added support for null conditional operator in bindings.
  • Added support for Avalonia 12 bindings.

Rider

• CMake
  • Project with both sln and cmake may show wrong UI.
• Code Analysis
  • Suppressed warnings appear in solution-wide analysis.
• Code Highlighting
  • Code highlight broken on "_g.cs" source generator generated file.
• Debug
  • Rider C++/LLDB: Natvis visualization displays enum values as numeric instead of enum names.
  • Can't set variables via debugger.
  • [Split Debugger, RemDev] Navigate to thread in parallel stack action doesn't work.
• Debug - Evaluation
  • Rider C++/LLDB: Inconsistent display of enum flags in debugger.
• Global Navigation and Search
  • 'Go to File' highlights the whole file as usage.
  • Search everywhere: search with prefix filters leads to no results if the filter is written before the request.
  • FQN lookup doesn't work for symbols in 2026.1 versions.
• Hot Reload
  • Hot Reload 3 dots button doesn't have a tooltip.
• Internals
  • Force-disable support for Wayland in Rider 2026.1.
• Live Templates
  • Live templates: neither Constant value nor Comma-delimited list of values are displayed.
• MCP
  • Fixed reformat API for MCP tools.
  • Rider MCP build_project tool does not work.
  • Rider MCP get_file_problems does not work.
  • Move Type to Another Namespace for MCP.
• Project Systems
  • Creating a Unreal class from "All classes" tap creates class from Common list.
  • Multiple internal errors in the file system cache with Unity 6.
  • File-based apps that target older frameworks break directive prefix.
• Project Templates
  • Can't change Aspire templates package.
• Refactorings
  • Not able to rename a file.

ReSharper

• Code Analysis - VB.NET
  • Incorrectly flags GetType() call.
• Command Line Tools
  • Running jb command tool causes multiple Roslyn exceptions.
• Crash
  • "ExecuteIfAlive after termination of lifetime took too much time" Runtime error on closing Visual Studio.
• Licensing and Evaluation
  • Error 403 requesting license server because of missing User-Agent header.
• Live Templates
  • Comma-delimited list of values is empty after upgrade.
• Platform - Component Model
  • CSharpLanguageLevelProjectProperty-related exception occurs when opening the options menu.
• Platform - Project Model
  • ReSharper linting broken for .NET 8 and .NET 9 projects after Visual Studio 2026 installation.
• Platform - VS Integration
  • Flickering and lag issues in ReSharper integration after VS 2026 update to 18.4.0.
  • Multi-Caret copy copies everything into a single line.
• Psi - VB.NET
  • Fail to parse xml in named argument.
• Refactorings
  • Move to namespace context action no longer working.
  • Add 'params' modifier should not be available on extension receiver parameter.
• UI
  • Completion (intellisense) Fluent style icons.
  • Regression: Unreadable unit test group ordering.
• XAML
  • Avalonia add support for null conditional operator in bindings.
  • Support Avalonia 12 bindings.
• No subsystem
  • Ensure logs are flushed when an error Is logged.

ReSharper C++

• C++
  • u8 string and character literals in C should have unsigned char underlying type.
• Caches
  • Redundant memory usage in UE4AssetsCache.
  • Signals for monitoring added/removed symbols.
  • Hang in CppLinkageEntityCache.FindEntitiesBySymbols.
• Code Style - Formatter
  • Do not place the semicolon on a separate line in a do-while statement.
• Project Model
  • Unresolved symbols are not highlighted in red inside a newly created file.
  • C language standard is wrong in a CMake project using clang.
  • ClangCL toolset shouldn't be used when the toolset name is Clang.
• Unreal Engine
  • Hang in blueprints cache.
• No subsystem
  • STOFL in type presentation.

ReSharper 2026.1

• Enhanced performance monitoring - All runtime behavior insights can now be displayed in a single tool window.
• Expansion beyond Visual Studio - Use ReSharper in VS Code-compatible editors like Cursor and Google Antigravity.
• Improved C# support - Better handling of extension members, new inspections, and early support for upcoming features.
• More stable Out-of-Process mode - Over 70 fixes for improved reliability.
• Modernized editor UI - Updated completion, tooltips, and popups with better scaling.

ReSharper C++ 2026.1

• ReSharper C⁠+⁠+ 2026.1 delivers faster startup times and reduced memory usage. This release adds support for the C⁠+⁠+⁠26 #embed directive and other new language features. Coding assistance improvements include auto-import for C⁠+⁠+⁠20 modules and new postfix completion scenarios. Unreal Engine developers benefit from improved Blueprint integration and compatibility fixes for the upcoming Unreal Engine 5.8.

Rider 2026.1

• Rider 2026.1 brings improved support for the .NET ecosystem and game development workflows, as well as refinements to the overall developer experience.

Rider

• Debugger is breaking on BreakForUserUnhandledException although exceptions are disabled.
• NETSDK1005 error when building projects with netstandard2.0 dependency project references.
• Rider MCP project-related tools return an empty list.
• Can no longer deploy APK to emulator or physical device after 2025.3.2 update.
• Can't upload APK file into physical Android with 2026.1 EAP1 and 2025.3.2 because of Fast Deployment.
• Failed to upload application APK file to device.
• RiderLink Installation navigation button doesn't work.
• Designer can't resolve dynamically loaded types.
• Aspire template does not fit.
• Available Packages dropdown overlaps Change Template Version dialog.
• Rider no longer finds Unity 'CGIncludes' shader folder (as of at least 6.3.2f1) because it moved.
• Re# CLT (inspectcode) ignores "namespace providers for Unity".
• Plugin suggester based on project dependencies doesn't work.
• Aspire template projects update.
• Console output does not auto-scroll when running TUnit tests via Run.
• Install .NET Aspire button not working.
• Rider scrolls to the wrong place in the file after jumping to implementation.
• Incorrect TFM is shown in the "Run/Debug Configurations".
• Warnings when compiling RiderLink.

ReSharper

• ReSharper not working with .slnx Solution and AdvancedInstaller Project.
• "CS1998" false-positive warning: "Async method lacks 'await' operators and will run synchronously".
• InitializeComponent being incorrectly flagged in MAUI projects.
• "Generate Partial" + "partial keyword completion" for event uses get/set instead of add/remove.

Rider

• Agent Client Protocol (ACP) agent registry support - You can now browse and install ACP-compatible AI agents directly from a curated registry in the AI Chat tool window. ACP defines a standard protocol for AI coding agents, letting Rider connect to any compatible agent without custom integrations. Users can add agents from the registry and use them immediately in AI Chat.

Rider

• Plugin suggestions based on project dependencies are shown again.
• Go to Implementation and Ctrl+Click navigation no longer scrolls the editor to an unexpected position after opening the target file.
• Remove (Ctrl+X) in the Find tool window now removes the selected entry from the results list again.
• InitializeComponent calls in .NET MAUI projects are no longer incorrectly flagged as errors by code analysis.
• .NET MAUI apps can now be deployed and run on physical Android devices when a RuntimeIdentifier is explicitly specified in the project file.
• Solutions with multi-targeted .NET projects (e.g. MAUI projects targeting both platform-specific and plain .NET frameworks) now build correctly from a clean state, including projects that reference them.
• Hot Reload now works correctly in projects that use the C# interceptors feature.
• Hot Reload now works correctly for Blazor WebAssembly standalone projects targeting .NET 10.
• Unreal Engine code vision inlays are now vertically centered relative to the line they annotate, restoring correct alignment in the editor.
• Solution-Wide Error Analysis now reuses precalculated diagnostics from document analysis, reducing update latency while typing.
• The ConstantExpected inspection now respects the [ConstantExpected] attribute transitively and no longer raises warnings when values are passed through annotated parameters.
• The OutParameterValuesAlwaysDiscarded inspection no longer reports false positives for out parameters used in C# 14 extension member syntax.
• Recursive calls are now correctly indicated in the gutter for C# extension members.

ReSharper

• InitializeComponent calls in .NET MAUI projects are no longer incorrectly flagged as errors by code analysis.
• The ConstantExpected inspection now respects the [ConstantExpected] attribute transitively and no longer raises warnings when values are passed through annotated parameters.
• The OutParameterValuesAlwaysDiscarded inspection no longer reports false positives for out parameters used in C# 14 extension member syntax.
• Recursive calls are now correctly indicated in the gutter for C# extension members.
• The bundled Unity plugin now works correctly in ReSharper Command Line Tools.
• Fixed an issue that could prevent memory profiling from starting on systems where the Microsoft-Windows-RPC ETW provider is already in use (for example, by security software).