# resharper-unity, and the editor that knows what OnCollisionEnter is

> This JetBrains plugin adds Unity-specific support to ReSharper and Rider: knowledge of the Unity API surface, event functions, coroutines, shader and meta file handling, and a Unity Editor plugin. It ships as one codebase for two IDEs, and the published tags stopped in 2023 while the branch kept moving.

**JetBrains/resharper-unity** — Unity support for both ReSharper and Rider

- Repository: https://github.com/JetBrains/resharper-unity
- Stars: 1,233 · Forks: 142
- Language: C#
- License: Apache-2.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/jetbrains-resharper-unity

## One plugin, two IDEs, and a problem only Unity has

The Unity Support plugin adds specific functionality for the Unity game engine to ReSharper and Rider, and it is an official JetBrains project.

The problem it solves is that Unity C# is not quite C#. The engine calls your methods by name through reflection, so a method called OnCollisionEnter is invoked by the engine even though nothing in your code calls it, and a generic C# analyser sees an uncalled private method and correctly reports it as unused. Unity developers get that warning on nearly every script, and the standard advice of suppressing it one method at a time is miserable.

The plugin's answer is to teach the IDE the Unity API surface. It knows about all Unity based classes, MonoBehaviour, ScriptableObject, EditorWindow and the rest, and their event functions, via analysis of the Unity API surface and documentation. Support for the Unity API starts from version 5.0.

That knowledge is what turns the whole feature set on. Once the analyser knows that a method name is an event function, it can mark it, generate it, complete it, check its signature and describe it.

The audience is Unity developers who want a real IDE instead of the default editor, and the plugin's pitch is stated in the README: Rider can replace the default MonoDevelop editor with an IDE providing rich code navigation, inspections and refactorings, and Rider itself is JetBrains' cross platform .NET IDE, based on ReSharper and the IntelliJ Platform, running on Windows, Mac and Linux.

## The install path changed twice, and Unity 2017.1 left a scar

The installation instructions are split by Unity version, which is the first sign that this plugin has been through several platform generations.

For Unity 2019.2 and later, the process is one setting: in Unity, choose Rider as the External Editor in the Unity settings. Uninstall is the same operation in reverse, choosing a different External Editor.

For Unity 2019.1 and earlier, the plugin comes bundled with Rider, so manual installation is not required, but Unity still has to be configured to use Rider as the external script editor. The steps depend on whether a .sln file is present. If it is, start Rider and open the .sln file, and Rider will install a Unity Editor plugin into the project. Otherwise, start Rider and open the project folder, and Rider shows a notification offering to install that plugin.

Then you switch back to the Unity Editor with the same project open, and the new Unity Editor plugin automatically configures Rider as the external script editor. The documentation notes that this only needs to be done once, and that it can also be done by hand through the Unity Editor's External Editor preference pane.

The old-Unity path has a documented quirk. Rider adds an Assets, Open C# Project in Rider menu item for older Unity versions, because prior to 2017.1 the Unity Editor does not recognise Rider as an editor that can load C# solutions and would also launch MonoDevelop. Other than not launching MonoDevelop, the menu items are identical.

The solution can also be loaded directly with the Assets, Open C# Project menu item, and more file types can be associated with Rider by editing Additional extensions in the Edit, Project Settings, Editor pane. For the standalone ReSharper plugin the install is the ReSharper, Extension Manager, where you search for Unity Support.

## Event functions: gutter icons, dead code, generation and completion

The feature list is long, and the event function group is the core of it.

Event functions and fields implicitly used by Unity are marked with an icon in the gutter, and empty event functions are marked as dead code with a Quick Fix to remove the method. When Solution Wide Analysis is enabled, implicitly used fields and event functions are marked as in use, and fields are highlighted if they are not accessed in your code.

Generation is covered from the other end. A new Generate Unity event function menu item is added to the Alt+Insert Generate Code menu, so you can create an event function through a dialog, and the same action is available from Alt+Enter on a Unity based class name.

Completion is the third piece. Auto complete suggests event function names when declaring methods in Unity based classes and expands to include the method signature, so you start typing an event function inside a class deriving from a known Unity class, such as MonoBehaviour, and the rest is filled in.

The inspection side catches mistakes that are easy to make and annoying to find. Incorrect method signatures and return types are shown as warnings with a Quick Fix to create the correct signature, and optional parameters are called out in a tooltip and marked as unused if they are not used in the body of the method.

```csharp
OnCollisionEnter(Collision collision)
```

There is also a naming carve-out, which is the kind of detail that shows the plugin is used by real Unity code. Naming consistency warnings are suppressed for known Unity event functions, so the tool no longer suggests that AnimatorIK be renamed to AnimatorIk. Descriptions for event functions and parameters are shown in tooltips and in QuickDoc, and the Read more link in QuickDoc navigates to the Unity API documentation, locally if it is available or via the Unity website otherwise.

## Coroutines, Invoke string literals and networking attributes

The plugin also handles the cases where Unity code passes names as strings, which is where a static analyser is normally blind.

For coroutines, event functions that can be coroutines are called out in tooltips, there is a Context Action on methods that can be coroutines to convert the method signature to or from a coroutine, and there are warnings for unused coroutine return values.

For the Invoke family, there is code completion, find usages and rename support for the string literals in MonoBehaviour.Invoke, IsInvoking, InvokeRepeating and CancelInvoke. It also supports StartCoroutine and StopCoroutine and understands the overloads there.

