gameripper

README.md



GAME RIPPER

! Use only to recorver your own assets, never ever, absolutely DO NOT rip someone else's game !
Easy to use, multiplatform game assets viewer and ripper with a GUI. Single native
executable for both Windows and
Linux. Just unzip it anywhere, no installation required.
Unlike with other similar tools, here no missing DLLs, no outdated MSVC redist, no missing Python modules, no JRE version mismatch,
no etc. It just works out-of-the-box, no technical knowledge required at all. Multilingual and fully SHIFTJIS, UNICODE and UTF-8
aware, no more problems with strange Japanese filenames and missing fonts on English localized Windows! This is also a clean and
standalone implementation, meaning it does NOT patch nor inject code into the games like other rippers. It also does not use any
on-line services hence no telemetry, and it does not leave any trace on your computer, no registry keys nor unwanted files created.
Usage

Drag'n'drop a game folder (or file) into the GAME RIPPER window (or click or press Enter to open folder selection).
Yeah, really this simple. Encryption key autodetection, format conversion etc. everything is taken care for you. Browse the
assets in the viewer, save gallery, export / import texts, or just "Decrypt / Unpack all" raw assets with a single click!
Screenshots


The start up screen.

Japanese characters in file names works correctly.

You can convert sprite sheets into animations (and then save as anim GIF).

The map viewer helps you finding secret areas.

For some engines exporting / importing translated texts also supported.
Supported Game Formats


Pixel Game Maker MV (fully supported, including text translations, however some maps might be off a bit)
RPG Game Maker MV / MZ (also encryption key autodetection if "www/data/System.json" is missing)
RPG Game Maker XP / VX / Ace (could be embedded in .exe, encryption key autodetection and "Fux2Pack" variants)
Wolf RPG / Pro (deobfuscate and unpack DxLib v6 and v8 Archives, encryption key autodetection)
Godot PCK (could be embedded in .exe or .elf, also encryption key autodetection)
Ren'Py (unpack RPA files (without python) and also deobfuscate scripts (if python found))
KiriKiri3 / KrKrZ / KAG (just unpacks XP3, no deobfuscation yet, but TLGs are converted to PNGs)
Illusion / IllGames Scenes (unpack SV, HC, KK, KKS, HS, HS2, RG characards)
Unity (EXPERIMENTAL; UnityFS, Assets, Resources; no deobfuscation, only images and audio ripped, textures converted to PNGs)
Unreal (UE4 and UE5 PAK files, also compression (Zlib, Gzip, LZ4, Zstd, save Oodle) and encryption key autodetection)
Game Maker Studio (GMS1, GMS1.4 and GMS2, could be embedded in .exe, QOIs and BZ2QOIs are converted to PNGs)
SRPG Studio (.rts, .dts, .srk, also encryption key autodetection)
ZipCrypto (also key autodetection if it has at least one uncompressed PNG, SVG, XML, DAE, FBX, WEBP, WAV, M4A or OGG asset)

If engine format not recognized (or -s flag used) then GAME RIPPER fallbacks to brute force scanning for unencrypted
assets (including but not limited to embedded resources in exe, WASM, Android APK, Java JAR etc. files).
Supported asset formats: JSON, CSV, PO, TMX, WAV, OGG, MP3, iMUS, BMP, TLG, GIF, PNG, JPEG, WEBP, DDS, DXT/1/3/5, PVRTC, ETC,
EAC, ATC, ASTC, CRN, RAW, QOI, BZ2QOI, PICKLE, RUBY for now, more to come.
What is and going to be supported: popular engine formats that are used by many games (like eg. Ren'Py) or if a
game with a large content creator community uses it (like the Koikatsu CharaStudio or HoneyCome DigitalCraft Scene unpackers).
What's definitely NOT going to be added: obscure formats that only one particular nieche game uses (for those take a look at
arc_unpacker, also Free and Open Source but CLI and Windows-only).
License

Free and Open Source, Public Domain. Comes without any warranty, nor
guarantee of fitness for a particular purpose, so always backup your game files before use, just to be on the safe side.
Troubleshooting FAQ


If a game file isn't recognized, try drag'n'dropping the game's folder instead.


