ReSharper C++ Releases

Class layout

• How a class is laid out in memory determines how much space each object takes, how well its data fits into CPU cache lines, and whether it matches a binary format or an ABI shared with other code. To satisfy alignment requirements, the compiler silently inserts padding between fields. As a result, a class can end up noticeably larger than the sum of its members. This can add up quickly for objects allocated in large numbers or processed in tight loops.
• The new Class Layout tool window visualizes the memory layout of a class, struct, or union, including the offset and size of every field and bit-field, base class subobjects, virtual table pointers, and the padding between them. This makes it easy to find padding you can eliminate, check the effect of alignas or #pragma pack, and understand the layout of classes in a complex hierarchy. To open the tool window, place the caret on a class name or any reference to a class type, then choose ReSharper | Inspect | Class Layout. Alternatively, select the Class Layout item in the Alt+Enter menu.

Refactorings

• Change Signature for constructors
  • The Change Signature refactoring now works on constructors. You can add, remove, reorder, and change the types of constructor parameters, and ReSharper C⁠+⁠+ updates the constructor calls throughout your code, including direct and braced initialization, new expressions, member and base class initializers, and factory functions such as std::make_unique. The Change Signature dialog also has two new options that let you add or remove the static specifier on functions and the explicit specifier on constructors.
• Extract Method placement
  • The Extract Method refactoring now has a Place in option that controls where the extracted function is placed: either next to the current function, as a free function in the namespace containing the current class, or as a free function in an anonymous namespace. A new Make constexpr option also lets you mark the extracted function constexpr.
• Introduce Using Directive
  • The new Introduce Using Directive refactoring replaces namespace qualifiers, such as std in std::cout, with a using namespace directive.

Format string analysis

• std::format, std::print, and {fmt}
  • ReSharper C⁠+⁠+ has long analyzed calls to printf-like functions. In 2026.3, the same analysis extends to the C⁠+⁠+⁠20 <format> and C⁠+⁠+⁠23 <print> standard library headers, as well as the popular {fmt} library. ReSharper C⁠+⁠+ now analyzes calls to format, format_to, format_to_n, formatted_size, print, and println from both the std and fmt namespaces:
    • Replacement fields in the format string are highlighted. When the caret is on a replacement field, the corresponding argument is highlighted too, and vice versa.
    • ReSharper C⁠+⁠+ reports invalid replacement fields, missing and unused arguments, and format strings that mix automatic and manual argument indexing.
    • The format specification is checked against the argument type. For example, formatting a double with the d presentation type is reported, and a quick-fix replaces it with a matching one.
    • Named arguments are supported for the {fmt} library via fmt::arg.
• printf updates
  • The analysis of printf-like functions now supports the new format specifiers from C23. ReSharper C⁠+⁠+ also understands POSIX positional arguments such as %1$s and %2$*1$d, and checks the argument types by position. A new inspection reports printf calls that mix positional and non-positional arguments.
• Unreal Engine logging macros
  • Format string analysis now supports UE_LOGFMT and related Unreal Engine structured logging macros. ReSharper C⁠+⁠+ highlights the fields in the format string, matches them with the arguments, and reports missing or unused arguments and invalid field names.
• Format attributes on constructors
  • The [[jetbrains::format]] and [[gnu::format]] attributes can now be applied to constructors, so ReSharper C⁠+⁠+ checks the format string in constructor calls. Additionally, ReSharper C⁠+⁠+ now recognizes the underscore spelling of the attribute, [[__gnu__::__format__(__printf__, 1, 2)]], as well as constant expressions in the attribute's argument indices.

Code analysis

• Clang-Tidy integration
  • The bundled Clang-Tidy binary has been updated to LLVM 23, bringing new checks and improvements from the latest LLVM release. Clang-Format has been updated as well.
  • NOLINT comments with globs in check names, such as // NOLINT(readability-*), now also suppress the ReSharper C⁠+⁠+ inspections that correspond to the matching Clang-Tidy checks. Moreover, a new Additional clang-tidy command-line arguments setting on the Clang-Tidy options page lets you pass extra arguments to Clang-Tidy.
• Explanations for failed constraints
  • When a requires expression evaluates to false, ReSharper C⁠+⁠+ now shows which requirement fails and why its expression is ill-formed. For example, a function or operator may be inaccessible or deleted, or the number of arguments may not match the candidate functions. Similarly, error messages about deleted constructors and failed destructibility checks now show the full chain of reasons, down to the specific base class or field that causes the problem.
