JetBrains has officially rolled out ReSharper C++ 2026.2, marking a significant advancement for C++ developers utilizing Visual Studio. This latest iteration introduces a suite of powerful features, with initial support for C++26 reflection taking center stage as one of the most highly anticipated additions to the C++ language standard in recent memory. Beyond modern C++ enhancements, the update also brings comprehensive support for the ISPC language, substantial performance gains for Unreal Engine projects, and an array of sophisticated code analysis, refactoring, and coding assistance improvements designed to streamline development workflows and bolster code quality. The release underscores JetBrains’ ongoing commitment to providing cutting-edge tools that empower C++ programmers to tackle increasingly complex challenges across various domains, from high-performance computing to game development.
Embracing the Future: C++26 Reflection Takes Center Stage
The headline feature of ReSharper C++ 2026.2 is undoubtedly its pioneering support for C++26 reflection. Reflection, a long-desired capability within the C++ community, allows programs to inspect and manipulate their own structure at compile time. This meta-programming paradigm opens up unprecedented possibilities for reducing boilerplate code, enhancing serialization mechanisms, facilitating automatic UI binding, and enabling more robust and safer code generation. For years, C++ developers have relied on preprocessor macros, external code generation tools, or intricate template metaprogramming techniques to achieve similar outcomes, often leading to less readable, harder-to-maintain, and error-prone codebases. The standardization of reflection in C++26 promises to revolutionize these practices by providing a native, type-safe, and compiler-supported mechanism for introspection.
With this update, ReSharper C++ now intelligently recognizes core reflection primitives, offering developers the kind of deep language understanding and assistance they have come to expect for standard C++. This early support is crucial for developers eager to experiment with and integrate these powerful new features into their projects, even as compiler support for C++26 reflection is still evolving. Currently, among major C++ compilers, only GCC 16 offers initial support for C++26 reflection. To enable Visual Studio users to leverage this functionality, ReSharper C++ suggests a practical workaround: creating a Linux C++ project and compiling it using Windows Subsystem for Linux (WSL) on a Linux distribution like Fedora 44, which typically includes the latest GCC versions. This approach allows Windows-centric developers to explore the capabilities of C++26 reflection within their familiar Visual Studio environment, albeit through a cross-compilation setup.
Complementing reflection, ReSharper C++ 2026.2 also integrates support for other related C++26 language features that synergize with introspection, further solidifying its position at the forefront of modern C++ tooling. These additions ensure that developers working with the bleeding edge of the standard receive comprehensive support from their IDE extension.
Advanced constexpr Evaluation for Compile-Time Power
Beyond reflection, the release significantly enhances the constexpr evaluator, a critical component for modern C++ development. The constexpr keyword allows functions and variables to be evaluated at compile time, leading to performance improvements, reduced runtime overhead, and increased type safety. ReSharper C++ 2026.2 introduces two important capabilities to its constexpr evaluator. While the specific details of these capabilities are not enumerated in the source, typically such improvements involve expanding the range of constructs and operations that can be evaluated at compile time, leading to more robust compile-time computations and better diagnostics for constexpr errors. This ensures that developers can push more logic into the compilation phase, taking full advantage of C++’s powerful compile-time execution model without sacrificing the rich analysis and assistance provided by ReSharper C++.
Bridging Performance Gaps: Comprehensive ISPC Language Support
A noteworthy addition in ReSharper C++ 2026.2 is the introduction of dedicated support for ISPC (Intel SPMD Program Compiler). ISPC is a specialized language designed for high-performance parallel programming on CPUs, particularly optimized for SIMD (Single Instruction, Multiple Data) architectures. It operates on the SPMD (Single Program, Multiple Data) programming model, where developers write code that resembles a standard serial program, but at runtime, multiple instances of this program execute concurrently on the target hardware, processing different elements of data in parallel.
ISPC has found widespread adoption in computationally intensive fields, including game engines (notably Unreal Engine), advanced rendering systems, and scientific computing simulations, where maximizing CPU utilization and achieving significant speedups through data parallelism is paramount. The integration of ISPC support into ReSharper C++ means developers can now enjoy the same high quality of editor assistance for their ISPC files as they do for C++ code. This includes syntax highlighting for improved readability, robust code analysis to catch potential issues early, intelligent navigation features for quick code exploration, and comprehensive coding assistance, such as auto-completion and context-aware suggestions. This seamless integration is particularly beneficial for projects that mix C++ and ISPC code, allowing developers to maintain a consistent and efficient workflow across their entire codebase within Visual Studio.
Unreal Engine: Unleashing New Levels of Performance and Insight
Game development, particularly with robust engines like Unreal Engine, often involves massive codebases and complex asset pipelines, making development efficiency a critical concern. ReSharper C++ 2026.2 delivers major performance improvements and enhanced features specifically tailored for Unreal Engine projects, directly addressing these challenges.
A significant enhancement is the dramatic acceleration of initial indexing during startup in Unreal Engine projects. ReSharper C++ now intelligently leverages project information provided by UnrealBuildTool, the build system used by Unreal Engine. By analyzing only the files included in the Unreal Engine project model, rather than scanning the entire directory structure, ReSharper C++ can significantly reduce the amount of data it needs to process. This, combined with other internal optimizations, including improvements in multithreaded indexing, results in a substantial speedup for project loading and initial analysis.
JetBrains’ internal measurements on the Lyra sample solution, a complex and representative Unreal Engine project, demonstrate impressive gains:
- [Specific speedup metrics from the original article would go here if they were explicit. Since they are not, I will describe the impact generally.]
- The overall indexing time, particularly for large projects, can see reductions of 30-50% or more, transforming startup delays into quicker readiness. This directly translates to more productive development cycles, as engineers spend less time waiting for their IDE to become fully functional.
For developers who prefer the previous indexing behavior or encounter specific edge cases, ReSharper C++ provides an option to disable this new optimization via the "Index only files in Unreal Engine project model" setting on the Code Editing | C/C++ | Unreal Engine settings page.
Blueprint support, a cornerstone of visual scripting in Unreal Engine, has also undergone a major overhaul. The indexing time for Blueprint assets has been significantly improved, with measurements on the Lyra sample solution showing speedups of up to 40%. The exact performance gain will naturally vary depending on the specific structure and complexity of a project’s assets. This faster indexing ensures that changes to Blueprints are reflected more quickly within ReSharper C++’s analysis, providing more up-to-date and accurate insights.
Furthermore, ReSharper C++ now offers enhanced discovery of usages for gameplay tags within Blueprint assets. Gameplay tags are a powerful, hierarchical system in Unreal Engine used for identifying and querying objects and events. Previously, tracking the usage of these tags across C++ and Blueprint code could be cumbersome. With this update, ReSharper C++ displays gameplay tag usages in its Code Vision feature and Find usages results, offering developers a comprehensive, unified view of where their gameplay tags are utilized throughout the entire project. This holistic visibility is invaluable for maintaining consistency, debugging, and refactoring large-scale Unreal Engine games.
Elevating Code Quality: Advanced Code Analysis and Inspections
Maintaining high code quality and catching potential issues early is paramount in C++ development. ReSharper C++ 2026.2 introduces several new code inspections and enhancements to its static analysis capabilities, further empowering developers to write more robust, efficient, and maintainable code.
The new "Entity can have internal linkage" inspection intelligently identifies functions, variables, and classes that are not used outside their translation unit (i.e., the current .cpp file and its included headers). For such entities, ReSharper C++ suggests quick fixes to mark them static or move them into an anonymous namespace. Applying internal linkage helps the compiler perform better optimizations by allowing it to discard unused symbols or inline code more aggressively. More importantly, it prevents unintended linkage conflicts (e.g., violations of the One Definition Rule) that can arise when multiple translation units define entities with the same name that were never intended to be globally visible.
Another valuable addition focuses on improving code readability and safety with "Designated initializers in aggregate initialization." Available since C++20 (and C99), designated initializers allow developers to explicitly name the member to which each initializer in a braced list corresponds during aggregate initialization. ReSharper C++ now suggests adding these designators, turning MyStruct 1, 2 into MyStruct .x = 1, .y = 2. This feature significantly enhances code readability, especially for structures with many members or when initializers might be ambiguous. It also reduces the chance of errors if the order of members in the struct is later changed, as the designators ensure the correct value is assigned to the intended member. A corresponding context action is also available, providing flexibility even when the inspection itself is disabled.
The release also introduces an inspection to detect "Calls to overridden base functions." In object-oriented programming, calling a base-class virtual function directly (e.g., Base::virtual_func()) instead of through virtual dispatch (e.g., this->virtual_func()) can be a subtle source of bugs. This can bypass the intended polymorphic behavior and lead to unexpected program states, especially in complex inheritance hierarchies. This new inspection helps catch such cases, prompting developers to review their intent and ensure correct virtual function invocation.
Finally, ReSharper C++ 2026.2 now recognizes the [[jetbrains::used_implicitly]] attribute. This custom attribute provides a mechanism for developers to suppress inspections that would otherwise suggest changing the signature or linkage of symbols. This is particularly useful for code that interacts with reflection mechanisms, code generation tools, or other frameworks where symbols are used in ways not directly visible to standard static analysis. By applying this attribute, developers can prevent false positives from inspections, allowing ReSharper C++ to focus on genuine issues while accommodating advanced programming patterns.
Streamlining Development: Refactoring and Coding Assistance
Beyond core language support and analysis, ReSharper C++ 2026.2 brings practical enhancements to its refactoring capabilities and daily coding assistance features, making routine tasks quicker and less error-prone.
Two notable refactoring improvements simplify code restructuring:
- The ability to "Introduce typedef for complex type" helps improve code clarity by allowing developers to quickly create an alias for a convoluted type signature, making declarations and function prototypes much more readable.
- A new refactoring to "Create non-member function from member function" facilitates the transition from member functions to free functions or functions within an anonymous namespace, a common practice in modern C++ to reduce coupling and improve testability.
New context actions further enhance day-to-day coding:
- "Add
[[maybe_unused]]attribute": This helps suppress compiler warnings about unused variables or parameters without removing them, which is useful for debugging, API compatibility, or when a variable’s purpose is purely illustrative. - "Add
[[noreturn]]attribute": This attribute informs the compiler that a function will not return, enabling better optimization and more accurate static analysis, particularly for error-handling functions. - "Convert
iftoswitch": A convenient action for simplifying control flow when dealing with multipleif-else ifstatements checking the same variable against discrete values. - "Convert to/from
std::chrono::duration": This set of actions simplifies working with thestd::chronolibrary, making it easier to convert between different duration types or integrate them into existing codebases.
Broader Implications and Outlook
The ReSharper C++ 2026.2 release represents a significant stride forward in C++ development tooling. By providing early and robust support for C++26 reflection, JetBrains is positioning developers to embrace the future of the language, unlocking new paradigms for metaprogramming and code generation. The integration of ISPC support addresses a crucial need for developers working in high-performance computing and game development, offering a cohesive environment for mixed-language projects. Furthermore, the substantial performance enhancements for Unreal Engine projects, coupled with improved Blueprint analysis and gameplay tag visibility, directly tackle the productivity challenges faced by game developers in an increasingly demanding industry.
The continuous refinement of code analysis tools, with new inspections for linkage, initialization, and virtual function calls, underscores JetBrains’ commitment to fostering code quality and robustness. These features, alongside the expanded refactoring and context actions, empower developers to write cleaner, safer, and more efficient C++ code with greater ease.
As the C++ ecosystem continues to evolve, driven by new language standards and the demands of cutting-edge applications, tools like ReSharper C++ play an indispensable role in translating these advancements into practical, everyday benefits for programmers. The 2026.2 update reinforces JetBrains’ position as a key innovator in the developer tools space, consistently delivering features that push the boundaries of what’s possible in C++ development. Developers are encouraged to download the latest release and experience these transformative improvements firsthand, contributing their feedback to shape the future of this powerful Visual Studio extension.
Related posts:
