# AnimeStudio: opening Unity bundles, encrypted ones included

> AnimeStudio is a Windows tool that opens Unity asset bundles, handles the encrypted bundles used by Genshin Impact, Star Rail and Zenless Zone Zero, and exports textures, meshes, animations, audio and shaders from a GUI or a CLI. The first decision it asks you to make is which game you are extracting from, because the decryption differs per title.

**Escartem/AnimeStudio** — Asset extraction tool for unity games, supports many encrypted titles including all Hoyoverse ones (*ﾟ∀ﾟ*)

- Repository: https://github.com/Escartem/AnimeStudio
- Stars: 1,294 · Forks: 215
- Language: C++
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/escartem-animestudio

## It opens bundles and shows you what is inside

AnimeStudio opens Unity bundles and lets you browse, preview and export their contents, which the README lists as textures, meshes, animations, audio, shaders and text assets. It handles the encrypted bundles used by Genshin Impact, Star Rail and Zenless Zone Zero and their other upcoming titles, it works on a long list of other encrypted games, and it works on regular Unity games too.

That last clause matters for how you think about the tool. This is not a Hoyoverse special case with a general purpose fallback, it is a general Unity asset reader with decryption support for the titles that need it.

The project ships as a GUI and a CLI in the same download. The README is explicit about which one to use: the GUI is what you want if you are just looking for assets, and the CLI is there for scripting and batch exports. That split is the same as a lot of extraction tooling, and it is the right one, because browsing an install interactively and dumping ten thousand textures on a schedule are different jobs with different interfaces.

The implementation is C++ and .NET together, with a native library layer and a managed application layer. The repository layout shows the split, with AnimeStudio.GUI/ and AnimeStudio.CLI/ as the two applications, AnimeStudio/ holding the core, and separate directories for the native pieces, AnimeStudio.Ooz/, AnimeStudio.FBXNative/, AnimeStudio.FBXWrapper/, AnimeStudio.HLSLDecompiler/, AnimeStudio.ACL/, AnimeStudio.PInvoke/, AnimeStudio.Patcher/ and AnimeStudio.Utility/. The licence is MIT.

## The game selector is the first decision, and the wrong choice gives garbage

The usage instructions are short, and the first line carries the most important warning in the README. You pick your game in the game selector first, and only then load a file or a folder, because each game has its own decryption, and loading with the wrong one selected will either fail or give you garbage.

That failure mode is worth dwelling on. A tool that said wrong game, try again would be an annoyance. A tool that produces plausible looking but corrupted assets is a trap, because you do not notice until you have exported thousands of files. The list has over 50 entries, including separate ones for closed beta versions, so the advice is to take the one that matches the build your files come from, and a build from a beta is a different entry from the release.

Once the game is right, the loop is ordinary. Load a file or a folder, browse the list, and export what you want. Assets can be filtered by type, by name or by container path, and most types can be previewed before exporting, which saves the export of the thousand textures you did not want.

The container path filter is the one that matters at scale. Unity bundles are organised into container paths that mirror the game's asset folder structure, so filtering by path is how you export one character, one environment set or one UI skin rather than the whole install.

The README also points at the official wiki for detail, at an original tutorial by Modder4869, and at the original readme of the project it descends from, RazTools' Studio, which is the historical starting point for this kind of tool.

## The Asset Browser is the answer to a game install you cannot load every time

For big dumps there is the Asset Browser, and it is the part of the tool that shows real design rather than just functionality.

It builds a map of everything in a game install, so you can search it without loading the whole thing every time. On a modern Hoyoverse title the install is large enough that loading it repeatedly is the difference between a usable tool and an unusable one, so a persistent index is the enabling feature rather than a convenience.

The maps have three properties worth knowing. They can be saved as message pack or json, so the format is a choice rather than a constraint, and message pack is the faster one for a large index. They can be relocated to a different install folder, which means a map built on one machine can be reused when the install moves or when you want to compare against a copy elsewhere. And two of them can be loaded side by side to see what changed between versions.

That last one is the genuinely useful feature for modding work. A game update is a diff, and if you can see which assets were added, changed or removed between two builds, you know what your mod has to account for without diffing two directories of binary files by hand.

The CLI exposes the same machinery through the --map_op and --map_type flags, so the map can be built in a script rather than only in the GUI.

## The CLI takes the same options as flags

The command line interface mirrors the GUI options, and the README gives a single worked example with an input path and an output path.

```
AnimeStudio.CLI.exe <input> <output> --game GI --types Texture2D,Sprite --export_type convert
```

That example selects the game, restricts the export to two asset types, and asks for conversion on export.

The flags worth remembering are the filters and the layout controls. --game picks the title, which is the same decision the GUI asks for and carries the same risk. --types, --names and --containers filter what gets exported. --group_assets controls the output folder layout, which is what keeps a large export navigable. --map_op and --map_type build the asset maps described earlier. And --silent keeps the output quiet, which is what you want in a script that runs unattended.

Running the executable with no arguments prints the full list, which is the documented way to find out what else is available. That is a small thing, but it is the difference between a CLI you can discover and one you have to be told about.

The wiki goes into the detail on all of this, and the Discord server is the fallback for anything the wiki does not cover.

## Four native libraries that you almost never rebuild

The native side is a set of separate projects, and the README explains when you need them.

The build script does not build them. They sit prebuilt in AnimeStudio.Libraries and only need rebuilding when you touch their sources. Each one is its own project in the solution and outputs straight into that folder.