That last point is the reason the string literal support matters. A method name written as a string is a name the tool cannot refactor safely, so a rename of a coroutine method leaves the string behind and the game breaks at runtime. Making the strings first class means the rename reaches them.

Networking gets the same treatment. There is code completion, find usages and rename support for string literals in the SyncVar attribute, in the hook parameter.

```csharp
[SyncVar(hook = "OnValueChanged")]
```

That is a networked object hook, and a hook name in an attribute is exactly the kind of string that a rename misses. The plugin treats it as a reference.

Taken together, the pattern is consistent. The plugin's job is not to add new refactorings but to make the engine's string based conventions visible to the refactorings that already exist.

## The Unity Editor plugin: meta files, shaders and the debugger

Beyond the analysis features, the plugin does one more thing that lives on the Unity side rather than the IDE side.

The first is the Unity Editor plugin itself, which Rider installs into each Unity project it opens. That component is what handles the automatic handling of.meta files and the support for.shader files, and in Rider it adds support for attaching the debugger to the Editor instance, so you can debug the editor process itself rather than only the player.

The meta file part is the quietly important one. Unity keeps a.meta file next to every asset, and those files hold the asset's GUID, which is what other assets reference. A tool that treats them as noise, or that reformats them, breaks references across a project, so an IDE that opens the project and integrates with Unity has to leave them alone or understand them.

The repository keeps separate rider and resharper directories because both IDEs share one plugin codebase.

The install and uninstall story is worth noting too, because it is the part that is most likely to confuse someone. For uninstall, you choose a different external editor in the Unity settings and delete the Editor plugin from your project.

So the cleanup is two steps, and if you only do the first, the Unity Editor plugin stays in the project, still configured to point at Rider.

## A build system with a signing key, and release tags that stopped in 2023

The repository layout shows a serious plugin build rather than a hobby project. There is a common directory, a resharper directory, a rider directory, a unity directory, a debugger directory, a buildScripts directory, a tools directory and a docs directory, plus Packaging.props, a SubplatformsCollection.Root and an SdkBasedPluginEmbedding.Root for the packaging, a sign.snk signing key, a dotnet-sdk.cmd, and both build.ps1 and build.sh for building on Windows and on Unix.

The build status badges point at two different CI systems, AppVeyor and Travis, and at a branch named 182, which is the branch the badges are configured to report on.

The release history is the weak point. The listed releases are net231-rtm-2023.1.2, net231-rtm-2023.1.1 and net231-rtm-2023.1.0, all dated 2023-06-21, and their titles name the Rider and ReSharper versions they target, with Rider 2023.1.x and ReSharper 2023.1. The tag names encode the target framework and the release channel.

So the published artefacts are from 2023, while the last push was on 2026-10-18 and the repository is not archived. That means the plugin is still being developed, and JetBrains ships it inside Rider for current versions, which is why the README says manual installation is not required for Rider. The tags in this repository are for the ReSharper plugin and for Rider versions that predate the bundling.

The licence is Apache-2.0, in a license.txt at the top level, and there is a CHANGELOG.md, a CONTRIBUTING.md and an OWNERSHIP file.

## Conclusion

Adopt this plugin if you write Unity C# in an IDE and want the event functions, coroutines and Unity API names treated as first class citizens rather than as strings a generic C# analyser has to guess at, and if you use Rider the install is close to automatic. Do not adopt it as a replacement for a Unity version upgrade path, since the published tags stop at the 2023.1.x builds for Rider and ReSharper even though the branch is still receiving commits. Before you rely on it, check which Rider and ReSharper versions your IDE can load the plugin into, and note that the feature set is tied to the Unity API surface the plugin analyses, so a very old or very new Unity version may not line up with what the inspections know.

## FAQ

### What does the resharper-unity plugin add to ReSharper and Rider?

It adds Unity specific functionality: knowledge of the Unity API surface and its event functions, code completion and generation of those functions, inspections for common errors with quick fixes, support for .shader files, automatic handling of .meta files, and in Rider support for attaching the debugger to the Unity Editor instance.

### How do I install the Unity Support plugin in ReSharper?

Open the ReSharper, Extension Manager and search for Unity Support. For Rider, the plugin is bundled and no manual installation is required; you configure Unity to use Rider as the external script editor, either automatically on first open of the solution or by hand in the Unity Editor's External Editor preference pane.

### Why does my Unity event function get reported as unused code?

With this plugin installed the analyser knows the Unity event functions and marks them with an icon in the gutter, and with Solution Wide Analysis enabled it marks implicitly used fields and event functions as in use, so a method called by the engine is no longer reported as dead code.

### Does the plugin support renaming Unity methods called by string?

Yes. There is code completion, find usages and rename support for the string literals in MonoBehaviour.Invoke, IsInvoking, InvokeRepeating and CancelInvoke, for StartCoroutine and StopCoroutine, and for string literals in the SyncVar attribute hook parameter.

### What licence is resharper-unity released under?

Apache-2.0, in the license.txt file at the top of the repository. The listed releases are the net231-rtm-2023.1.x builds for Rider 2023.1 and ReSharper 2023.1, all dated 2023-06-21, while the last push was on 2026-10-18.

## Sources

- [Issues](https://github.com/JetBrains/resharper-unity/issues)
- [JetBrains/resharper-unity on GitHub](https://github.com/JetBrains/resharper-unity)
- [License: Apache-2.0](https://github.com/JetBrains/resharper-unity/blob/master/LICENSE)
- [README](https://github.com/JetBrains/resharper-unity/blob/master/README.md)
- [Releases](https://github.com/JetBrains/resharper-unity/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jetbrains-resharper-unity