Mulligan Renamer does the tedious half of a Unity rename, in four install flavours

Renaming many objects without hand editing each one

The Mulligan Renamer tool for Unity allows for quick and safe renaming of many assets or GameObjects all at once, according to the repository description, and the README says the same thing in slightly more detail.

The problem it solves is narrow and real. In the Unity Editor, renaming a single object is a context menu action, but a rename that affects a hundred objects, or a rename that has to follow a convention across a folder, is a manual grind in the Project window. Mulligan Renamer puts a window in front of that grind and applies a sequence of operations to a whole selection.

The tool opens from the Window/Red Blue menu. If you already have objects selected when you open it, they are entered for rename automatically. Otherwise you drag and drop the assets or GameObjects you want into the window.

That two path entry is the right ergonomic choice and worth noting for anyone evaluating it. The selection-aware path suits an artist who has just filtered the Project window, and the drag and drop path suits anyone who is renaming a specific set of files from disk.

The primary language of the repository is C#, and the licence is MIT with the text in the LICENSE file.

Five rename operations, and they compose

The README lists the operations and gives a worked example for each, which is unusually good documentation for an editor tool.

Search String and Replacement String replaces substrings in the selected objects. The example is the name Char_Hero_Idle with search string Hero and replacement string Enemy, which yields Char_Enemy_Idle. There is a Regular Expressions mode for search and replace, described as allowing just about any rename operation.

Prefix and Suffix additions put text at the start or the end of every object. The name Hero with the added prefix Char_ and suffix _Idle yields Char_Hero_Idle.

Trimming deletes a number of characters from the front or the back. The name CHairA with 1 specified to Delete from Front and 1 specified to Delete from Back yields Hair.

Enumerating adds sequential numbers to the end of each object name. The README notes this is added after the deletions or suffix additions. Selecting 3 objects all named Wall, specifying "00" or "D2" as the format string, and a Starting Count of 0 yields Wall00, Wall01 and Wall02.

And the key line is the last one: you can combine any number of the rename operations in any order to achieve the results you want. The sequencing rule matters. Enumeration runs after deletions and suffix additions, so if you trim a prefix and then want numbering, the numbers land on the trimmed name rather than being affected by the trim. The wiki page on rename operations covers this in more detail than the README does.

Four install routes, and which one suits your pipeline

The README documents four ways to get Mulligan Renamer into a project, which is unusual and reflects the different ways Unity projects are set up.

The simplest is the Unity Asset Store, where the tool can be installed for free through the Unity Asset Store listing.

The next is as a UPM package from GitHub, by adding a dependency to your Project/Packages/manifest.json.

"com.redbluegames.mulligan": "https://github.com/redbluegames/unity-mulligan-renamer.git?path=/Assets/RedBlueGames/MulliganRenamer"

Your file then looks something like this, with the Mulligan entry alongside the other dependencies and a testables block.

{
  "dependencies": {
    "com.redbluegames.mulligan": "https://github.com/redbluegames/unity-mulligan-renamer.git?path=/Assets/RedBlueGames/MulliganRenamer",
    "com.unity.textmeshpro": "2.1.1",
    "com.unity.timeline": "1.2.17",
    "com.unity.ugui": "1.0.0",
  },
  "testables": [
    "com.unity.inputsystem"
  ]
}

Save the file and, when you open Unity, it should automatically download Mulligan and add it to your Packages folder in the project.

The third route is a .unitypackage from the Releases page. You download the latest file, open the Unity project you want to import into, and install it through the Asset menu, in Unity Editor going to Assets, then Import Package, then Custom Package. The README recommends storing the files at the default location of Assets/RedBlueGames, while noting it should work anywhere.

The fourth is npm. The package is registered at the npm registry as com.redbluegames.mulligan, and you can install it manually with npm or point Unity Package Manager at it through a scoped registry entry in manifest.json.

The npm route and its scoped registry block

The npm installation path is worth reading closely, because it shows the two ways the package is meant to be consumed.