AnimeStudio.Ooz produces AnimeStudio.Ooz.dll and handles Kraken, Mermaid and Leviathan decompression, the decompression that makes a compressed bundle readable in the first place. AnimeStudio.HLSLDecompiler produces a library for shader decompilation. AnimeStudio.FBXNative handles FBX export and needs the Autodesk FBX SDK at exactly version 2020.3.7 installed, which is the single most annoying dependency in the project because the version is pinned rather than ranged. And AnimeStudio.ACL.DB,.ZZZ and.SR are three libraries for animation decompression, one per ACL version, which is a small design lesson in itself: the same problem recurred as the animation format was revised, and instead of one library with three code paths there are three libraries.

All of them are x64 only, and all of them are excluded from the solution build, so they are built by hand when needed. That exclusion is a deliberate choice to keep the normal build fast, and it means a from-source build gives you a working application but not a working FBX export unless you also satisfy the SDK requirement.

## Building it means two .NET frameworks and one script

The build requirements are specific. You need Visual Studio 2022 with the C++ desktop workload and the .NET 9 and 10 SDKs, both of them, because the project targets both frameworks and produces a build for each.

The packaging script build.ps1 builds the GUI and the CLI for both frameworks and packages them into a dist directory. The README notes that this is the same script the CI runs, so if it works there it works locally, which is a useful property for a script that touches several projects and a packaging step.

For day to day work, dotnet build AnimeStudio.GUI is enough. The packaging step is only needed for a release. The solution file is AnimeStudio.slnx, the newer XML solution format, and Directory.Build.props at the root holds the shared build properties.

That split between daily build and release build is what makes the repository usable for a contributor. Adding a game is a code change in the core, and it does not require the native libraries, the FBX SDK, or the packaging step to iterate on it. The build script is there for the moment when you need an artefact.

The project also keeps an official wiki, and contributions are welcome whether it is a new game, a fix for an existing one or anything else, with pull requests reviewed by the maintainers.

## The licence covers the tool, not the assets it hands you

AnimeStudio is MIT licensed, which means the tool itself is free to use, read and modify. The assets it exports are a different matter, and the sensible position is that they belong to the games they came from.

Extracting your own install for study, for making your own mods, for a presentation about a game's art pipeline, or for a private collection of a texture you like is a normal use of a tool like this. Redistributing a large set of extracted assets is a different act, and the terms of service of the game in question are the place to look. This is not legal advice, it is the observation that the MIT licence of the tool says nothing at all about the copyright of the content it produces.

The distribution channel deserves a note too. There are no GitHub releases. The downloads are CI artefacts, a .NET 10 build marked as recommended and latest, and a .NET 9 build marked as stable, both hosted through a nightly link service. Both are Windows x64 only and need the matching .NET Desktop Runtime installed. Unzip anywhere and run AnimeStudio.GUI.exe or AnimeStudio.CLI.exe.

The repository was last pushed to on 2026-10-09, so the tool is being worked on, and the fact that you take a CI artefact rather than a tagged release means you are taking whatever the last successful build produced.

## Conclusion

AnimeStudio fits a modder, artist or researcher who needs to look at what is actually inside a Unity game install, including the encrypted titles where the assets are otherwise unreadable, and who wants either a browsable GUI or a scriptable export. It does not fit a non-Windows machine, since both builds are Windows x64 and need a matching.NET Desktop Runtime, and it does not fit anyone planning to redistribute the extracted assets. Verify three things before you start: that the game entry you pick in the selector matches the build your files come from, since the wrong decryption can fail outright or give you garbage, that the build you download matches the.NET Desktop Runtime you have installed, since the.NET 10 and.NET 9 builds need their own runtime, and whether the assets you want are in a native library you have to rebuild by hand, since the FBX export path needs the Autodesk FBX SDK at exactly version 2020.3.7.

## FAQ

### Which games can AnimeStudio extract assets from?

It handles the encrypted bundles used by Genshin Impact, Star Rail and Zenless Zone Zero and their other upcoming titles, works on a long list of other encrypted games, and works on regular Unity games. The game selector has over 50 entries, including separate ones for closed beta versions, and you must pick the entry matching the build your files come from.

### Which AnimeStudio download should I use and what does it need?

There is a .NET 10 build marked as recommended and latest, and a .NET 9 build marked as stable. Both are Windows x64 only and need the matching .NET Desktop Runtime installed. Unzip the download anywhere and run AnimeStudio.GUI.exe for the graphical interface or AnimeStudio.CLI.exe for the command line tool.

### How do I use the AnimeStudio command line tool?

It takes an input path and an output path plus flags, for example AnimeStudio.CLI.exe <input> <output> --game GI --types Texture2D,Sprite --export_type convert. Useful flags are --game, --types, --names and --containers for filtering, --group_assets for the output folder layout, --map_op and --map_type for building asset maps, and --silent to keep the output quiet. Running it with no arguments prints the full list.

### What is the Asset Browser for?

It builds a map of everything in a game install so you can search it without loading the whole thing each time. Maps can be saved as message pack or json, relocated to a different install folder, and two of them can be loaded side by side to see what changed between versions of a game.

### What do I need to build AnimeStudio from source?

Visual Studio 2022 with the C++ desktop workload, plus the .NET 9 and .NET 10 SDKs. build.ps1 builds the GUI and the CLI for both frameworks and packages them into dist, and dotnet build AnimeStudio.GUI is enough for day to day work. The native libraries are prebuilt and only need rebuilding if you change their sources, and the FBX export library additionally needs the Autodesk FBX SDK at exactly version 2020.3.7.

## Sources

- [Escartem/AnimeStudio on GitHub](https://github.com/Escartem/AnimeStudio)
- [Issues](https://github.com/Escartem/AnimeStudio/issues)
- [License: MIT](https://github.com/Escartem/AnimeStudio/blob/master/LICENSE)
- [README](https://github.com/Escartem/AnimeStudio/blob/master/README.md)

---

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