AssetRipper: a GUI for pulling assets out of Unity builds

What AssetRipper is for, and who actually needs it

The README frames AssetRipper around four jobs, all of them developer-facing: finding dependency assets that were accidentally included in a game, converting assets into the native Unity engine format, identifying code that could not be inlined or trimmed from a build, and finding broken asset references. That list tells you the intended user. It is the person who built the game and wants to inspect what actually shipped, not the person who wants someone else's art.

The distinction matters because the tool has no access control and no notion of ownership. It reads a build and writes a Unity project. Nothing in the workflow asks whether you are entitled to the files inside. The README addresses this only through disclaimers: GPL-3.0 licensing, no affiliation with Unity Technologies, and a Credits page for attributions. There is no section on permitted use.

The version range is wide. The README states support for Unity versions from 3.5.0 to 6000.4.X, then immediately qualifies it: support quality may vary slightly for different Unity versions. That sentence is doing a lot of work. A build from a well-trodden Unity 2019 or 2020 release is a different proposition from one on the newest 6000.4.X line, and the README does not break the range down further.

How the extraction pipeline works

AssetRipper is a C# application built from a single solution file, AssetRipper.slnx, at the repository root. The top-level layout separates Source/ from Localizations/, docs/ and Media/, which matches the shape of a desktop tool with a translation layer rather than a library you link against.

The mechanism, as the README describes it, is a conversion rather than a viewer. You point the tool at Unity game files and it produces a Unity project. That output is the point of the design: the README's second bullet is explicitly about converting assets into the native Unity engine format, which means the result is meant to be opened in the Unity editor, not merely browsed.

That choice has consequences. A converter has to reconstruct relationships between assets, not just decode individual files. Reconstructing a reference graph is where version differences bite, and it is the most plausible explanation for the README's caveat about uneven support quality. A viewer can show you a mesh without knowing what references it. A converter has to decide where that mesh belongs.

The README also lists identifying code that could not be inlined or trimmed. That is a build-audit use, and it depends on the same conversion path: the tool has to surface what survived the build process rather than what the source project contained.

Getting AssetRipper and running a first extraction

The README does not give build-from-source instructions or a command-line invocation. It points to a downloads page at assetripper.com/download.html. Since the README documents no install command, treat that page as the entry point and do not expect a package manager install. The repository does carry a nuget.config at the top level, which indicates NuGet is involved when the project is built from source, but the README does not document the build steps themselves.

What the repository does give you is the project file. AssetRipper.slnx sits at the root, and the source lives under Source/. That is the whole of the documented structure.

AssetRipper.slnx
Source/
Localizations/
docs/
Media/
LICENSE.md
nuget.config

Once you have a build, the workflow is graphical. Open the application, select the game files or folder you want analyzed, choose an output directory, and start the export. The README describes the result as assets converted into the native Unity engine format, so the output is a Unity project directory rather than a folder of loose files.

Open that output folder with a Unity editor, and expect the import to reveal what the README warns about. If assets come in unreadable or references do not resolve, the version gap is the first thing to check, not your steps.

Where AssetRipper breaks down

The honest limitation is stated in the README itself: support quality may vary slightly for different Unity versions. Read that as a warning about the newest engine releases. A tool that claims coverage up to 6000.4.X is claiming a moving target, and the qualifier is the maintainer telling you the edges are soft.

The second limitation is structural. Extraction from a built game is lossy by nature. Code that was inlined or trimmed is gone, which is precisely why the README lists finding it as a use case: you can identify that something was trimmed, but you cannot recover the original form. Asset names, folder structure and import settings may not survive the round trip either, and the README makes no promise that they do.

The third is platform. Every related search phrase about mobile or Android or an online version describes something the repository does not contain. The top-level entries are a solution file, source, localizations, docs and media. There is no web frontend and no mobile project. Anyone searching for an online or Android build is looking for something that does not exist here.

Finally, this is the wrong tool if you want a quick look at one texture. Opening a full conversion to inspect a single file is a heavy path, and a format-specific extractor will be faster.

AssetRipper against AssetStudio

The comparison people search for is AssetRipper versus AssetStudio, and the difference is in the output contract rather than the input format. Both read Unity files. AssetStudio is oriented around browsing and exporting individual assets: you load a bundle, inspect a tree, and pull out what you want. AssetRipper is oriented around producing a Unity project, which the README states directly in its second bullet about converting assets into the native Unity engine format.

That changes what you do with the result. With a project-level output you can open the result in the editor and let Unity resolve references, which is what makes the broken-reference and dependency-audit use cases workable. With per-asset export you get files, and you reassemble the relationships yourself.

The trade-off runs the other way too. A full conversion takes longer and produces more output than you may want. If your task is to check one sprite, the project-level approach is overhead. If your task is to understand how assets in a build reference each other, per-asset export leaves you doing the graph work by hand.

AssetRipper also carries a licence obligation that a browsing tool may not: it is GPL-3.0, and the README states that plainly.

Licence, maintenance and the premium edition

AssetRipper is licensed under the GNU General Public License v3.0, per the README and the LICENSE.md file at the repository root. GPL-3.0 is a copyleft licence, so if you distribute a modified version of the tool you take on obligations that a permissive licence would not impose. Using the tool to produce output is a separate question from modifying and redistributing the tool, and the README does not discuss it. For anything beyond personal inspection, ask a lawyer rather than reading a README.

The README also states that AssetRipper is not sponsored by or affiliated with Unity Technologies, and that Unity is a registered trademark of Unity Technologies. Nothing about the project's output changes Unity's terms.

On maintenance: the last push to the default branch was on 2026-08-24, and release 2.0.0 carries the same timestamp. The previous release, 1.3.14, is dated 2026-04-25, and 1.3.12 before that on 2026-03-19. The 2.0.0 release is a major version bump after a run of 1.3.x releases, which suggests a breaking change rather than an incremental patch, though the README does not describe what changed.

There is a premium edition. The README links to a features page and states that users can access AssetRipper Premium with an active $10 subscription on Ko-fi, Buy Me a Coffee, GitHub Sponsors or PayPal. The README does not list which features are premium-only, so check the linked page before assuming a capability is in the free build.

Editorial conclusion

Adopt AssetRipper if you are a Unity developer inspecting your own shipped build for dependency assets, broken references or code that survived trimming, and you can work inside GPL-3.0. Do not adopt it if you need a legally clean pipeline for redistributing someone else's art, or if you need a mobile or in-browser version, since none is described. Before committing, verify your exact Unity version is covered by the README's stated range of 3.5.0 to 6000.4.X, and check the Credits page for the attribution list that ships with the project.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes