Rider Releases

JetBrains Air in Rider - one place to run your agents and verify their work

• As of this release, Rider ships with Air, a new layer for agentic development. Work with the coding agents of your choice, and run, track, and verify multi-agent workflows inside your IDE, where code intelligence helps agents make fewer wrong turns and gives you the tools to review every change before it ships.
• Your agents, your models, your subscriptions – with Junie Lite for free
  • Air works with Claude Agent, Codex, Gemini, GitHub Copilot, Junie, OpenCode, and other ACP-compatible agents. It detects the agents already installed on your machine so you can connect them in a click, and you can add more from the agent registry.
  • Your existing setup carries over, too: provider subscriptions, API keys, and even a custom base URL all work, with no JetBrains AI subscription required. Run Claude Agent on your Claude subscription in the terminal or in a full-screen IDE tab, use other agent subscriptions in the chat or terminal, and switch between subscriptions at any moment, even mid-session.
  • Air includes free AI with the Junie Lite configuration, so you can use an agent without a subscription. You only need a JetBrains Account.
• A central workspace to review changes and guide the agent
  • Review an agent's changes with the surrounding code and your project tools in view, and send feedback straight back to the agent. Anchor a note to a specific line in the diff, or comment directly from the code, so the agent gets concrete context about the change you want. Work in the chat or the terminal, whichever suits you.

Key highlights

• .NET 11 support
  • Rider 2026.3 ships with day-one support for .NET 11. You can create, build, run, and debug net11.0 projects using updated project templates for the new SDK, and use all C# 15 language features, including union types and closed hierarchies.
  • The debugger and embedded decompiler also support Runtime Async. Explore the graph of async tasks in the Tasks view, inspect the full async call stack, and examine compiler-generated constructs and metadata in both the IL Viewer and the Assembly Explorer metadata tree.
• Go beyond the .slnx with the Files view
  • The new Files view shows your repository as it is organized on disk. You can open and edit files outside your solution – such as CI pipelines, Dockerfiles, scripts, documentation, and AI agent instructions – without adding them as solution items or creating virtual folders in the IDE.
  • The Files view replaces the File System view, which only covered the directory containing your .sln or .slnx file. Search Everywhere also includes files available in the Files view.
  • To keep navigation fast, the Files view lets you browse and edit files without indexing the entire repository by default. If your repository includes frontend projects outside your main .NET solution, such as a React app alongside a .NET backend, you can enable full IDE support for those directories whenever you need it.
  • The Solution and Files views work side by side: use the Solution view to focus on your .NET projects, and switch to the Files view when updating repository-level configuration or reviewing code, specs, and examples modified by AI agents.
• Quick tasks and edits without opening a project
  • Not every task needs an open project. The new Home window replaces the Welcome screen, so you can get to work the moment Rider opens. Edit a file, run a terminal command, work with databases, or attach the debugger or profiler to a running process – all without waiting for a full project to load.
  • If you need to do more complex work, you can open or create a solution to use all of Rider’s intelligent features. You’ll still find your recent solutions and remote development connections in the Projects and Files tool window on the Home screen, so you can easily switch between quick tasks and full IDE work in one place.
  • The Home window also comes with a new default startup behavior, which matches other JetBrains IDEs. When you start Rider, it now reopens the last solution or project you worked on, so you can pick up where you left off. To start in the Home window instead, clear the Reopen projects on startup checkbox in Settings | Appearance & Behavior | System Settings.

AI integrations

• Git worktrees for parallel work and easy code reviews
  • Rider can now copy your local project configuration into new Git worktrees, including run configurations and other settings stored in .idea. You no longer need to commit those settings to Git or recreate them for each worktree.
  • You can also list local and ignored files in .worktreeinclude for the IDE to copy, and configure a custom script to run when a worktree is created, for example, to install dependencies.
  • Other worktree improvements include:
    • Support for multi-root projects.
    • More reliable worktree creation in repositories with submodules.
    • The option to check out a branch that is already checked out in another worktree, using --ignore-other-worktrees.
    • Automatic removal of deleted worktrees from Recent Projects.
    • Improved support for WSL and container-based projects.