• CUDA
  • ReSharper C⁠+⁠+ 2026.3 extends its CUDA support with a new set of inspections, which you can configure in the new CUDA group on the inspection severity settings page:
    • Execution spaces: ReSharper C⁠+⁠+ checks that a function can be called from the CUDA execution space of the calling code, following the rules of the CUDA Programming Guide. The check takes into account __CUDA_ARCH__ guards, CUDA runtime API functions, C library functions available in device code (such as printf and malloc), and calls to overloaded operators.
    • Memory spaces: New inspections detect invalid uses of the __device__, __constant__, __shared__, __managed__, and __grid_constant__ specifiers. Examples include memory space specifiers on data members or function parameters, initializers on __shared__ variables, and conflicting specifiers.
    • CUDA Tile: New inspections enforce the restrictions of the CUDA Tile programming model. For example, they report goto and return statements inside loops in __tile_global__ functions, as well as tile kernels launched with a block size other than 1. A suggestion also detects loops that can be replaced with a range-based for over cuda::tiles::irange.
• Language support
  • ReSharper C⁠+⁠+ 2026.3 supports more features from recent C⁠+⁠+ standards:
    • C⁠+⁠+⁠23 delimited escape sequences: \x{...}, \o{...}, and \u{...} (P2290).
    • C⁠+⁠+⁠26 user-generated static_assert messages (P2741).
    • C⁠+⁠+⁠26 offset parameter of the #embed directive (P3540).
    • C⁠+⁠+⁠26 #line directives before module declarations (P3868).

Visual Studio integration

• Out-of-Process mode
  • In ReSharper 2026.2, Out-of-Process (OOP) mode became the default. It moves heavy analysis work out of the Visual Studio process, helping prevent UI freezes and keep typing smooth. This release continues to polish OOP mode and fix some of the remaining issues:
    • Includes Analyzer is now available in OOP mode.
    • Visual Studio's F8 and Shift+F8 shortcuts navigate between ReSharper's Find Usages results.
    • The New from Template command is once again available in the Solution Explorer context menu for C⁠+⁠+ projects.
• Unit testing in CMake projects
  • CMake projects opened in Visual Studio's Open Folder mode are now built before unit tests are run, according to the Build Policy setting of the unit test session.

• Installing ReSharper C++ through systems management software no longer fails when the software's deeply nested working folders make dependency paths exceed the path length limit.

• C++
  • Issue with bad parent 3 of 'QualifiedMsDeclSpecPropertyAccessorReference'.
  • Exception in parser in file '1.cpp' Exception during parsing file "1.cpp".
  • May not be null issue.

• C++
  • It is impossible to trace path to local entity 'compound_statement <compound statement>' in substituted function '<+typename...>f' body.
  • Evaluation failure in lambda inside expansion-statement.
  • Issue with Clang support of keyword _Alignas in C++.
  • Type 'A' is incomplete with C++26 reflection.
• Code Analysis
  • Analyzer threw an exception.
  • Struct can be moved into anonymous namespace in C file.
• Unit Testing
  • ReSharper C++ 2026.2 passes Google Test filter through unsupported @gtest.rsp response file.
• Unreal Engine
  • Object reference not set to an instance of an object.

C++ support

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

ISPC language support

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

Unreal Engine

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

Code analysis

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

Coding assistance

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

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

Performance

• ReSharper C⁠+⁠+ 2026.1 brings significant performance optimizations across all stages of the IDE experience, specifically tuned for the demands of large-scale Unreal Engine projects. Measurements on the Lyra sample project for Unreal Engine in Out-of-Process mode demonstrate these improvements:
  • Initial indexing of C⁠+⁠+ code is now up to 20% faster, reducing the wait when you open a solution for the first time.
  • Warm startup time has been improved by more than 20%, so returning to a previously opened solution is noticeably faster.
  • Backend memory usage after a warm start has been reduced by up to 21%, leaving more resources available for the rest of your workflow.

Language features

• ReSharper C⁠+⁠+ now supports the #embed preprocessor directive introduced in C⁠+⁠+⁠26 and C23. This directive lets you embed the contents of a binary resource file directly into your source code, without the need for external tooling or code generation.
• This release also adds support for two additional language features:
  • _Countof operator: ReSharper C⁠+⁠+ now recognizes the _Countof operator from C2Y (the upcoming C standard), which returns the element count of an array.
  • Extended floating-point types: bfloat16_t, float16_t, and float128_t floating-point types standardized in C⁠+⁠+⁠23 are now supported.
