JetBrains has pushed a major architectural change into ReSharper 2025.2 that moves most heavy analysis out of Visual Studio’s UI process into a separate 64‑bit worker process — a shift the company says reduces cumulative UI freezes during solution startup by roughly 61 percent in its lab tests and dramatically improves typing responsiveness for large solutions. (blog.jetbrains.com, theregister.com)
ReSharper has been one of the definitive productivity extensions for .NET developers inside Visual Studio for more than a decade. Its deep code analysis, navigation, refactorings and code generation tools have been widely praised — and widely criticized for the same reason: the complexity of those features has historically exacted a toll on Visual Studio’s responsiveness, especially on very large solutions or machines with constrained memory. (blog.jetbrains.com)
The new Out‑of‑Process (OOP) mode in ReSharper 2025.2 is the most visible outcome of a multi‑year engineering effort to decouple compute‑heavy logic from the Visual Studio UI thread. JetBrains describes the work as a long, complex effort that began years ago and built on experience from Rider’s architecture (which already runs many ReSharper components out of process). The company has published multiple deep‑dive updates on the topic over several years. (blog.jetbrains.com)
The test methodology combined Event Tracing for Windows (ETW) MessageCheckDelay measurements and custom tooling to detect UI unresponsiveness. JetBrains summed all UI freezes of 100 ms or longer during launch to derive the headline numbers and included a side‑by‑side UI pause visualizer in their writeups to illustrate the difference. They also compared Visual Studio with no extension installed as a baseline (which, in their lab, measured around 6.3 seconds total freeze during startup for the Orchard Core test). (blog.jetbrains.com)
Caveat: these are vendor‑run tests performed in JetBrains’ lab environment with a particular configuration and hardware profile. Lab numbers are informative about trends and impact, but real‑world results will vary depending on solution size, installed extensions, OS/hardware configuration, and whether other tools (for example dotMemory/dotTrace) are present. JetBrains is explicit that the numbers may deviate when measured in different environments. (blog.jetbrains.com)
JetBrains is also positioning ReSharper as an interop bridge to its own IDE ecosystem: much of ReSharper’s backend code is reused in Rider, the company’s cross‑platform C# IDE. Improvements to the ReSharper core therefore benefit both Visual Studio plugins and JetBrains’ other IDE investments. This reuse matters for macOS users who lost an official Visual Studio for Mac, because Rider is the primary JetBrains cross‑platform alternative. (blog.jetbrains.com)
The architectural work also benefits JetBrains’ broader product portfolio because much of the same backend is reused in Rider and new cross‑platform efforts (including ReSharper features for Visual Studio Code). In other words, investing in OOP is not only about fixing a Visual Studio problem — it’s about aligning a common ReSharper core across multiple host editors. (blog.jetbrains.com)
For anyone who builds and maintains large C# codebases inside Visual Studio, this release is worth testing now. Do so with care: validate debugger and profiling workflows, roll out in stages, and track JetBrains’ updates as the company works toward restoring parity. The architectural payoff looks promising; the success of the migration will depend on how quickly and reliably JetBrains can bridge the remaining feature gaps while preserving the responsiveness gains that developers desperately need. (blog.jetbrains.com, jetbrains.com)
Source: theregister.com Big change to JetBrains ReSharper cuts Visual Studio freezes
Background
ReSharper has been one of the definitive productivity extensions for .NET developers inside Visual Studio for more than a decade. Its deep code analysis, navigation, refactorings and code generation tools have been widely praised — and widely criticized for the same reason: the complexity of those features has historically exacted a toll on Visual Studio’s responsiveness, especially on very large solutions or machines with constrained memory. (blog.jetbrains.com)The new Out‑of‑Process (OOP) mode in ReSharper 2025.2 is the most visible outcome of a multi‑year engineering effort to decouple compute‑heavy logic from the Visual Studio UI thread. JetBrains describes the work as a long, complex effort that began years ago and built on experience from Rider’s architecture (which already runs many ReSharper components out of process). The company has published multiple deep‑dive updates on the topic over several years. (blog.jetbrains.com)
What changed: the technical outline
Why in‑process ReSharper caused pain
Historically, most of ReSharper’s analysis ran inside Visual Studio’s process. Visual Studio (until recently) ran as a 32‑bit process with a limited address space, and even with 64‑bit VS builds the UI thread remains a bottleneck for operations that must touch UI data. Heavy analysis that needed access to Visual Studio APIs would block the UI thread, producing pauses that affect typing, clicking and window repainting. These pauses are the core complaint longtime ReSharper critics cite. (blog.jetbrains.com, jetbrains.com)The Out‑of‑Process approach
The OOP redesign isolates most analysis, indexing, caching and computation into a separate 64‑bit worker process. The Visual Studio UI process keeps only what must run inside it — UI bindings, editor text surfaces and COM API interactions. Communication between the UI and the external worker is handled via an inter‑process protocol, and the design attempts to ensure heavy work never needs to block the UI thread. JetBrains reports multiple scheduling, indexing and cache improvements alongside this separation. (jetbrains.com, blog.jetbrains.com)Engineering trade‑offs
Moving logic out of process forces a re‑architecture of code that previously assumed a shared memory process and synchronous access to UI objects. JetBrains had to rework component lifecycles, dependency injection, and the action/refactoring layers that sometimes require visual UI flows (dialogs, in‑place editors). The project required reconciling features that must stay in the UI process with services that can be moved — and engineering the IPC to be low‑latency and resilient. JetBrains has documented both the architectural reasoning and the practical complications, and warns that some features will lag as parity is established. (blog.jetbrains.com)Measured benefits: what JetBrains tested and found
JetBrains ran a set of lab benchmarks that illustrate the change in client scenarios. The most prominent is the Orchard Core solution test — a large open‑source CMS with roughly 223 projects — where JetBrains measured cumulative UI freezes of 100 ms or longer during Visual Studio startup. In that test, cumulative frozen time fell from 26.0 seconds with ReSharper 2025.1.4 (in‑process) to 10.1 seconds with ReSharper 2025.2 running OOP — a 61% reduction by their metric. JetBrains also reports improvements for smaller solutions and substantial reductions in typing latency, with median typing latency reportedly falling from ~26.4 ms to ~16.7 ms in their “most realistic typing” scenario. (blog.jetbrains.com)The test methodology combined Event Tracing for Windows (ETW) MessageCheckDelay measurements and custom tooling to detect UI unresponsiveness. JetBrains summed all UI freezes of 100 ms or longer during launch to derive the headline numbers and included a side‑by‑side UI pause visualizer in their writeups to illustrate the difference. They also compared Visual Studio with no extension installed as a baseline (which, in their lab, measured around 6.3 seconds total freeze during startup for the Orchard Core test). (blog.jetbrains.com)
Caveat: these are vendor‑run tests performed in JetBrains’ lab environment with a particular configuration and hardware profile. Lab numbers are informative about trends and impact, but real‑world results will vary depending on solution size, installed extensions, OS/hardware configuration, and whether other tools (for example dotMemory/dotTrace) are present. JetBrains is explicit that the numbers may deviate when measured in different environments. (blog.jetbrains.com)
What doesn’t work yet (current limitations)
Out‑of‑Process mode is shipped as a public preview and is off by default in 2025.2 (it may be enabled by default in some EAP builds). JetBrains’ documentation and blog posts list several features that are not supported or are partially broken in OOP mode right now:- AI Assistant and AI‑powered features are not available in OOP mode.
- Debugger integrations and debugger visual helpers (including predictive debugger and compiled modules debugging) are currently unavailable.
- Dynamic Program Analysis (DPA) and integrations with dotTrace, dotMemory and dotCover do not function with OOP enabled.
- Template editor, structural search and replace, regular expression validation, and dependency/diagramming tools are also listed as unsupported. (jetbrains.com, blog.jetbrains.com)
How to try Out‑of‑Process mode
Developers who want to test the new mode can enable it through ReSharper’s options or toggle via the status bar. JetBrains provides multiple activation paths:- ReSharper → Options → Environment → Products & Features → check “Run ReSharper in separate process” and click Save and Restart.
- Use the menu: Extensions → ReSharper → R# Out‑of‑Process → Switch to Out‑of‑Process mode.
- Use the Ctrl+Shift+A action search and type “Switch to Out‑of‑Process mode.”
- Use command‑line flags at Visual Studio startup: /ReSharper.OOP to start in OOP mode or /ReSharper.InProcess to force the old mode. (jetbrains.com, lp.jetbrains.com)
Real‑world impact: who benefits, who loses features
Winners
- Developers working with very large solutions or monorepos should see the most dramatic responsiveness improvements. The Orchard Core example is emblematic of this class of workload. (blog.jetbrains.com)
- Teams who previously disabled ReSharper because it made Visual Studio sluggish may now find the product usable again, reclaiming ReSharper’s refactorings, navigation and code inspections without the UI pain that drove them away. (blog.jetbrains.com)
Trade‑offs and losers (for now)
- Developers who rely on deep debugger integration inside Visual Studio — especially those using JetBrains’ dotTrace/dotMemory/dotCover or the Visual helpers — will need to remain on in‑process mode until those integrations are ported. (jetbrains.com)
- Teams that depend on AI Assistant features inside ReSharper will lose that capability with OOP mode enabled until JetBrains brings AI support into the new architecture. Given the increasing use of AI coding helpers, this limitation will be significant for some users. (blog.jetbrains.com)
Where ReSharper fits in the changing tooling landscape
The arrival and rapid improvement of AI coding assistants (GitHub Copilot, Microsoft’s IntelliCode, OpenAI‑powered plugins, plus JetBrains’ own AI Assistant) has shifted how many developers address routine code tasks like completions and small refactorings. Some observers suggest these tools may erode the absolute necessity of a heavyweight extension like ReSharper for some workflows. But ReSharper’s historical strength — deep, reliable refactorings and codebase‑wide maintenance utilities — remains uniquely valuable where structural quality and large‑scale changes matter. Research has also highlighted that generative AI can increase near‑duplicate and poorly structured code, which increases the need for strong refactoring and cleanup features of the kind ReSharper offers. (theregister.com, blog.jetbrains.com)JetBrains is also positioning ReSharper as an interop bridge to its own IDE ecosystem: much of ReSharper’s backend code is reused in Rider, the company’s cross‑platform C# IDE. Improvements to the ReSharper core therefore benefit both Visual Studio plugins and JetBrains’ other IDE investments. This reuse matters for macOS users who lost an official Visual Studio for Mac, because Rider is the primary JetBrains cross‑platform alternative. (blog.jetbrains.com)
Market footprint and perception
ReSharper is widely installed and remains one of the most visible Visual Studio extensions. Public counts of installs vary by source and are updated periodically; press coverage has cited figures in the low‑millions range for marketplace downloads. Market install numbers should be treated as approximate because publisher dashboards, marketplace aggregation, and packaging channels can count downloads differently. That said, the product’s large installed base explains why an architectural change of this magnitude will meaningfully affect many developer workflows. (theregister.com, platform.softwareone.com)Risks, unknowns and what to watch
- Feature‑parity timeline: JetBrains is explicit that full parity between in‑process and out‑of‑process modes will take time. There is no firm public timeline for when every missing integration (especially debugger tooling and AI features) will be restored. Organizations that require those features must plan for a phased migration. (jetbrains.com, blog.jetbrains.com)
- Dual‑mode complexity: Maintaining two code paths (in‑process and out‑of‑process) increases testing and QA burden. Bugs may be mode‑specific and harder to reproduce, and third‑party ReSharper plugins may not behave identically across modes. This complexity could lead to intermittent integration issues until the migration stabilizes. (blog.jetbrains.com)
- Interference with other extensions: Developers who enable multiple code‑intelligence tools simultaneously (built‑in IntelliSense, ReSharper, GitHub Copilot, JetBrains AI, third‑party analyzers) may still face noisy completion popups, duplicated code actions, and selector conflicts. The presence of OOP mode reduces one class of UI freezes but does not eliminate cognitive overload from overlapping features. (theregister.com)
- Telemetry and measurement variance: Vendor benchmark claims are useful but should be validated against local scenarios. Differences in extensions, Visual Studio versions, machine specs, and solution topology can all change observed results. JetBrains invites users to share traces and recordings and to join the usage statistics program to help refine the measurements. (blog.jetbrains.com)
Practical guidance for developers and teams
- If your workflow uses ReSharper but you struggle with Visual Studio freezes, try Out‑of‑Process mode in a controlled way: enable it on a few developer machines, run standard workflows (build/test/debug), and document any missing features. Use the status‑bar toggle to switch back quickly if a needed integration fails. (jetbrains.com)
- Preserve a golden image for CI and automated builds that doesn’t rely on OOP‑only features; treat OOP as a client‑side optimization rather than a replacement for in‑process capabilities until parity is reached. (blog.jetbrains.com)
- Avoid enabling OOP while you need dotTrace/dotMemory/dotCover integrations or advanced Visual Studio debugger helpers. JetBrains’ documentation lists each incompatible subsystem; consult that list before rolling out OOP enterprise‑wide. (jetbrains.com)
- If you’re evaluating alternatives to ReSharper because of past performance issues, give the new OOP preview a field test — the responsiveness improvements can be game‑changing — but strictly vet debugger and AI workflows before decommissioning existing toolchains. (blog.jetbrains.com)
What this means for JetBrains and the IDE ecosystem
Moving ReSharper out of process is a structural bet on developer productivity: it accepts short‑term feature gaps in exchange for a fundamentally smoother editing experience. If JetBrains can restore parity for debugger and AI integrations while keeping the OOP performance gains, ReSharper will be in a stronger position to compete with lighter AI coding assistants and Microsoft’s built‑in tools.The architectural work also benefits JetBrains’ broader product portfolio because much of the same backend is reused in Rider and new cross‑platform efforts (including ReSharper features for Visual Studio Code). In other words, investing in OOP is not only about fixing a Visual Studio problem — it’s about aligning a common ReSharper core across multiple host editors. (blog.jetbrains.com)
Conclusion
The Out‑of‑Process mode in ReSharper 2025.2 is the most consequential change to the product’s architecture in years. JetBrains’ internal tests demonstrate substantial reductions in UI freezes and meaningful typing latency improvements for large solutions, and many developers who previously found ReSharper unusable because of performance will likely benefit. At the same time, the preview nature of OOP means important integrations — debugger tooling, profiling tools and AI features — are not yet available, so teams must weigh the responsiveness gains against temporary feature loss.For anyone who builds and maintains large C# codebases inside Visual Studio, this release is worth testing now. Do so with care: validate debugger and profiling workflows, roll out in stages, and track JetBrains’ updates as the company works toward restoring parity. The architectural payoff looks promising; the success of the migration will depend on how quickly and reliably JetBrains can bridge the remaining feature gaps while preserving the responsiveness gains that developers desperately need. (blog.jetbrains.com, jetbrains.com)
Source: theregister.com Big change to JetBrains ReSharper cuts Visual Studio freezes