• Get Rider ready for your AI agent
  • The new AI Agent Setup widget in the bottom-right status bar brings Rider's coding agent integrations together in one place. Open it to see available capabilities – such as MCP tools, skills, and hooks – along with a concise explanation of how each one fits into your workflow.
  • The overview shows which integrations are already enabled and links directly to the settings pages for the ones you can configure, whether your coding agent runs inside Rider or in an external terminal.

Agent skills

• Async debugging context for AI agents
  • Asynchronous hangs and deadlocks are notoriously difficult to investigate, and restarting the application to set one more breakpoint often causes timing-sensitive bugs to disappear entirely. Rider's debugging-code skill now gives AI agents access to runtime state from an active debug session.
  • During a session, an agent can inspect the async task graph and active call stacks to trace dependencies between operations and see where execution is blocked. Instead of relying on repeated restarts and trial-and-error breakpoints, you and your agent can pinpoint the method blocking an async operation or identify the specific tasks and lock sites involved in a deadlock.
• .NET project integration for database agent skills
  • The database agent skills introduced in DataGrip 2026.2 now work with .NET project configurations in Rider.
  • When an agent creates or updates a database connection, the rider-database-connection-management skill can discover and reuse connection strings from your .NET project, so you do not have to re-enter connection details manually. For Microsoft SQL Server and LocalDB, the skill also configures JetBrains' bundled drivers and connection settings automatically.
• Let AI agents run .NET tests through Rider
  • To verify their changes without IDE support, coding agents typically run dotnet test, parse raw console output, and handle each test framework's behavior on their own. The Rider MCP server now provides a dedicated test execution workflow for agents.
  • An agent starts a test run with test_run_start and retrieves the run status and results through Rider. The IDE builds the required projects, executes the tests using its own test runner infrastructure, and returns structured results – including test failures and build errors – in a consistent format across VSTest and Microsoft.Testing.Platform.
  • Every agent-triggered run appears in Rider as a standard test session, so you can monitor progress, inspect failures, and navigate directly to the relevant code. Because structured output is more compact than raw console logs, this workflow can also reduce token usage and execution cost, depending on your model, project, context, and workflow.

Performance

• Automatic error and freeze reporting
  • Rider 2026.3 automatically sends error and UI freeze reports to JetBrains, helping us identify the problems that interrupt your work and prioritize fixes based on their impact.
  • Reports contain only technical data. Personal details such as file paths, URLs, and usernames are removed from report messages before they leave your machine. You can turn automatic reporting off in Settings | Appearance & Behavior | System Settings | Data Sharing.
• Faster warm start when reopening solutions
  • When you reopen a solution, code highlighting, solution-wide search, and all code navigation actions become available faster, so you can start exploring and working with your codebase sooner.

Code analysis

• C# 15 support
  • Rider provides full support for C# 15, covering union types, closed class hierarchies, collection expression arguments, extension indexers, and labeled break and continue statements. Code analysis, completion, navigation, and other IDE features work with the new syntax, while dedicated inspections, quick-fixes, and context actions help you adopt it and simplify existing code.
  • Rider also supports the memory safety redesign preview, recognizing the new safe modifier and unsafe expressions, highlighting missing or redundant unsafe contexts, and offering quick-fixes to address them.
• New and improved C# inspections
  • Rider expands its collection expression suggestions to cover more list and immutable-builder initialization patterns, including foreach loops, AddRange, and individual Add calls. New inspections catch character values accidentally used as array lengths or indices, highlight culture-sensitive operations and implicit string-sorting behavior, and detect using statements that dispose of a task instead of its result. Corresponding quick-fixes help make your intent explicit and avoid subtle mistakes. A new inspection suggests using concise tuple syntax, and a quick-fix replaces verbose ValueTuple object creation with a readable list of tuple elements.

Debugging

• Debugger support for Runtime Async
  • Rider's async debugging tools now support Runtime Async in .NET 11. You can set breakpoints in runtime-async methods, and Rider reconstructs async call stacks across await points even in applications that mix traditional async and runtime-async methods.
  • Parameters and local variables remain available at suspension points in the Threads & Variables tab, where you can inspect them as you would in a standard stack frame.
  • For complex asynchronous flows, the Tasks tab also recognizes runtime-async methods and shows how awaiting tasks connect across chains of operations.
