Rider（英語版） リリース

• 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

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.

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

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

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

AI

• Rider is continuing to evolve as an open platform that allows you to bring your preferred AI tools into your professional development workflows.
• In addition to Junie, Claude Agent, and Codex in the AI chat, you can now choose from a wider range of agents, including GitHub Copilot and Cursor, and dozens of external agents supported via the Agent Client Protocol. With the new ACP Registry, you can discover available agents and install them in just one click.

Faster solution loading and code completion

• Rider 2026.1 improves performance in areas you notice during everyday work.
• Opening solutions and attaching to running processes is now faster thanks to more efficient indexing of the referenced assemblies. Code completion is also more responsive, particularly for import suggestions, helping you stay in flow with fewer interruptions.
• Code an dalysis has also been optimized, contributing to lower overall IDE overhead.

The latest language support

• C# - Rider 2026.1 brings improvements to code analysis, new inspections, and support for evolving language features. Enhanced support for C# extension members includes better navigation and refactorings, as well as improved quick-fixes that automatically import missing extension members when needed. This release also introduces early support for C# 15 Preview language features, such as collection expression arguments and the [ExtendedLayout] attribute, helping you experiment with new syntax as the language evolves. In addition, several new inspections and style options help catch subtle issues, such as short-lived HttpClient instances or incorrect use of ImmutableArray<T> with collection initializers.
• Improved debugging for F# - Rider's new Smart Step Into for F# support makes it easier for you to choose your step target. The debugger can also display return values for function calls, helping you understand program flow without adding extra logging. Stepping has been improved for async and task expressions, and multiple issues affecting F# debugging have been fixed.

.NET support and productivity improvements

• Support for file-based C# programs - Rider now supports working with single-file C# programs that can be run using dotnet run file.cs. You can open and run a standalone .cs file directly from the IDE, without requiring a .csproj. Rider's editor recognizes file-based programs with top-level statements, #! shebangs, and #: directives, including #:package and #:sdk. Code highlighting, code completion, run markers, and debugging are all available, allowing you to create quick scripts, prototypes, and one-off tools written as a single C# file.
• NuGet Package Manager Console (Preview) - Rider 2026.1 brings NuGet's PowerShell-based workflow into the IDE, offering a Package Manager Console (PMC) that's currently in preview. The new console supports standard NuGet PowerShell commands, as well as commands provided by NuGet packages themselves. Entity Framework Core PowerShell commands are fully supported, allowing you to take advantage of familiar EF Core workflows without leaving Rider. You can run NuGet and Entity Framework Core commands either from the NuGet tool window or directly in the terminal. In the NuGet tool window, you can select the package source and default project using UI controls. In the terminal-based console, this context is displayed in the PowerShell prompt and can be changed using PowerShell commands.
• Azure DevOps: Ability to clone repositories - A new bundled Azure DevOps plugin allows you to clone repositories directly from Rider..
• Viewer for .NET disassemblies - You can now view the native disassembly generated from your C# code without leaving Rider. Once you've installed the new .NET Disassembler plugin, you'll be able to inspect output produced by the JIT, ReadyToRun, and NativeAOT compilers inside the new ASM Viewer tool window.
• Smoother MAUI iOS development workflow from Windows - Developing .NET MAUI applications for iOS from Windows requires connecting Rider to a Mac build host. Rider 2026.1 streamlines this workflow with a new setup experience that automatically prepares the remote environment. When you connect to a Mac, Rider now verifies that the remote system has everything configured, including macOS, Xcode, the .NET SDK, and required MAUI workloads. If any components are missing, Rider can install or update them automatically, helping you get started faster. Additionally, you can now build, deploy, and debug MAUI iOS applications from Windows more reliably. Improved diagnostics and connection stability, and fixed issues that previously prevented MAUI apps from deploying to iOS simulators or Windows devices.

Game development improvements