• ReSharper C⁠+⁠+ 2026.1 improves compatibility with compiler-specific extensions:
  • Nested functions: ReSharper C⁠+⁠+ now supports GCC's extension for defining functions inside other functions in C code.
  • _Nullable/_Nonnull qualifiers: Clang's pointer nullability qualifiers are now recognized by the parser.

Coding assistance

• Reduce cognitive load with ReSharper C⁠+⁠+⁠'⁠s new auto-import support for C⁠+⁠+⁠20 modules. When you use an exported symbol but the corresponding import declaration is missing, the IDE now provides a smart suggestion to insert it automatically. Currently, auto-import is supported only for symbols exported directly from primary module interface units and module partitions.
• Postfix completion has been extended to cover the following scenarios:
  • Primitive types: Postfix completion previously only worked with class and struct types. It now also handles expressions of primitive types like int, bool, and float.
  • Literals: Postfix completion now works after literals, so typing 42.cos expands to cos(42).
  • User-defined literal suffixes: Code completion is now available for user-defined literal operators.
• Two auto-indent improvements contribute to a smoother editing experience:
  • Pressing Enter between the braces of a control-flow statement or a class definition now correctly positions the cursor with proper indentation even when attributes are present (e.g. class [[deprecated]] MyClass {}).
  • Auto-indentation inside extern blocks now respects the Indent linkage specification block members formatting setting.

Unreal Engine

• BlueprintPure in Code Vision: Code Vision now recognizes functions marked with the BlueprintPure specifier in addition to BlueprintCallable.
• Event implementations in Code Vision: Code Vision now detects implementations of BlueprintNativeEvent and BlueprintImplementableEvent functions in Blueprint assets.
• Find Usages for delegate properties: Find Usages now discovers Blueprint-side bindings for BlueprintAssignable delegate properties.
• Improved Blueprint search accuracy: Find Usages for Blueprint references now searches by asset path instead of Blueprint name. This means that if your project contains multiple Blueprints with the same name, the search results are no longer ambiguous.
• ReSharper C⁠+⁠+ now 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.
• ReSharper C⁠+⁠+ also adds support for the UnrealHeaderTool changes in the upcoming Unreal Engine 5.8. In particular, the DECLARE_DYNAMIC_MULTICAST_DELEGATE macros no longer trigger false-positive errors in code analysis.

Code analysis

• ReSharper C⁠+⁠+ 2026.1 updates the bundled Clang-Tidy binary, bringing the latest checks and enhancements from the LLVM 22 release.
• A new inspection detects designated initializers that appear in a different order than the corresponding members are declared in the struct. Since C⁠+⁠+⁠20 requires designated initializers to follow the declaration order, out-of-order initializers result in a compilation error. ReSharper C⁠+⁠+ now flags these cases and provides a quick-fix that automatically reorders the initializer list to match the struct definition.
• Another new inspection warns you when a function has a different access level (public, protected, or private) than the virtual function it overrides in the base class. While C⁠+⁠+ permits changing the access level of an override, doing so is often unintentional and can lead to surprising behavior. The inspection helps catch these subtle mismatches.
• This release extends Unused symbol inspections to class members defined in .cpp source files. Previously, these members were assumed to be externally visible and excluded from the Unused symbol analysis. Now, they are analyzed the same way as static functions and anonymous namespace members.

Navigation

• Refined the gutter marks in C⁠+⁠+ files to help you navigate and understand complex codebases with minimal effort.
• Tooltips with semantic highlighting: Tooltips that appear when hovering over gutter marks now feature semantic highlighting, making them easier to read at a glance.
• Navigation to base classes: A new gutter icon on class definitions lets you navigate upward in the inheritance hierarchy to base classes, complementing the existing marks for navigating to derived classes.
• Go to Declaration and other navigation actions now work on the opening brace in brace initialization expressions (e.g. MyStruct { 1 }), in addition to the type name.

Visual Studio integration

• ReSharper C⁠+⁠+ tooltips are now available in Visual Studio 2026, restoring the tooltip support that was missing in the initial Visual Studio 2026 compatibility release. Tooltip presentation has also been improved: icons now help distinguish between symbol types, and theming support has been enhanced.
• Several editor UI elements in ReSharper have been refreshed to better align with the modern look of the Visual Studio experience.
• Thanks to a redesign, the code completion UI now provides a cleaner and more consistent look within the editor.
• Also modernized a number of related UI components, including parameter info popups, tooltips, and other editor popups, replacing outdated visuals and improving their appearance across themes and DPI settings.
• The updated UI now supports Visual Studio's editor zoom feature, ensuring completion lists and parameter info scale correctly when zoom levels change.

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