Metadata-Version: 2.4
Name: ArisuFxPy
Version: 1.25.7
Summary: A Unity extraction and patching package (ArisuFxPy edition)
Author-email: ArisuGpt <arisujod@gmail.com>, Rudolf Kolbe <rkolbe96@gmail.com>
License: MIT License
        
        Copyright (c) 2019-2026 K0lb3
        Copyright (c) 2026 ArisuGpt
        
        Permission is hereby granted, free of charge, to any person obtaining a copy
        of this software and associated documentation files (the "Software"), to deal
        in the Software without restriction, including without limitation the rights
        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        copies of the Software, and to permit persons to whom the Software is
        furnished to do so, subject to the following conditions:
        
        The above copyright notice and this permission notice shall be included in all
        copies or substantial portions of the Software.
        
        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
        SOFTWARE.
Project-URL: Homepage, https://github.com/arisugpt/ArisuFxPy
Project-URL: Bug Tracker, https://github.com/arisugpt/ArisuFxPy/issues
Keywords: python,unity,unity-asset,python3,data-mining,unitypack,assetstudio,unity-asset-extractor
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Intended Audience :: Developers
Classifier: Development Status :: 5 - Production/Stable
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Programming Language :: Python :: 3.14
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: Games/Entertainment
Classifier: Topic :: Multimedia :: Graphics
Requires-Python: >=3.8
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: lz4
Requires-Dist: brotli
Requires-Dist: Pillow
Requires-Dist: texture2ddecoder>=1.0.5
Requires-Dist: etcpak
Requires-Dist: astc-encoder-py>=0.1.12
Requires-Dist: fmod_toolkit
Requires-Dist: fsspec
Requires-Dist: attrs
Requires-Dist: tpk_ar
Provides-Extra: ttgen
Requires-Dist: typetreegeneratorapi>=0.0.10; extra == "ttgen"
Provides-Extra: full
Requires-Dist: arisufxpy[ttgen]; extra == "full"
Provides-Extra: tests
Requires-Dist: pytest; extra == "tests"
Requires-Dist: pillow; extra == "tests"
Requires-Dist: psutil; extra == "tests"
Requires-Dist: arisufxpy[full]; extra == "tests"
Provides-Extra: dev
Requires-Dist: ruff; extra == "dev"
Requires-Dist: arisufxpy[tests]; extra == "dev"
Dynamic: license-file

# ArisuFxPy