• Complete mobile development support for Unreal Engine on Android and iOS - Rider 2026.1 fully supports mobile game development for Unreal Engine across both major mobile platforms. This release builds on Rider 2025.3's introduction of debugging support for Android-based mobile and VR devices, adding support for iOS-based mobile and VR ones. On macOS, you can debug Unreal Engine games running on iOS devices directly from Rider. Set breakpoints, inspect variables, step through code, and analyze call stacks - all within the familiar debugger interface. Initial Xcode setup for provisioning and signing is still needed per Apple's requirements.
• Dramatically faster variable inspections for UE projects - Inspecting complex variables while debugging Unreal Engine projects is now much faster and more responsive. Expanding containers no longer slows down your debugging session, making it easier to explore object state and understand what's happening at runtime. This improvement comes from a rewritten parser and evaluator for Natvis expressions used by Rider's debugger. Variable inspection with the rewritten evaluator is up to 87 times faster on warm runs and 16 times faster on cold ones, and the debugger's memory usage has dropped to just over a third of what it was.
• Blueprint improvements
  • Finding usages, event implementations, and delegate bindings across Unreal Engine Blueprints and C++ code is now more reliable, making it easier to trace how gameplay logic connects across assets.
  • Code Vision now supports the BlueprintPure specifier and correctly detects blueprint events implementations in Blueprints. Find Usages has also been improved and now identifies additional BlueprintAssignable delegate bindings.
  • Blueprint usage search now relies on the asset path instead of the Blueprint name, ensuring accurate results even when multiple Blueprints share the same name.
• Faster indexing and lower memory usage for Unreal Engine projects - Working with large Unreal Engine codebases is now noticeably faster and more resource-efficient. In the measurements on Epic Games Lyra sample project, initial C++ indexing is over 20% faster, helping you get to work sooner when opening a project for the first time. After opening an already indexed project, the backend uses approximately 14% less memory, reducing the IDE's footprint and leaving more resources available for the rest of your workflow. Warm startup is also 10% faster, so returning to your project between sessions feels snappier. Rider now also indexes Unreal Engine plugins by default. With the growing use of plugins in Unreal Engine projects and the recent performance gains, indexing plugins by default provides better code analysis and navigation out of the box.
• CMake support for C++ gaming projects (Beta) - Rider 2026.1 introduces Beta support for CMake-based C++ projects, allowing you to open, edit, and build them directly in the IDE. This makes it easier to work with cross-platform projects without switching to another build system. This addition is intended to support game development workflows that rely on CMake, such as projects built around CMake-based engines or tooling. For general-purpose C++ and embedded development, CLion remains the primary JetBrains IDE.
• Redesigned Unity Profiler integration - Performance investigation for game projects has become a first-class workflow in Rider 2026.1, thanks to the redesigned Unity Profiler integration. You can now open Unity Profiler snapshots directly in Rider and analyze them in a dedicated Profiler tool window with a structured view of frames and call stacks. A timeline view shows CPU time per frame, helping you quickly identify slow frames and performance hotspots. Profiler data is tightly integrated with your code. You can navigate directly from profiler frames and call stacks to the corresponding source, while editor gutter indicators display execution time and memory information inline. This integration reduces context switching between the Unity Editor and Rider, allowing you to move more naturally between performance data and code when investigating runtime issues.
• .NET mixed-mode debugging on Windows - Rider 2026.1 introduces mixed-mode debugging, which lets you debug both managed (.NET and .NET Framework) and native (C/C++) code in a single debugging session. This is particularly useful for applications that cross managed-native boundaries, such as those where .NET code calls into native libraries or game engines built from a mix of managed and native components.
• Enhanced Godot editor integration - Rider's Godot integration includes a new add-on that bridges the Godot editor and Rider. When enabled in the Godot toolbar, it automatically configures your Godot editor settings for a smoother development experience in Rider.

Platform and IDE changes

• Ability to work on multiple branches at once with Git worktrees - Rider is continuing to evolve as an open platform that allows you to bring your preferred AI tools into your professional development workflows. With the evolution of AI agents, running multiple tasks in parallel has become a major time-saver, and this is precisely where Git worktrees are extremely handy. To support cutting-edge workflows for AI-boosted software development, Rider now provides first-class support for Git worktrees. Create a separate worktree for an urgent hotfix, hand off another one to an AI agent, and keep working in your main branch - all at the same time, without interruption. Even if you don't use agents, worktrees will save you time on branch switching, especially in big projects.
• Working with databases - The AI chat integration for Junie, Codex, and Claude Agent now offers full, native support for your connected databases. Whether you're using Junie's autonomous planning to refactor data layers or leveraging the reasoning of Claude Agent, you can now query, analyze, and modify your database state using natural language right from the IDE. The same functionality is available for external agents via an MCP server. Data source settings can now be stored in your JetBrains Account via data source templates. Especially nifty for All Products Pack users or anyone who uses multiple instances of JetBrains IDEs, this upgrade allows you to access data source templates and settings in every JetBrains IDE with database functionality.

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

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

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