• Debugging for .NET single-file applications - Windows only
  • Publishing a .NET application as a single executable simplifies deployment, but investigating issues in the published binary has previously been difficult.
  • Rider now supports debugging single-file .NET applications, including code bundled from NuGet packages and framework libraries. You can launch or attach to a published single-file executable, set breakpoints, step through code, and inspect state as you would with a standard .NET build. This lets you diagnose issues that occur only after publishing, without trying to reproduce them in a different build configuration.
• Natvis hot reload and expression evaluator improvements
  • Large C++ and game codebases, including Unreal Engine and custom studio engines, rely on .natvis files to make complex engine types readable in the debugger. Previously, testing a visualizer change meant stopping the debug session, relaunching the game, and reproducing the same state.
  • In response to a long-standing community request, and building on the Linux and macOS Natvis support introduced in 2026.2, Rider 2026.3 reloads .natvis files during an active debug session so the Variables view updates right away. To reload visualizers, use the editor prompt that appears after saving a loaded .natvis file, select More | Reload Natvis in the Debug tool window, or run the Reload Natvis action. You can enable Natvis rendering in Settings | Build, Execution, Deployment | Debugger | Data Views | C/C++.
• Faster, more consistent stepping in the C++ debugger
  • Stepping is the most frequent action in a debug session, so even small delays and uneven response times add up quickly when you trace a bug across dozens of steps.
  • Rider 2026.3 replaced the Python-based stepping scripts in the C++ debugger on Windows with native code running directly inside the debugger. In internal benchmark on a test machine, a single Step Over went from 10–20 ms (with spikes above 30 ms) to a steady 6–7 ms; actual results vary by project and hardware.
  • The native implementation covers Step Into, Step Over, and Step Instruction for C++ code built with MSVC, including Unreal Engine projects, and lays the groundwork for further debugger optimizations. It also fixes cases where stepping stopped at the wrong location or left internal breakpoints behind, causing unexpected stops.
• New C++ debugger based on LLDB 21 - Experimental
  • Rider's C++ debugger has long relied on a heavily customized fork of LLDB 9 to provide MSVC and Natvis support, which meant missing out on upstream LLVM fixes from newer releases.
  • In Rider 2026.3, you can opt in to a new C++ debugger built on LLDB 21 across Windows, macOS, and Linux, delivering on the roadmap shared when Natvis support arrived on Linux and macOS in 2026.2 and bringing a unified native debugging engine to all three platforms. The new debugger:
    • Uses Rider's custom expression evaluator – which powers Natvis rendering – on macOS and Linux in addition to Windows.
    • Incorporates years of upstream LLVM fixes while retaining Rider's MSVC and Natvis customizations.
    • Establishes a modern foundation for upcoming C++ debugger improvements.
  • LLDB 9 remains the default debugger in this release. To try LLDB 21, use the notification shown when you open a C++ project to download and switch to it, or go to Settings | Build, Execution, Deployment | Debugger, click Download in the LLDB section, and select LLDB 21 in the Debugger list. 
• Set data breakpoints directly from the editor
  • When debugging Unreal Engine or custom C++ projects, you no longer need to open the Watches window first to set a data breakpoint. Right-click a variable directly in the editor to add a data breakpoint on the spot.
  • You can also create data breakpoints from the Breakpoints dialog: click + (Add), select Data Breakpoints, and enter a variable name or memory address along with the watched region size.
  • Setting data breakpoints from the Watches and Evaluate Expression UI remains supported as well. Data breakpoints validate input as you type and support read/write access triggers, conditions, logging, and other breakpoint options.
  • AI agents can also use data breakpoints via the Rider MCP server. When you and your agent investigate an unexpected change in a value, the agent can set a data breakpoint and stop execution at the code that accesses the watched memory, rather than adding logging to find where the change occurs.

UI/UX