[![PyPI Version](https://img.shields.io/pypi/v/ArisuFxPy.svg?logo=pypi&logoColor=white)](https://pypi.org/project/ArisuFxPy/)
[![PyPI Downloads](https://img.shields.io/pypi/dm/ArisuFxPy.svg)](https://pypi.org/project/ArisuFxPy/)
[![Telegram Channel](https://img.shields.io/badge/Telegram-hackinjectlab-2CA5E0?logo=telegram&logoColor=white)](https://t.me/hackinjectlab)
[![Python 3.8+](https://img.shields.io/badge/python-3.8+-3776AB.svg?logo=python&logoColor=white)](https://www.python.org)
[![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux%20%7C%20Android%20Termux-blue)]()
[![MIT License](https://img.shields.io/badge/license-MIT-green)](https://github.com/arisugpt/ArisuFxPy/blob/main/LICENSE)
[![CI Tests](https://github.com/arisugpt/ArisuFxPy/actions/workflows/test.yml/badge.svg)](https://github.com/arisugpt/ArisuFxPy/actions/workflows/test.yml)

A Unity asset extractor for Python based on [AssetStudio](https://github.com/Perfare/AssetStudio).

Next to extraction, ArisuFxPy also supports editing Unity assets.
Via the typetree structure all object types can be edited in their native forms.

```python
# modification via dict:
    raw_dict = obj.parse_as_dict()
    # modify raw dict
    obj.patch(raw_dict)
# modification via parsed class
    instance = obj.parse_as_object()
    # modify instance
    obj.patch(instance)
```

## 🚀 Why ArisuFxPy? (Key Enhancements over UnityPy)

- 🛡️ **UABE Avalonia-Grade Compatibility (Zero False Encryption Errors):**  
  Fixed a longstanding upstream UnityPy bug where normal Unity AssetBundles with engine version `< 2020` or modern archives using 16-byte alignment (`0x200`) were falsely treated as encrypted (*"The BundleFile is encrypted, but no key was provided!"*). **ArisuFxPy accurately distinguishes alignment padding from Unity CN DRM**, opening and saving all standard bundles seamlessly without requiring fake keys.
- 📦 **Trailing Padding & Robust Offset Handling (`BlocksInfoAtTheEnd`):**  
  Fixed critical LZ4 decompression errors (`Decompression failed: corrupt input or insufficient space in destination buffer. Error code: 62`) on AssetBundles containing trailing padding or appended container metadata. ArisuFxPy calculates exact block index offsets from the internal UnityFS header size, matching UABE Avalonia.
- 🔧 **Manual Target Byte Padder (Hex Padding):**  
  Built-in utility in `bundle_modder.py` (Option 6) to automatically inject null bytes (`0x00`) to match exact target file sizes required for anti-cheat verification and strict game integrity checks.
- 📱 **Android & Termux 1st-Class Support:**  
  Designed for mobile game modders and data-miners. Includes 1-line installation (`install.sh`), Termux-friendly pure Python fallbacks, and directory-shadowing fixes.
- 🎮 **Interactive Modder Tool (`bundle_modder.py`):**  
  A built-in interactive CLI tool to inspect asset tables, export/import text and JSON dumps, modify raw asset data, re-pack bundles with LZ4/LZMA, and apply custom hex padding on PC and Android.

If you need advice, want to discuss game modding / data-mining, or need support,
feel free to join our official **[Telegram Group (@hackinjectlab)](https://t.me/hackinjectlab)**.

If you're using ArisuFxPy for a commercial project,
a donation to a charitable cause or a sponsorship of this project is expected.

**As ArisuFxPy is still in active development, breaking changes can happen.**
These changes are usually limited to minor versions (x.y) and not to patch versions (x.y.z).
So in case that you don't want to actively maintain your project,
make sure to make a note of the used ArisuFxPy version in your README or add a check in your code.
e.g.

```python
if ArisuFxPy.__version__ != '1.9.6':
    raise ImportError("Invalid ArisuFxPy version detected. Please use version 1.9.6")
```

1. [Installation](#installation)
2. [Example](#example)
3. [Important Classes](#important-classes)
4. [Important Object Types](#important-object-types)
5. [Configurations](#configurations)
6. [Credits](#credits)

## Installation

**Python 3.8 or higher is required.**

### 💻 PC & Termux Quick Install (via PyPI)

```bash
pip install ArisuFxPy
```

Or install bleeding-edge from GitHub:
```bash
pip install git+https://github.com/arisugpt/ArisuFxPy.git
```

Or install from source:
```bash
git clone https://github.com/arisugpt/ArisuFxPy.git
cd ArisuFxPy
python -m pip install .
```

---

### 📱 Android (Termux) Installation Guide

> [!IMPORTANT]
> **Do NOT install Termux from Google Play Store** (the Play Store build is obsolete and packages fail to install).  
> Always download the official, actively maintained Termux APK from **F-Droid** or **GitHub Releases**:
> - 📥 **[Download Termux (F-Droid)](https://f-droid.org/packages/com.termux/)**
> - 📥 **[Download Termux APK (GitHub Releases)](https://github.com/termux/termux-app/releases)**

#### ⚡ 1-Line Auto Installer (Recommended):
Open Termux on your phone and run this single command:
```bash
curl -sSL https://raw.githubusercontent.com/arisugpt/ArisuFxPy/main/install.sh | bash
```
*This automatically installs Python, Clang, Git, builds dependencies, and installs ArisuFxPy.*

#### 🛠️ Manual Termux Installation:
If you prefer running commands manually:
```bash
# 1. Update Termux and install required tools
pkg update -y
pkg install python git clang make -y

# 2. Install ArisuFxPy and CLI table viewer
pip install git+https://github.com/arisugpt/ArisuFxPy.git
pip install tabulate
```

#### 🎮 Interactive Unity Asset Modder & Dumper:
To run the interactive bundle modding tool on Android / PC:
```bash
curl -sSL https://raw.githubusercontent.com/arisugpt/ArisuFxPy/main/bundle_modder.py -o bundle_modder.py
python bundle_modder.py
```

### Notes

#### Windows

Visual C++ Redistributable is required for the brotli dependency.
In case a new(ish) Python version is used, it can happen that the C-dependencies of ArisuFxPy might not be precompiled for this version.
In such cases the user either has to report this as issue or follow the steps of [this issue](https://github.com/arisugpt/ArisuFxPy/issues/223) to compile it oneself.
Another option for the user is downgrading Python to the latest version supported by ArisuFxPy. For this see the Python version badge at the top of the README.

#### Crash without warning/error

The C-implementation of the typetree reader can directly crash Python.
In case this happens, the usage of the C-typetree reader can be disabled. Read [this section](#disable-typetree-c-implementation) for more details.

## Example

The following is a simple example.

```python
import os
import ArisuFxPy

def unpack_all_assets(source_folder: str, destination_folder: str):
    # iterate over all files in source folder
    for root, dirs, files in os.walk(source_folder):
        for file_name in files:
            # generate file_path
            file_path = os.path.join(root, file_name)
            # load that file via ArisuFxPy.load
            env = ArisuFxPy.load(file_path)

            # iterate over internal objects
            for obj in env.objects:
                # process specific object types
                if obj.type.name in ["Texture2D", "Sprite"]:
                    # parse the object data
                    data = obj.parse_as_object()

                    # create destination path
                    dest = os.path.join(destination_folder, data.m_Name)

                    # make sure that the extension is correct
                    # you probably only want to do so with images/textures
                    dest, ext = os.path.splitext(dest)
                    dest = dest + ".png"

                    img = data.image
                    img.save(dest)

            # alternative way which keeps the original path
            for path,obj in env.container.items():
                if obj.type.name in ["Texture2D", "Sprite"]:
                    data = obj.parse_as_object()
                    # create dest based on original path
                    dest = os.path.join(destination_folder, *path.split("/"))
                    # make sure that the dir of that path exists
                    os.makedirs(os.path.dirname(dest), exist_ok = True)
                    # correct extension
                    dest, ext = os.path.splitext(dest)
                    dest = dest + ".png"
                    data.image.save(dest)
```

You probably have to read [Important Classes](#important-classes)
and [Important Object Types](#important-object-types) to understand how it works.

Users with slightly advanced Python skills should look at [ArisuFxPy/tools/extractor.py](ArisuFxPy/tools/extractor.py) for a more advanced example.
It can also be used as a general template or as an importable tool.

## Important Classes

### Environment

[Environment](ArisuFxPy/environment.py) loads and parses the given files.
It can be initialized via:

-   a file path - apk files can be loaded as well
-   a folder path - loads all files in that folder (bad idea for folders with a lot of files)
-   a stream - e.g., `io.BytesIO`, file stream,...
-   a bytes object - will be loaded into a stream

ArisuFxPy can detect if the file is a WebFile, BundleFile, Asset, or APK.

The unpacked assets will be loaded into `.files`, a dict consisting of `asset-name : asset`.

All objects of the loaded assets can be easily accessed via `.objects`,
which itself is a simple recursive iterator.

```python
import io
import ArisuFxPy

# all of the following would work
src = "file_path"
src = b"bytes"
src = io.BytesIO(b"Streamable")

env = ArisuFxPy.load(src)

for obj in env.objects:
    ...

# saving an edited file
    # apply modifications to the objects
    # don't forget to use data.save()
    ...
with open(dst, "wb") as f:
    f.write(env.file.save())
```

### Asset

Assets \([SerializedFile class](ArisuFxPy/files/SerializedFile.py)\) are a container that contains multiple objects.
One of these objects can be an AssetBundle, which contains a file path for some of the objects in the same asset.

All objects can be found in the `.objects` dict - `{ID : object}`.

The objects with a file path can be found in the `.container` dict - `{path : object}`.

### Object

Objects \([ObjectReader class](ArisuFxPy/files/ObjectReader.py)\) contain the _actual_ files, e.g., textures, text files, meshes, settings, ...

To acquire the actual data of an object it has to be parsed first.
This happens via the parse functions mentioned below.
This isn't done automatically to save time as only a small part of the objects are usually of interest.
Serialized objects can be set with raw data using `.set_raw_data(data)` or modified with `.save()` function, if supported.

For object types with ``m_Name`` you can use ``.peek_name()`` to only read the name of the parsed object without parsing it completely, which is way faster.

There are two general parsing functions, ``.parse_as_object()`` and ``.parse_as_dict()``.
``parse_as_dict`` parses the object data into a dict.
``parse_as_object`` parses the object data into a class. If the class is a Unity class, it's stub class from ``ArisuFxPy.classes(.generated)`` will be used, if it's an unknown one, then it will be parsed into an ``UnknownObject``, which simply acts as interface for the otherwise parsed dict.
Some special classes, namely those below, have additional handlers added to their class for easier interaction with them.

The ``.patch(item)`` function can be used on all object (readers) to replace their data with the changed item, which has to be either a dict or of the class the object represents.

#### Example

```py
for obj in env.objects:
    if obj.type.name == "the type you want":
        if obj.peek_name() != "the specific object you want":
            continue
        # parsing
        instance = obj.parse_as_object()
        dic = obj.parse_as_dict()

        # modifying
        instance.m_Name = "new name"
        dic["m_Name"] = "new name"

        # saving
        obj.patch(instance)
        obj.patch(dic)
```

#### Legacy

Following functions are legacy functions that will be removed in the future when major version 2 hits.
The modern versions are equivalent to them and have a more correct type hints.

| Legacy        | Modern          |
|---------------|-----------------|
| read          | parse_as_object |
| read_typetree | parse_as_dict   |
| save_typetree | patch           |


## Important Object Types

Now ArisuFxPy uses [auto generated classes](ArisuFxPy/classes/generated.py) with some useful extension methods and properties defined in [legacy_patch](ArisuFxPy/classes/legacy_patch/). You can search for a specific classes in the module `ArisuFxPy.classes` with your IDE's autocompletion.

### Texture2D

-   `.m_Name`
-   `.image` converts the texture into a `PIL.Image`
-   `.m_Width` - texture width (int)
-   `.m_Height` - texture height (int)

**Export**

```python
from PIL import Image
for obj in env.objects:
    if obj.type.name == "Texture2D":
        # export texture
        tex = obj.parse_as_object()
        path = os.path.join(export_dir, f"{tex.m_Name}.png")
        tex.image.save(path)
        # edit texture
        fp = os.path.join(replace_dir, f"{tex.m_Name}.png")
        pil_img = Image.open(fp)
        tex.image = pil_img
        tex.save()
```

### Sprite

Sprites are part of a texture and can have a separate alpha-image as well.
Unlike most other extractors (including AssetStudio), ArisuFxPy merges those two images by itself.

-   `.m_Name`
-   `.image` - converts the merged texture part into a `PIL.Image`
-   `.m_Width` - sprite width (int)
-   `.m_Height` - sprite height (int)

**Export**

```python
for obj in env.objects:
    if obj.type.name == "Sprite":
        sprite = obj.parse_as_object()
        path = os.path.join(export_dir, f"{sprite.m_Name}.png")
        sprite.image.save(path)
```

### TextAsset

TextAssets are usually normal text files.

-   `.m_Name`
-   `.m_Script` - str

Some games save binary data as TextAssets.
As ``m_Script`` gets handled as str by default,
use ``m_Script.encode("utf-8", "surrogateescape")`` to retrieve the original binary data.

**Export**

```python
for obj in env.objects:
    if obj.type.name == "TextAsset":
        # export asset
        txt = obj.parse_as_object()
        path = os.path.join(export_dir, f"{txt.m_Name}.txt")
        with open(path, "wb") as f:
            f.write(txt.m_Script.encode("utf-8", "surrogateescape"))
        # edit asset
        fp = os.path.join(replace_dir, f"{txt.m_Name}.txt")
        with open(fp, "rb") as f:
            txt.m_Script = f.read().decode("utf-8", "surrogateescape")
        txt.save()
```

### MonoBehaviour

MonoBehaviour assets are usually used to save the class instances with their values.
The structure/typetree for these classes might not be contained in the asset files.
In such cases see the 2nd example (TypeTreeGenerator) below.

-   `.m_Name`
-   `.m_Script`
-   custom data

**Export**

```python
import json

for obj in env.objects:
    if obj.type.name == "MonoBehaviour":
        # export
        # save decoded data
        tree = obj.parse_as_dict()
        fp = os.path.join(extract_dir, f"{tree['m_Name']}.json")
        with open(fp, "wt", encoding = "utf8") as f:
            json.dump(tree, f, ensure_ascii = False, indent = 4)

        # edit
        tree = obj.parse_as_dict()
        # apply modifications to the data within the tree
        obj.patch(tree)
```

**TypeTreeGenerator**

ArisuFxPy can generate the typetrees of MonoBehaviours from the game assemblies using an optional package, ``TypeTreeGeneratorAPI``, which has to be installed via pip.
ArisuFxPy will automatically try to generate the typetree of MonoBehaviours if the typetree is missing in the assets and ``env.typetree_generator`` is set.

```python
import ArisuFxPy
from ArisuFxPy.helpers.TypeTreeGenerator import TypeTreeGenerator

# create generator
GAME_ROOT_DIR: str
# e.g. r"D:\Program Files (x86)\Steam\steamapps\common\Aethermancer Demo"
GAME_UNITY_VERSION: str
# you can get the version via an object
# e.g. objects[0].assets_file.unity_version

generator = TypeTreeGenerator(GAME_UNITY_VERSION)
generator.load_local_game(GAME_ROOT_DIR)
# generator.load_local_game(root_dir: str) - for a Windows game
# generator.load_dll_folder(dll_dir: str) - for mono / non-il2cpp or generated dummies
# generator.load_dll(dll: bytes)
# generator.load_il2cpp(il2cpp: bytes, metadata: bytes)

env = ArisuFxPy.load(fp)
# assign generator to env
env.typetree_generator = generator
for obj in objects:
    if obj.type.name == "MonoBehaviour":
        # automatically tries to use the generator in the background if necessary
        x = obj.parse_as_object()
```


### AudioClip

-   `.samples` - `{sample-name : sample-data}`

The samples are converted into the .wav format.
The sample data is a .wav file in bytes.

```python
clip: AudioClip
for name, data in clip.samples.items():
    with open(name, "wb") as f:
        f.write(data)
```

### Font

**Export**

```python
if obj.type.name == "Font":
    font: Font = obj.parse_as_object()
    if font.m_FontData:
        extension = ".ttf"
        if font.m_FontData[0:4] == b"OTTO":
            extension = ".otf"

    with open(os.path.join(path, font.m_Name+extension), "wb") as f:
        f.write(font.m_FontData)
```

### Mesh

-   `.export()` - mesh exported as .obj (str)

The mesh will be converted to the Wavefront .obj file format.

```python
mesh: Mesh
with open(f"{mesh.m_Name}.obj", "wt", newline = "") as f:
    # newline = "" is important
    f.write(mesh.export())
```

### Renderer, MeshRenderer, SkinnedMeshRenderer

ALPHA-VERSION

-   `.export(export_dir)` - exports the associated mesh, materials, and textures into the given directory

The mesh and materials will be in the Wavefront formats.

```python
mesh_renderer: Renderer
export_dir: str

if mesh_renderer.m_GameObject:
    # get the name of the model
    game_obj_reader = mesh_renderer.m_GameObject.deref()
    game_obj_name = game_obj_reader.peek_name()
    export_dir = os.path.join(export_dir, game_obj_name)
mesh_renderer.export(export_dir)
```

### Texture2DArray

WARNING - not well tested

-   `.m_Name`
-   `.image` converts the texture2darray into a `PIL.Image`
-   `.m_Width` - texture width (int)
-   `.m_Height` - texture height (int)

**Export**

```python
import os
from PIL import Image
for obj in env.objects:
    if obj.type.name == "Texture2DArray":
        # export texture
        tex_arr = obj.parse_as_object()
        for i, image in enumerate(tex_arr.images):
            image.save(os.path.join(path, f"{tex_arr.m_Name}_{i}.png"))
        # editing isn't supported yet!
```

## Configurations

There're several configurations and interfaces that provide the customizability to ArisuFxPy.

### Unity CN Decryption

The Chinese version of Unity has its own builtin option to encrypt AssetBundles/BundleFiles. As it's a feature of Unity itself, and not a game specific protection, it is included in ArisuFxPy as well.
To enable encryption simply use the code as follow, with `key` being the value that the game that loads the bundles passes to `AssetBundle.SetAssetBundleDecryptKey`.

```python
import ArisuFxPy
ArisuFxPy.set_assetbundle_decrypt_key(key)
```

### Unity Fallback Version

In case ArisuFxPy failed to detect the Unity version of the game assets, you can set a fallback version. e.g.

```python
import ArisuFxPy.config
ArisuFxPy.config.FALLBACK_UNITY_VERSION = "2.5.0f5"
```

### Disable Typetree C-Implementation

The [C-implementation](ArisuFxPyBoost/) of typetree reader can boost the parsing of typetree by a lot. If you want to disable it and use pure Python reader, you can put the following 2 lines in your main file.

```python
from ArisuFxPy.helpers import TypeTreeHelper
TypeTreeHelper.read_typetree_boost = False
```

### Custom Block (De)compression

Some game assets have non-standard compression/decompression algorithm applied on the block data. If you wants to customize the compression/decompression function, you can modify the corresponding function mapping. e.g.

```python
from ArisuFxPy.enums.BundleFile import CompressionFlags
flag = CompressionFlags.LZHAM

from ArisuFxPy.helpers import CompressionHelper
CompressionHelper.COMPRESSION_MAP[flag] = custom_compress
CompressionHelper.DECOMPRESSION_MAP[flag] = custom_decompress
```

-   `custom_compress(data: bytes) -> bytes` (where bytes can also be bytearray or memoryview)
-   `custom_decompress(data: bytes, uncompressed_size: int) -> bytes`

### Custom Filesystem

ArisuFxPy uses [fsspec](https://github.com/fsspec/filesystem_spec) under the hood to manage all filesystem interactions.
This allows using various different types of filesystems without having to change ArisuFxPy's code.
It also means that you can use your own custom filesystem to e.g. handle indirection via catalog files, load assets on demand from a server, or decrypt files.

Following methods of the filesystem have to be implemented for using it in ArisuFxPy.

-   `sep` (not a function, just the separator as character)
-   `isfile(self, path: str) -> bool`
-   `isdir(self, path: str) -> bool`
-   `exists(self, path: str, **kwargs) -> bool`
-   `walk(self, path: str, **kwargs) -> Iterable[List[str], List[str], List[str]]`
-   `open(self, path: str, mode: str = "rb", **kwargs) -> file` ("rb" mode required, "wt" required for ModelExporter)
-   `makedirs(self, path: str, exist_ok: bool = False) -> bool`

## Credits

- **Original Author & Upstream:** [K0lb3](https://github.com/K0lb3) - [UnityPy](https://github.com/K0lb3/UnityPy)
- **Forked, Enhanced & Maintained by:** [ArisuGpt](https://github.com/arisugpt) - [ArisuFxPy](https://github.com/arisugpt/ArisuFxPy)

First of all,
thanks a lot to all contributors of UnityPy and ArisuFxPy, and all of its users.

Also, many thanks to:

-   [Perfare](https://github.com/Perfare) for creating and maintaining and every contributor of [AssetStudio](https://github.com/Perfare/AssetStudio)
-   [ds5678](https://github.com/ds5678) for the [TypeTreeDumps](https://github.com/AssetRipper/TypeTreeDumps) and the [custom minimal Tpk format](https://github.com/AssetRipper/Tpk)
-   [Razmoth](https://github.com/Razmoth) for figuring out and sharing Unity CN's AssetBundle decryption ([src](https://github.com/Razmoth/PGRStudio)).
-   [nesrak1](https://github.com/nesrak1) for figuring out the [Switch texture swizzling](https://github.com/nesrak1/UABEA/blob/master/TexturePlugin/Texture2DSwitchDeswizzler.cs)
-   xiop_13690 (discord) for figuring out unsolved issues of the ManagedReferencesRegistry

## ⚖️ Legal Disclaimer & Fair Use Notice

> [!IMPORTANT]
> This repository and tool are created strictly for **educational, academic research, and interoperability purposes**.
> - **No Proprietary Assets:** This project does not distribute or host any copyrighted game files, proprietary assets, or unauthorized code. All trademarks and registered trademarks are properties of their respective owners.
> - **Fair Use & EULA:** Users are solely responsible for ensuring their usage complies with relevant local laws and third-party software terms of service. The authors and contributors assume no liability and are not responsible for any misuse or damages resulting from the use of this software.