Press Win+R and type (path)\gameripper.exe -v (where (path) is the folder you've unzipped GAME RIPPER).
Load the game, exit GAME RIPPER and a detailed log will show up (also saved in gameripper.log file). Please attach this log file
along with a public download link of the faulting game file to bugreports. Using -vv or -vvv increases verbosity. On Linux, use
your favourite terminal and type ./gameripper -v.


Alternatively right-click on gameripper.exe, choose "Create shortcut". Then right-click on the shortcut, and choose "Properties".
In the Target field you can specify the command line flags (for example "C:\Program Files\GR\gameripper.exe" "-v", your path
might be different) and press "OK". After that just click on this shortcut to start GAME RIPPER with those options.


If you get "Out of memory" error message, then check "Unpack and exit" before you drag'n'drop the folder or run with command line
options gameripper.exe -d (path to game). This will not load and decode all the assets into memory (which could be a lot, several
gigabytes), rather just decrypts and unpacks the game one file at a time. In this mode GAME RIPPER automatically quits when
processing is done. Note that some engines (Unity in particular) still needs to read in large files into memory (resource files).
The decrypted and unpacked assets will be saved under the unpacked directory.


You can turn off audio with the gameripper.exe -n no-audio flag. SDL seems to have issues with audio under wine with some
configurations, never noticed this under Linux nor on native Windows. Anyway not using audio solves wine's problem.


If a game deliberately has fake headers to fool engine detection, then use gameripper.exe -s to force scanning for assets,
or gameripper.exe -e (engine) to force using a specific engine.


Unpacking a Godot game creates .import files: that's normal, this is how .pck archives store assets. Open this file in
Notepad and you'll see a path="res://.godot/imported/(something)" line. Your actual asset file will be then extracted
to unpacked/_godot/imported/(something) along with the converted asset (leading dot means hidden file under Linux, so it is replaced
with an underscore; also note that the actual path may vary depending on the game, eg. res://.imported/(something) also common).


If ripping Unity doesn't work then you'll need the exact Unity revision, like 2023.3.0b9 and you'll have to download the
corresponding dump file from github into the game's
folder. GAME RIPPER will use that dump file in the game folder if found, otherwise fallbacks to some sane built-in defaults. If this
latter fails, then it will notify you about the missing dump file with the exact download URL. This dump file feature guarantees
that unlike other existing rippers, GAME RIPPER will be able to rip from any future Unity versions as well.


If some Unreal .pak file is using a different key than the one autodetected from Binaries\Win64\*-Shipping.exe then place a
keys.txt in the game folder with base64 encoded keys in each line. GAME RIPPER will read in this file and will try to decrypt the
archives with all of the keys until one succeeds. As for compression everything is supported except Oodle.


If the sprites are blurry, press Space to toggle between smooth and pixel correct zooming.


On maps, press Space to toggle zoom mode. You can move the map around with a simple drag'n'drop.


Automatic animation detection might mess up some sprites, you can press Backspace to convert it back to a sprite sheet.


If you have a single sprite sheet with multiple frames on it, click on "Animate", specify the number of columns and rows and click
"Animate" again.


Of you have multiple sprites each with exactly one animation frame, then you'll need to merge. Click on the sprite with the first
frame, then Shift + click on the sprite with the last frame. A new animated sprite will be added with all those frames.


If the animation speed does not seem right, then you can press + / - to speed up or slow down the playback
respectively. This is also saved in the exported anim GIF's frame header (in centiseconds), but keep in mind that most GIF players
do not care about the frame duration, they use a fixed delay and that's it. Although GIMP can save this value too, but it does not
read the duration parameter either when you import an animated GIF (it defaults to 100 millisecs for all frames).


If your operating system's language is not detected correctly, press F1 to cycle through languages, or use the -l
command line flag with a two letter ISO language code (eg. -l fr, -l en, -l ja etc.) or full language code (eg. -l fr_FR,
-l en_US, -l ja_JP etc.)


If encryption key autodetection isn't working then press F2 on program start up, and you can enter the key manually.
Or you can specify it on the command line too like gameripper.exe -k "01 02 03 04". Using uppercase letter you can specify it
as a base64 encoded string, for example gameripper.exe -K "pzq1+cZGipLozoSKnxO/vLeOunJWRFSBPUC+bZiLIsQ=".


Useful external tools to extract the keys (and assets) from games (some are VERY difficult to use, be warned; there's good
reason why I've developed GAME RIPPER):

pgmmv: https://gist.github.com/syrinka/b2c1cd996231da8171bff70e0d10167f https://github.com/blluv/pgmm_decrypt

rpgmv/mz: https://petschko.org/tools/mv_decrypter/index.html

rpgmxp/ace: https://github.com/uuksu/RPGMakerDecrypter

wolfrpg: https://github.com/Sinflower/UberWolf

godot: https://github.com/char-ptr/godot-key-extract https://github.com/bruvzg/gdsdecomp (also creates .pck archives)
unity: https://github.com/Perfare/AssetStudio https://github.com/zhangjiequan/AssetStudio https://github.com/AssetRipper/AssetRipper

unreal: https://github.com/gildor2/UEViewer https://github.com/devinacker/UnrealKey https://github.com/GHFear/AESDumpster

gms: https://github.com/UnderminersTeam/UndertaleModTool

srpg: https://github.com/HNIdesu/SRPGStudioReverseTools https://github.com/Sinflower/SRPG-ToolBox

zipcrypto: https://github.com/kimci86/bkcrack


Command Line Summary


-v, -vv, -vvv: verbose mode (also saves gameripper.log)

-d (path): decrypt only (unpack game but do not decode) and exit

-n: no audio

-l (langcode): use language by default (skip language autodetection)

-e (engine): force using of engine (skip engine autodetection)

-s: force scanning for assets (skip engine autodetection)

-k (hex bytes): specify key in hex

-K (base64): specify key as base64 encoded string

Have fun!