• Sound cues for IDE events and editor line marks
  • Screen reader users now get audio cues for editor line marks: errors and warnings, lines added, changed, and removed under version control, and code folding. You can also hear when things finish. Builds, tests, and other time-consuming background tasks report their results with distinct sounds for success, warning, and error states, and breakpoint hits come with a sound too. And if you work across multiple monitors or several projects at once, enable these sounds so you don’t have to glance at the screen to check statuses.
  • With screen reader support enabled, line-mark cues and sounds for the most important events (builds, tests, breakpoint hits) are enabled by default. Agents in Air come with sound cues of their own, and they’re enabled by default for everyone, whether or not you enable screen reader support. You'll hear when an agent finishes, stops with an error, or needs your input, and when dictation starts or stops. Everything else is opt-in. You can explore and preview the sounds on the new Accessibility settings page, and use the Play sound checkbox on the Notification settings page to enable cues for a specific notification group.
• Built-in bracket colorization
  • In response to a popular community request, Rider now includes built-in bracket colorization. Coloring matching brackets by nesting level helps you read deeply nested code, including single-line expressions where indent guides do not apply.

GameDev

• Lua support in Rider - Beta
  • Game projects often pair C++ or C# engine code with Lua scripts for gameplay logic, engine customization, and hot updates. A new JetBrains-maintained Lua plugin, available in Beta on JetBrains Marketplace, lets you work with Lua 5.1–5.4, LuaJIT, and Luau in the same IDE without relying on third-party plugins.
  • Rider infers types from your existing EmmyLua, LuaLS, and LDoc comments as well as Luau type annotations, so you do not need to change how your project is annotated.
  • The plugin includes:
    • Syntax and error highlighting, plus more than 35 inspections with quick-fixes.
    • Code completion, Quick Documentation, parameter info, and inlay hints.
    • Go to Declaration, Find Usages, call hierarchy, and require path resolution.
    • Refactorings including Rename, Extract Function, Inline, Change Signature, and Move to Module.
    • A code formatter with configurable Lua code style settings.
• Unreal Engine support
  • Several of the C++ debugging improvements in Rider 2026.3 are designed with Unreal Engine and custom C++ game engines in mind. Here is a quick look at what is new in the Debugging section, followed by the latest Unreal Engine updates:
    • Natvis hot reload and expression evaluator improvements let you update .natvis visualizers during an active debug session without restarting the game, start the debugger faster on Unreal Engine projects, and inspect containers like TMap and TSet more reliably.
      Faster, more consistent C++ stepping replaces Python stepping scripts with native code on Windows for MSVC and Unreal Engine projects, reducing Step Over times.
    • An experimental C++ debugger based on LLDB 21 is available as an opt-in feature on Windows, macOS, and Linux, combining years of upstream LLVM fixes with Rider's MSVC support, Natvis rendering, and a custom expression evaluator across all three platforms.
    • Data breakpoints in the editor and for AI agents let you add a data breakpoint by right-clicking a variable in the editor or from the Breakpoints dialog, and allow AI agents to set data breakpoints through the Rider MCP server when tracking down unexpected memory changes.
• Verse support in Rider - Beta
  • The new Verse Language plugin brings Verse, C++, and Unreal Engine integration together in Rider. Built on Rider's own language engine, it provides native Verse support without requiring an external language server.
  • The plugin highlights syntax, reports errors as you type, and provides code completion, Go to Declaration, Find Usages, and Quick Documentation across your solution. Through the Rider MCP server, these capabilities are also available to your AI agents.
  • To work with C++ and Verse together, open your Unreal Engine 6 project's .sln or .uproject file. For a lighter setup focused only on Verse files, open the .code-workspace file generated by Unreal Engine.
• Command-line argument presets (former EzArgs plugin)
  • Game developers often relaunch a game or editor with different maps, log levels, or test flags. Built-in command-line argument presets fully replace the EzArgs plugin, letting you maintain a shared list of arguments, group them into presets, and switch presets from the main toolbar before clicking Run or Debug.
  • Presets are independent of run configurations, so you can reuse the same setup across Debug and Release, for example, when investigating a Release-only bug, without duplicating configurations.
  • Command-line argument presets include:
    • A Preset selector next to the Run and Debug controls, including None to launch without preset arguments.
    • Typed arguments (Flag, Boolean, String, Integer, and Floating-point number) with type validation.
    • Folders, descriptions, and checkboxes to toggle individual arguments or entire folders per preset.
    • Command-line import: paste existing arguments (including saved EzArgs strings) into Import Args from Command Line to split them and detect their types automatically.
    • Sharing through version control via a project file, or across projects using XML import and export.