You can use npm to install it manually, or you can add a scoped registry to your Packages/manifest.json so that Unity Package Manager resolves the package itself.

{
  "scopedRegistries": [
    {
      "name": "NPM",
      "url": "https://registry.npmjs.org",
      "scopes": [
        "com.redbluegames"
      ]
    }
  ],
  "dependencies": {
    "com.redbluegames.mulligan": "1.7.5"
  }
}

The scopedRegistries block maps the com.redbluegames scope to the npm registry URL, and the dependencies block then pins a specific version.

Note the version in that example, 1.7.5. The recent releases listed for the repository are v1.7.8 on 2022-02-17, v1.7.6 on 2021-07-18 and v1.7.4 on 2021-01-20, so the pinned version in the README is a little behind the newest tag. The dependencies block takes a version rather than a git URL, which is what makes the registry entry necessary in the first place.

The practical difference between the routes is where the source of truth lives. The Asset Store gives you a curated, updatable install in the editor. The GitHub UPM entry points at a branch or path in the repository, so it tracks whatever is on that path. The npm entry pins a published version. Which one you want depends on whether you want updates to arrive through the Asset Store, through a git reference, or through a version bump you control.

What it does not cover, and where the wiki takes over

The README describes the tool as a set of rename operations on names, and that is the limit of it.

There is no command line interface. Everything happens in the editor window, so this is not a tool you run in a build pipeline or in a batch script over a repository of assets. The scripts and automation paths in the README cover installation only, not operation.

There is also no mention of renaming assets on disk outside the editor, which matters if your project keeps art outside the Unity project folder and syncs it in. The renames happen inside Unity, where the asset database and the references between assets are known.

The README itself is candid about its own scope. It says it provides a quick overview of the tool and points to the wiki for more detailed documentation, with a dedicated page on rename operations. So the operation reference, including the full set of options for each operation, lives outside the repository.

That is a reasonable split for an editor tool, but it does mean the repository README is not enough to decide whether the tool covers your case. If your rename needs a conditional rule, a pattern match on file contents, or a mapping table from old names to new names, the wiki page is where you find out whether it exists.

A community tool with a package manifest and a licence

The repository layout shows the shape of a Unity Editor package rather than a library. There is an Assets/ directory holding the tool, a Packages/ directory, ProjectSettings/, a UnityPackageManager/ directory, and the files that Unity itself expects, RBPackageSettings.cs, LanguageBookmarks.json and the .sln.DotSettings file. The .circleci/ directory and .idea/ and .vscode/ directories suggest continuous integration and editor tooling, and the ReadMeImages/ directory holds the banner and the animated overview used in the README.

The Assets directory also implies the tool ships with localisation, since the contributors list names people who did the Portuguese translation and localisation, the Spanish translation, and the Simplified Chinese translation, alongside a contributor credited with cleanup and keeping the lights on and one credited with continuous integration support. There is a spelling configuration in the top level, wordlist.txt, which is what a translated editor UI needs in order for the spell checker to pass.

The licence is MIT. For a tool that modifies your project files, permissive licensing is the low risk choice, and the README points at a Contributing Guidelines document that asks people to read it before submitting a pull request.

On maintenance, the repository is not archived and the last push was on 2026-09-05, which is more recent than the newest tagged release of v1.7.8 from 2022-02-17. So the project is still receiving work while the published versions are several years old, and the Asset Store listing is the version most users will actually be running.

Editorial conclusion

Adopt Mulligan Renamer if you work in the Unity Editor and need to rename dozens of assets or GameObjects in one pass, especially when the change is a prefix, a suffix, a trim or a sequence number. Do not adopt it if you need to rename across a project from the command line, because it is an editor window with no CLI, and it does not replace a proper asset management tool for large renames. Before you install it, check which Unity version your project targets against the package's compatibility, and run the rename on a small selection first with a version control commit behind you, since renames touch project files that reference the renamed assets.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. redbluegames/unity-mulligan-renamer on GitHub
5. Releases