• Full support for .vcxproj.filters - Experimental
  • When you reorganize a C++ project in Rider, your Visual Studio teammates now see the same project structure. Rider keeps .vcxproj.filters synchronized as you work:
    • Create filters, including nested filters, and add new or existing files to them.
    • Rename and move files and filters using drag-and-drop or refactorings.
    • Create a .filters file automatically when you add the first filter to a project that does not have one yet.
    • Update the Rider project tree automatically when .vcxproj.filters changes externally, such as when a teammate edits the project in Visual Studio or you pull changes from version control.
    • Switch the project tree between the logical filter view and the on-disk folder structure at any time.
• Debug Unity CoreCLR Players
  • Unity 6.7 introduces CoreCLR as a new scripting runtime for desktop Players, and Rider 2026.3 supports it alongside Mono and IL2CPP. You can attach to and debug a CoreCLR Player, set breakpoints, and step through code the same way you do with Mono or IL2CPP Players.
  • Existing Mono Player workflows remain unchanged, so you can test CoreCLR on a separate branch and compare runtime behavior without disrupting your main setup.
• Rider and the Godot Editor now work closely together
  • Most Godot developers keep the Godot Editor and Rider open side by side. Until now, the two applications did not know about each other. To open a file in the other application, you were required to locate it manually. A C# debug session from Rider started a separate Godot instance.
  • The connection between Rider and Godot uses the RD framework, the open-source protocol that already connects Rider to Unity and Unreal Engine.
  • Several popular community requests depended on this connection, and this release delivers the first of them. With the connection, you can:
  • Debug C# with the current scene started from Godot Editor, with Rider's C# debugger attached from the first frame. This means that Godot Editor’s embedded game window can be used to pause execution, adjust game speed, and more while Rider handles your breakpoints.
  • Debug GDScript with the current scene.
  • Right-click a file in either Rider or the Godot Editor to open it in the connected application.
  • The connection service ships with Rider, and the JetBrains Rider Integration add-on lets the Godot Editor load it. Install and enable the add-on from the Godot Asset Store.
• Professional debugging for C# and GDScript
  • When you stop at a breakpoint in a Godot game, inspecting a single variable is rarely enough. You also need to see which nodes exist in the scene, where they sit in the hierarchy, and what state they hold.
  • Rider 2026.3 brings Godot-aware debugging to both C# and GDScript, presenting engine objects the way you work with them in Godot:
    • Inspect autoloads, the active scene, and its full node hierarchy in the live scene tree, with a node inspector for properties and batched loading to keep large scenes responsive.
    • View each node's Godot name and type instead of an internal object ID.
    • Hover over GDScript variables to inspect their values, or use Add to Watches to track expressions.
    • Browse large arrays and dictionaries across pages in the Variables view.
    • Use GDScript code completion when writing expressions in the Immediate window at a breakpoint.
  • No extra setup is required: Start a debug session from any Godot run configuration, and the scene tree appears in the debugger when you hit a breakpoint.

WSL

• Lightweight WSL support in Rider - Beta
  • You can now open and work on a solution stored in WSL directly from Rider on Windows without starting a full remote development backend inside Linux. Rider and the ReSharper language server run on Windows for local UI and editor responsiveness, while a lightweight agent (IJent) inside WSL handles file operations and processes.
  • Because IJent operates inside WSL rather than over \\wsl$ (9P) network mounts, project scanning and indexing run faster, Linux paths and symlinks resolve accurately, and file reads avoid 9P and Microsoft Defender bottlenecks.
  • Rider automatically detects .NET SDKs installed in WSL, so code analysis, builds, and debugging run directly against the Linux file system and toolchain. Support for unit testing and NuGet in this mode is planned for upcoming releases. This feature is currently in Beta.

Other

• Removal of C# Interactive
  • Starting with Rider 2026.3, the C# Interactive tool window is no longer included in the IDE.
  • Few developers relied on C# Interactive, and the feature had accumulated correctness and usability issues over time.

Plugins

• Pull request and authentication updates in the Azure DevOps plugin
• Updates to the Azure DevOps plugin let you complete more of your pull request review workflow directly in Rider:
  • Sign in to Azure DevOps with your Azure account while retaining token-based authentication for self-hosted servers.
  • View pull request events and discussion threads together on a single timeline.
  • Read, reply to, and add review comments from the timeline, diff view, and code editor without leaving the IDE.

• Blueprints
  • Several 'uassets' can't be parsed properly in a UE project created from dev-5.8.
• Code Analysis
  • Unexpected analysis for a declared CLIEvent.
• Code Highlighting
  • Add highlighting options for F# functions.
• Debug
  • Remove Show options from the context menu of Debugger Graph Tasks view.
• Debug - Breakpoints
  • Rider freezes permanently after a Git operation changes files with breakpoints.
• Project Systems
  • A project startup hang doesn't let the async VFS refresh proceed.
  • RepoView causes breaks VCS/ProjectModel data.
  • Duplicate PACKAGE_JSON roots in RepoViewRootsV3 keep growing in 2026.2.3.1 and cause frontend OOM.
• Project Templates
  • Long wait period before allowed to create project.
• No subsystem
  • Import type: enumerating types may trigger unneeded FCS requests.

• Rider 2026.2.3, included a new 'Files' view. This view shows the entire repository rather than only the file system view for the current solution folder. It has been found that this view can slow Rider down. The slowdown is hard to trace back to the 'Files' view, so you might not realize what's causing it. For this reason, the new 'Files' view in this update has been disabled for everyone, including users who enabled it themselves. If you still want the repository view, you can turn it back on: in the Explorer tool window | the More options icon | the Enable Files view option.

• AI performance insights from the Monitoring tool window
  • Now you can ask your AI agent to investigate your application’s performance right from the Monitoring tool window. Monitoring collects runtime data every time you run your app, so your agent has the information it needs to find bottlenecks and link them to your code.

• This build fixes an issue with the AI Agent Setup widget, introduced in Rider 2026.2.2. Previously, the widget would sometimes fail to open when you clicked its taskbar icon on Windows with display scaling set to below 175%. Now it opens just fine.

• AI Agent Setup widget - Rider 2026.2.2 introduces the AI Agent Setup widget, a new entry point in the bottom-right status bar. This new tool helps you find and set up Rider's features for coding agents. When you open it, you'll see a list of supported features like MCP tools, skills, and hooks, along with brief explanations of how each one can help your workflow. The overview shows you which features are already enabled and which ones you can set up, with direct links to the right settings pages. No matter if your coding agent runs inside Rider or in an external terminal, the widget helps you see what Rider offers and quickly find the settings you need to begin.
• Less noise and clearer context for AI agents with hooks
  • Rider's hooks now provide AI agents with more targeted feedback after code changes. This helps cut down on unnecessary information and makes formatting changes coming from the IDE easier to spot.
  • Agents now get inspection results from the Run files inspections hook only for the code they added, not the whole file. This lets them focus on their own changes.
  • The Reformat file hook now gives a diff that shows any formatting changes made by the IDE. Agents can see what changed right away, so they don't have to reread the file to understand the updates.
• Test coverage gets TUnit support - Rider's dotCover integration now measures coverage for unit tests written with TUnit. To enable coverage, install the JetBrains.dotCover.Framework package in your project.

• On macOS 26.2.2, Rider could freeze indefinitely, usually while loading a large solution, but sometimes at other times. Rider collects thread dumps from its backend process to help diagnose slowdowns. This process briefly suspends the backend and then resumes it. A change to the macOS system API broke the resume step, leaving the backend permanently suspended. This issue has been fixed, and macOS 26.2.2 is now fully supported.
• The Attach to Unity Editor feature no longer depends on the editor executable name. This change fixes problems with recent Unity Hub versions and custom engine builds.
• MCP server access errors on attached folders. File operations now work across all folders attached to the solution, not just in the main solution directory.

• The bundled refactoring-code skill helps AI agents refactor code faster and at lower cost.
• The bundled debugging-code skill lets AI agents investigate runtime issues in C#, F#, C++, and mixed-language projects, whether they're built with .NET, Unity, or Unreal Engine. Agents can set breakpoints, step through code, inspect values and thread context, follow the call order, and check which branches are taken or whether execution reaches a specific line.
• Rider's quality-check hooks now support Codex in addition to Claude Code.
• The bundled dottrace-analyze skill can now analyze snapshots captured while profiling Unity projects.

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