Skip to content

🔧 Middleware & SDKs

Game development middleware, libraries, and SDK-provided formats used across multiple titles and platforms.

Fast3d/F3dex (N64)

SGI's microcode format for defining 3D graphics on the Nintendo 64. Used in Super Mario 64, Paper Mario 64, Banjo-Kazooie, and many other N64 titles.

  • n64-fast3d-engine - N64 Fast3D engine implementation.
  • noclip.website (Banjo) - F3DEX implementation for Banjo-Kazooie viewer.
  • MeltyTool (F3dzex2) - F3DZEX2 format support.
  • F3DEX2Decoder - Decoder for F3DEX2 display lists.
  • F3D2F3DEX - Converter between F3D variants.
  • Hack64 Fast3D Commands - Documentation for Fast3D display list commands.
  • CloudModding F3DZEX2 - Documentation for F3DZEX2 format.
  • fast64 - Blender plugin for exporting F3D display lists for N64 decompilation projects (Super Mario 64, Ocarina of Time).
  • pigment64 - Rust library for converting N64 image data (Intensity, IA, CI, RGBA formats) between native and PNG formats, used by N64 decompilation projects.
  • F3DEX3 - Modern, heavily rewritten F3D-family microcode for N64 romhacks; rewrites vertex/lighting code from scratch for higher performance, adds new visual features (simultaneous vertex colors + normals, ambient occlusion), and improves accuracy over F3DEX2.
  • RT64 - N64 graphics renderer implementing the RDP/F3D microcode family with enhancements (widescreen, higher resolutions, ray tracing) for emulators and native ports.
  • n64rawgfx - Exports and imports uncompressed ("raw") N64 graphics (RGBA, CI, IA, I formats) to/from BMP files, e.g. for Super Mario 64 texture editing.

Granite SDK

Texture streaming middleware (.gts/.gtp files) used across multiple titles.

Havok

Physics and animation middleware used in hundreds of games across all platforms.

  • Havok IO (Blender) - Havok tool for Blender (replaces legacy HavokMax 3ds Max plugin). Blender add-on that imports .hkx, .hkt, .hka, .igz, and .pak files from Havok XML and binary archives.
  • Capabilities: builds armatures and keyframed actions from animation data, constructs static meshes from geometry blocks, and unwraps PAK/IGZ containers.
  • HavokNoesis - Noesis plugin for Havok format.
  • MapEditor - Realtime map editor mod for Venice Unleashed (Battlefield 3).
  • HavokPreviewToolsBatch2018 - Batch conversion script for Havok Preview Tool 2018 that can automatically convert Havok HKX/HKT files' format.
  • hkxlib - JAXB parser for editing TAGXML formatted Havok files.
  • hkxEdit - Visual editor for Havok 2010.2 files based on hkxlib, written in Java.
  • TagTools - Tools for editing Havok 2015/2016 binary tag files. Includes TagTools converter and CollisionConverter for converting rigid bodies to static compound shapes with type and flag tags.
  • FF16-Model-Importer - Tool to export and import Final Fantasy XVI .mdl file binaries as .gltf or .dae.
  • SSE-Fallout-4-Animation-Converter - Tool to convert animations to PS4 format for Skyrim Special Edition and Fallout 4.
  • hkxcmd (aerisarn fork) - Tool for working with HKX (Havok animation format) used in Elder Scrolls and Fallout series.
  • hkxcmd - Command-line tool for parsing, converting, and modifying Havok HKX animation format files.
  • Blender HKX - Blender addon for importing and exporting Havok HKX animation format.
  • HavokLib - C++ library for reading, converting, and upgrading/downgrading Havok physics packfiles across versions (5.0.0-2017).
  • havok2fbx - Converts Havok files to Autodesk FBX.

JSYSTEM (GameCube/Wii)

Nintendo's in-house middleware used to develop GameCube and Wii era games. Used in Pikmin, Pikmin 2, Luigi's Mansion, Super Mario Sunshine, Super Mario Galaxy, Wind Waker, Twilight Princess, Mario Kart: Double Dash, and many other first-party GameCube/Wii titles.

  • gclib - Python implementations of several GameCube file formats for ROM hacking.
  • Amnoid GC Resources - Documentation and resources for GameCube file formats.
  • JStudio (LordNed) - Classes for Wind Waker J* tools.
  • J3D-Model-Viewer - Viewer for J3D models.
  • Hack.io - Libraries for J3D Era formats.
  • noclip.website (JSYSTEM) - In-browser viewer for JSYSTEM formats.
  • MeltyTool (JSystem) - JSystem format viewer/exporter.
  • SuperBMD - BMD/BDL model converter for GameCube/Wii games.
  • p2setoolkit - Toolkit for disassembling/reassembling Pikmin 2 BMS sequenced music files.
  • Rain336/JSystem - Rust libraries for parsing Nintendo Wii/GameCube file formats.
  • Formats: BCSV, RARC, U8.
  • picori - Picori (ピッコル) is a library for decompilation, modding, and rom-hacking with focus on GameCube and Wii games.
  • Luma's Workshop (BMD) - BMD/BDL format documentation.
  • Wiki.CloudModding (JSYSTEM) - JSYSTEM format documentation.
  • blojob - J2DGraph BLO format tool.
  • pyblo2-gui - GUI for working with BLO files.
  • j3dview - J3DGraph viewer.
  • blemd - Blender addon for J3D models.
  • J3DUltra - Advanced J3D model tool.
  • Jekyll - J3D animation tool.
  • RiiStudio - Modern editor for J3D models.
  • Tockdom BMD/BDL - BMD/BDL format documentation.
  • ibnktool - JAudio instrument bank tool.
  • chutools - Collection of tools for JAudio audio assets in Nintendo games, an updated version of XAYRGA's JAMTools.
  • Formats: JASE, JBST, IBNK (v1/v2), BMS (disassembler).
  • BMS-Analyzer - Nintendo Wii/Gamecube BMS to MIDI converter
  • pyjmap - JMap format library.
  • jpc_conv - JParticle converter.
  • pikmin2-stb - JStudio format tool.
  • Yaz0Decoder - Yaz0 compression decoder.
  • rarc-rs - Rust library for RARC archives.
  • WArchive-Tools - Tools for working with RARC archives.
  • RARClib.py - Python library for RARC format.
  • yaz0-decode-encode - Yaz0 compression tool.
  • BTITool - BTI texture tool.
  • GCFontTool - GameCube font tool.
  • libbti - BTI texture library.
  • RarcPack - RARC archive packer.
  • pyjkernel - Python library for JKernel formats.
  • WiiExplorer - Wii filesystem explorer.
  • ARCTool - Python script to extract RARC, Yaz0, and U8 archives.
  • atirut.bdl - JSYSTEM BMD/BDL model importer for Godot Engine.
  • wsystool - WAVESYSTEM modification toolkit for JSYSTEM games.
  • jampacked - BAA unpacker for JSYSTEM games.
  • aurora - Source-level GameCube & Wii GX graphics compatibility layer, used by decompilation and static-recompilation projects to run original GC/Wii rendering code on modern backends (Dawn/WebGPU).
  • BMDCubed - Converts skinned COLLADA (.dae) files to the Binary Model Data (BMD) format used by first-party Nintendo GameCube and Wii games.
  • j3d-animation-editor - Editor for a variety of J3D animation files.
  • GCFT - GUI multitool for viewing and modifying common GameCube file formats, built on the gclib library above. See also the author's fast Python compression/format libraries: PyFastYaz0Yay0 (Yaz0/Yay0) and PyFastBTI (BTI textures).

SEAD (Nintendo EAD/EPD Engine)

Decompilation of Nintendo EAD/EPD's internal engine and standard library, used across many first-party Wii U and Switch titles including New Super Mario Bros. U.

  • sead - Decompilation of the sead engine/library developed by Nintendo EAD (now EPD), present in New Super Mario Bros. U and other titles. Includes the agl graphics library and an nw_ptcl wrapper for NintendoWareForCafe's Eft particle library.

Mii (RFL/FFL Face Library)

Nintendo's Mii avatar creation/rendering libraries, used across the Wii, Wii U, 3DS, and Switch.

  • RFL - Decompilation of the Revolution Face Library (RFL), Nintendo's Mii avatar library for the Wii.
  • ffl - Decompilation of FFL (Face Library), the successor to RFL used for Mii avatars on Wii U, 3DS, and Switch.
  • FFL-Testing - Mii rendering sample and renderer server built on the FFL decompilation. Fork of aboood40091/FFL-Testing with added rendering server functionality.
  • mii2studio - Command-line tool converting Mii data between Wii, 3DS, Wii U, Miitomo, and Switch formats, outputting files loadable by Nintendo's Mii Studio and PNG renders via Nintendo's rendering API.

Katana Engine (Koei Tecmo)

Koei Tecmo's in-house engine and asset formats (G1M models, G1T texture archives, G1A/G2A skeletal animations), used across Team Ninja, Omega Force, and Gust titles as well as several external collaborations.

  • Project-G1M - Native C++ Noesis plugin for G1M model, G1T texture, and G1A/G2A skeletal animation files. Used across Nioh, Dead or Alive 5/6, the Warriors series (Dynasty/Samurai Warriors, Hyrule Warriors, Fire Emblem Warriors), Atelier, Toukiden, Fire Emblem: Three Houses, and Persona 5 Scramble. Supersedes the same author's Python-based fmt_g1m.

M3G (Mobile 3D Graphics API)

Java Mobile 3D Graphics API (JSR-184) used by many J2ME mobile games in the 2000s.

  • m3gcore - Core engine implementation (in C) of the M3G (JSR-184) API, originally developed at Nokia Research Center and later released as open source through the Symbian Foundation.
  • M3G-Blender-Exporter - Modern M3G (.m3g, JSR-184) exporter for Blender 3.6, implementing a byte-accurate full mobile 3D scene graph.
  • M3G2FBX - Command-line M3G model converter, for Real Racing 3, NFS: Most Wanted, and NFS: No Limits.
  • desktop-m3g - Free C++ implementation of the M3G 1.1 (JSR-184) API for Linux and Android, with Java and Ruby bindings and a separate M3G-Reader-Writer library for reading/writing the .m3g format.
  • Juinness - Converts arbitrary 3D models into M3G models.

Murder Engine

Murder Engine, a 2D game engine/framework used by several indie titles.

  • murder-unpack - Reverse-engineers exported Murder Engine games back into editor-openable projects.
  • Features: C# decompilation of managed single-file bundles, sprite extraction from texture atlases, dialogue (.gum) export, localization CSV export, per-game engine-version fingerprinting, asset repacking.

NETLizard (J2ME Game Engine)

  • netlizard - Parser utility and Qt4 GUI tool for NETLizard 3D J2ME game resource files (models, textures, fonts, text, sprites), reversed from decompiled Java source.
  • NETLizard_idTech4 - Converter from NETLizard 3D J2ME game resource files to idTech4 format.

Nebula Engine

The Nebula Device/Nebula2 engine, used by Project Nomads and other early-2000s titles.

  • nebula2-assets-extractor - Extracts and converts asset packs for the Nebula Device 2 engine.
  • Formats: NPK0 archives, NTX1 textures, NOB0 scripts, NVX1 models, NAX0 animations (read, and read/write for most).
  • Features: NVX-to-OBJ/glTF conversion, NTX-to-image and image-to-NTX conversion, NOB script decompilation, NPK packing/unpacking.

MikuMikuDance

Freeware animation program and its associated model and motion formats (.pmx, .pmd, .vmd).

  • MikuMikuLibrary - Library for working with MikuMikuDance formats.
  • MMD Tools - Blender add-on for importing/exporting MikuMikuDance assets. Supports physics, bone constraints, and motion/pose data.
  • MMD Tools Append - Companion extension for MMD Tools that provides material/scene controls, lighting presets, and Rigify helpers.
  • saba - C++ library and viewer for loading and playing MikuMikuDance PMD/PMX models, VMD motion, and VPD pose data, with OpenGL/DirectX 11/Vulkan example viewers.

Cal3D

Cal3D, an open-source skeletal-based 3D character animation library used by several early-2000s indie games.

  • Cal3d-Noesis - Noesis addon for Cal3D models and animations.

Spine (2D Skeletal Animation Middleware)

  • Spine Magic Builder - Windows toolkit for reconstructing scattered or mislabeled Spine skeleton/atlas/texture assets by scanning a directory tree at the byte level and matching candidates, with a GUI picker for visual validation against SpineViewer.
  • Live2d-SpineViewer - Combined viewer for Live2D and Spine 2D skeletal animation assets.
  • Formats: Live2D .moc/.moc3 (with .moc.bytes support), Spine .skel/.json/.atlas across versions 2.1 through 4.2, plus .lpk/.wpk archive packages.
  • Features: Texture atlas slicing and premultiplied-alpha (PMA) handling.
  • Spine-Asset-Py - Python library for parsing Spine skeletal animation asset files (.skel/.atlas).
  • Spine Skeleton Data Converter - Command-line converter between Spine skeleton .skel (binary) and .json formats, with automatic version detection and cross-version conversion across Spine 3.5 through 4.2.
  • spine2d - Experimental, pure Rust (unofficial) runtime for Spine 4.3, parsing skeleton/atlas data without FFI bindings to the official spine-c/spine-cpp runtimes; renderer-agnostic core with wgpu and Bevy integrations.

RenderWare

Cross-platform 3D engine and middleware developed by Criterion Games. Powering the Grand Theft Auto trilogy (III, Vice City, San San Andreas), Burnout series, and many other titles.

  • librw - Re-implementation of the RenderWare Graphics engine.
  • DragonFF - Blender add-on for RenderWare .dff models, .txd textures, .col collisions, and .ipl map data.
  • Blender-3D-RW-Anm-plugin - Import and export RenderWare animations (.anm) into Blender 3D.
  • rwio - RenderWare import/export plugin for 3ds Max.
  • rwd3d9 - D3D9 extension of RenderWare for GTA III and Vice City.
  • RenderWareFile - Library for working with RenderWare binary files.
  • RenderWareNET - Library to work with RenderWare 3 formats.
  • RWIDE2YTYP - RenderWare .IDE to Five .YTYP and NY .IDE converter.
  • rwfury - Python library for reading and writing RenderWare formats.
  • Games: GTA III, Vice City, San Andreas
  • Formats: DFF (3D models), TXD (textures), IMG (archives), COL (collision), IFP (animation)
  • g3DTZ - GAME.DTZ archive extraction utility for GTA: Liberty City Stories and Vice City Stories, supporting both the PSP and PS2 versions.
  • GTARW-BlenderMapExport - Blender IPL/IDE map exporter for GTA San Andreas and Vice City, companion to the DragonFF add-on.
  • gtaRenderHook - Rendering hook/reimplementation for Grand Theft Auto: San Andreas, reading the original game's RenderWare model, texture, and world data.
  • RenderWare3Docs - Official Electronic Arts release of RenderWare Graphics 3 white papers and user guides, covering the engine's file formats and APIs.

CRI

CRI Middleware formats (CPK archives, ADX audio, etc.) used in many Japanese games across multiple platforms.

  • CriPakTools - Tools for extracting and repacking CRI CPK archives used in many Japanese games.
  • CriPakTools (GUI) - GUI version of CriPakTools with additional features including Shift-JIS support, 2GB+ CPK support for PS3, batch mode, compression support, and improved CPK header handling.
  • Universal-CPK-Mod-Installer - Universal installer for CPK mod files.
  • CriFsV2Lib - Library for working with CRI FileSystem V2 archives.
  • AfsLib - Simple, relatively fast library for reading and writing CRIWare AFS archives.
  • AfsBatch - Batch AFS packer. Packs each subdirectory in a given directory into an AFS file of the same name.
  • cri-archive-lib - Rust library for reading and writing CRI CPK archives.
  • CriCodecs - Python frontend for CRI codec tools.
  • SonicAudioTools - Toolset for modifying CRIWARE file formats.
  • Features: ACB Editor, ACB Finder (link AWB to ACB), ACB Injector, CPK Unpacker.
  • Formats: .acb, .awb, .cpk, .adx, .adx2, .csb.
  • hca - Efficient, high-quality decoder for CRI's HCA (ADX2) audio format used by many CRIWARE-based games.
  • HCADecoder - Original decoder for CRI's HCA (ADX2) audio format, the canonical reference implementation other HCA tools are based on.
  • GoldWave_HcaFile - HCA/ACB playback and export plugin for the GoldWave audio editor.
  • UsmToolkit - Converts CRI USM video files into user-friendly formats, using ffmpeg and vgmstream. See also UsmToolkitHandler, a companion tool that speeds up the conversion process.
  • WannaCRI - Python library and CLI for extracting and creating CRI USM video files (VP9/H.264, encrypted and unencrypted) with embedded HCA audio.
  • ACE - GUI tool (Audio Cue Editor) for editing and previewing CRIWARE ACB/AWB files.
  • CriTools - JavaScript tools for extracting audio from CRIWARE game files (ADX/HCA from CPK archives).

PSB (Persistent Serialized Binary)

Serialized data/archive format used by many Japanese visual novel and mobile game engines (M2/Emote, CatSystem2, and others).

  • psbfile - Decompiler and rebuilder for the galgame PSB file format.
  • FreeMote - Toolset and managed library for EMT/PSB (M2 Packaged Struct Binary) files used by many Japanese visual novels and mobile games.
  • Tools: PsbDecompile/PsBuild (decompile PSB to JSON + resources and recompile), EmtConvert (convert PSB between engine/platform variants), FreeMote Viewer (renders unencrypted PSB).
  • Formats: PSB, PSZ, MDF, PIMG, SCN, MMO, EMTBYTES, MTN, DPAK.
  • emote-psb-rs - Rust library and CLI for parsing, decoding and encoding M2 Emote PSB files.
  • FreeMote-SDK - SDK for "Special Emote" engines that take pure (unencrypted) PSB files as input, working around M2 Emote's per-version key isolation.

XNA

Microsoft XNA Framework model format used in various Xbox 360 and PC games.

  • blender_xna - Blender import plugin for XNA model formats.
  • FNA - Accuracy-focused reimplementation of the XNA4 framework for modern platforms, reading original .xnb content files; widely used to port XNA-based games (Terraria, Bastion, Fez, and others).
  • XNA-Noesis-Importer - Noesis script to import Microsoft XNA, MonoGame, and FNA model files (.xnb).
  • xnb - Python library for reading XNA .xnb content files, currently deserializing Texture2D entries with the BGRA surface format.

Sappy (GBA Audio)

SDK-provided formats for the Game Boy Advance sound engine. Used in Pokémon Gen III and many other GBA titles.

  • gba-mus-ripper - GBA music ripper.
  • SapPy - Python-based GBA sound tool.
  • agbplay - Music player and music ripper for GBA.
  • sappy - GBA sound tool.
  • Sappy (Touched) - Fork with additional features.
  • shinen-gax-python - Python tools for Shin'en Multimedia's GAX Sound Engine used in Game Boy Advance games. Includes conversion, unpacking, waveform dumping, and song rendering tools. Also supports NAX Sound Engine format.
  • gsfopt - GSF (GBA Sound Format) optimizer tool. Optimizes GSF sets by removing unused code/data, converts minigsfs/gsflibs to single GSF files, and includes timing functionality for auto-tagging.
  • saptapper - Automated GSF ripper for Game Boy Advance games using the Sappy driver. Extracts music from GBA ROMs automatically.
  • deadbeef_GSFdecoder - GSF decoder plugin for DeaDBeeF media player. Enables playback of GSF (GBA Sound Format) files in DeaDBeeF, based on viogsf/VBA-M.
  • engine-software-gba-tools - Tools for interacting with music data in GBA games that use the Engine Software (developer) replayer.
  • gba-audio-tools - Tools for extracting and converting Game Boy Advance Sappy-driven audio.
  • gba-audio-extractor - Tool for extracting audio from GBA ROMs.
  • m4a2s - Extracts music and sound data from GBA games using the mp2k/m4a sound driver, outputting assembly source for sequences, voicegroups, and samples while preserving pointer links via auto-generated global names.
  • wav2agb - Converts standard WAV files to GBA-compatible assembly (.s) sample data for the m4a sound engine.
  • See also se2m4a, a companion tool converting sound effects to m4a-compatible assembly source.
  • wav28ad - Converts WAV files to the .8ad ADPCM sample format used by GBA homebrew sound engines, per pineight's 8ad format notes.

RAD Game Tools

Middleware provider (Bink video, Granny 3D, Miles Sound System) used in hundreds of games across all platforms.

  • Knit - Fully managed C# reader for Granny 2 files used in many games.
  • GR2Toolkit - Toolkit for working with Granny 3D (GR2) model format files.
  • Granny Converter Library - C++ library for converting Granny2 (.gr2) models and animations to FBX format.
  • opengr2 - Open source Granny2 (.gr2) input/output library and tools, with accompanying file format documentation.
  • opengr2-rs - Open source Rust parser for Granny2 (.gr2) files.
  • opengr2-bevy - Bevy engine file loader for Granny2 (.gr2) files, built on opengr2-rs.
  • piggy - Portable decompilation of RAD Game Tools' Iggy Game UI middleware library, aiming to provide an open-source drop-in replacement (originally targeting Minecraft: Legacy Console Edition).
  • bonkdec - Permissive Bink video decoder library in C#.

Virtools

  • VirtoolsUnpacker - C# rewrite of Luigi Auriemma's Virtools file unpacker, for extracting Virtools-packed game files.

Nintendo SDKs & Hardware

Formats and tools generic to Nintendo consoles or SDKs.

Switch

  • nxdumptool - Generates XCI, NSP, HFS0, ExeFS, and RomFS dumps from Nintendo Switch gamecards and installed titles.
  • HACGUI - A comprehensive interface for extracting Nintendo Switch contents, deriving keys, and mounting filesystems (NAND, RomFS, Save).
  • nstool - General purpose tool to read and extract Nintendo Switch file formats (NSO, NRO, NCA, etc.).
  • TegraRcmSmash - C++ reimplementation of fusee-launcher for Nintendo Switch RCM payloads.
  • hactool - Tool to view information about, decrypt, and extract Nintendo Switch file formats including NCA, XCI, PFS0, HFS0, RomFS, ExeFS, save data, and more.
  • XCI-Explorer - Tool for viewing contents of Nintendo Switch XCI and NSP files. Features include viewing metadata, exploring partitions, checking NCA hashes, extracting NCA, and modifying certificates.
  • LegacySwitchLibraries - Switch file format libraries for Switch Toolbox and other programs.
  • exefs_patches - ExeFS patching tool for Nintendo Switch.
  • switch-reversing - Reverse engineering resources for Nintendo Switch.
  • nxtik - Library and tool for parsing Nintendo Switch .tik (ticket) files.
  • NxFileViewer - GUI viewer for the contents of Nintendo Switch container files.
  • nsz - Homebrew-compatible NSP/XCI compressor and decompressor for Nintendo Switch game dumps.
  • switch-libpulsar - Switch homebrew library to load, parse, and play sounds from BFSAR (binary sound archive) files and related audio file formats.
  • hac2l - Modern rewrite of hactool for viewing, decrypting, and extracting Nintendo Switch file formats, especially NCA (Nintendo Content Archive).
  • nut - Multi-purpose utility to organize, manage, and install Nintendo Switch NSP, NSZ, XCI and XCZ files, with USB/network install serving for Tinfoil.
  • goldbricks - Homebrew Nintendo Switch client for installing NSP packages via USB, GDrive or a nut server.
  • nxo-parser - Rust parsers for Nintendo Switch executable formats (NSO/NRO).
  • SimpleModManager - Homebrew mod manager for the Nintendo Switch (Atmosphere CFW), organizing LayeredFS mod overlay folders per game title ID.
  • NX-Shell - Multi-purpose file manager homebrew for the Nintendo Switch, browsing and previewing images, audio, and archives on the filesystem.
  • Goldleaf - Multi-purpose homebrew tool for the Nintendo Switch, browsing/installing NSP and NCA titles and inspecting the filesystem.
  • hac-rs - Rust library for reading some of the file formats used by the Nintendo Switch operating system.
  • shader-compiler-rs - Recompiles binary Maxwell shaders (as found in Nintendo Switch executables) to GLSL.
  • nx-archive - Rust library for reading and writing Nintendo Switch package archive formats.
  • Fuse-Nx - FUSE driver (and supporting tools) for mounting various Nintendo Switch file formats as a browsable filesystem.
  • frhop - Lightweight utility to serve Nintendo Switch archives over USB for installation.
  • ghidra-nn-stuff - Collection of Ghidra tools and data for reverse engineering Nintendo Switch sysmodule binaries.
  • NSC_BUILDER - Batch-oriented Nintendo Switch NSP/XCI tool for cleaning titlerights encryption and building multicontent NSP/XCI/NSZ/XCZ files.
  • mkbktr - Generates BKTR update packages for Nintendo Switch titles.

iQue Player

Wii U

  • WiiUTools - Collection of Python utilities for working with Wii U file formats including IPK packages, RPX executables, SARC archives, and texture editing (TexHaxU/TexHaxU2).
  • wfslib - WFS (WiiU File System) library and tools.
  • Cafe-Shader-Studio - Shader editor and viewer for Wii U games.
  • GTX-Extractor - Wii U GX2 texture extraction tool. Converts GTX texture files to DDS format for use in modding and asset extraction.
  • noclip.website (Wii U Transfer Tool) - In-browser viewer for the Wii U Transfer Tool's scenes, reading the app's NW4R/BRRES assets.
  • WiiUZip - Archive manager for Wii U filetypes.
  • wiiu-things - Scripts and notes documenting the Wii U FST (filesystem table) format layout.
  • nuspacker - Packs files into an installable Wii U content format (NUS package).
  • nusserver - Custom Nintendo Update Server (NUS) implementation, companion to nuspacker/nustool.
  • wfs-tools - Command-line tools for the Wii U WFS filesystem, built on wfslib. See also wfs-tools-web, a web-based version powered by WebAssembly.
  • fuse-wiiu - FUSE filesystem for extracting data from Wii U titles in various formats.
  • wiiuqt - Qt-based Wii U NAND tools, built alongside koolkdev's wfs-tools.
  • wudump - Dumps raw images from a Wii U game disc. See also disc2app, a fork that extracts decrypted .app/.h3/.tmd/.cert/.tik content instead of a raw dump.
  • saviine - Dumps and injects Wii U save data, for use with the Homebrew Launcher.
  • JNUSLib - Java library for handling Wii U NUS content (.app, tmd, tik, cert files) from local files, the NUS server, or .woomy/.wud/.wux/.wumad images, with decryption, extraction, and .wud-to-.wux compression.

3DS

Container & ROM Formats (CXI/CFA/CCI/CIA/NCCH/RomFS)
  • Project_CTR - A collection of custom Nintendo 3DS tools.
  • ctrtool - Read/extract 3DS file formats (CXI, CFA, CCI, CIA).
  • makerom - Create 3DS file formats.
  • RomFS-Builder - Program to convert a folder in Windows into a 3DS RomFS binary. For use with makerom.
  • 3dstool - All-in-one tool for extracting and creating 3DS file formats.
  • Formats: CIA, CCI, NCCH, NCSD.
  • NDecrypt - Encryption/decryption utility for Nintendo cartridge images, supporting Nintendo DS, DSi, 3DS, and New 3DS cartridge formats.
  • 3dsconv - Python script converting Nintendo 3DS CCI (.cci/.3ds) cart images to the CIA format, with support for decrypted, NCCH-encrypted, and zerokey-encrypted images.
  • pyctr - Python library for reading Nintendo 3DS file formats (NCCH, ExeFS, RomFS, CIA, and more), used by several other 3DS tools.
  • 3DS-rom-tools - Tools and guides for working with Nintendo 3DS game/application formats (.3ds, .cci, .app, .cxi, .cfa, .cia).
  • rofs_dumper - Dumps very early Nintendo 3DS ROFS containers.
  • 3dsconv-c - C port of ihaveamac's 3dsconv, converting Nintendo 3DS CCI cart images to CIA format.
  • braindump - Early homebrew tool for dumping 3DS game cartridges and eShop titles. Archived, but has no already-listed direct successor for this specific niche.
Encryption, Keys, Save Data, Titles & CDN
  • otptool - Tool for Nintendo OTP (One-Time Programmable) files.
  • custom-install - Installs a CIA title directly to an SD card for the Nintendo 3DS without needing to run an installer on-console.
  • rebuild-title-database - Script to rebuild the contents of a Nintendo 3DS title.db Title Database, working alongside save3ds_fuse.
  • save-data-copy-tool - Copies Nintendo 3DS save data between gamecard and digital versions of the same game.
  • cmd-gen - Experimental script to generate CMD files for Nintendo 3DS SD titles.
  • search-3ds - Searches the contents of encrypted/decrypted files used on the Nintendo 3DS system.
  • faketik - Generates and installs fake Nintendo 3DS ticket (.tik) files to make missing titles re-appear.
  • restore-overwritten-secureinfo - Restores a Nintendo 3DS console's SecureInfo_A/B file from inspect.log data.
  • gen-title-info-entry - Experimental script to generate the Title Info Entry structure used in a Nintendo 3DS title.db.
  • dumptik - Dumps all ticket (.tik) files from a Nintendo 3DS console.
  • firmswap - Python implementation of the hardmod downgrade for Nintendo 3DS, working directly with FIRM partition data.
  • save-crypto-finder - Determines which titles a collection of encrypted Nintendo 3DS save files belong to, using boot9 and movable.sed.
  • save3ds - Extract/import/FUSE tool for the Nintendo 3DS common save format (DISA/DIFF), covering save data, extdata, and the title database. Upstream of ihaveamac's save3ds fork.
  • 3ds-save-tool - Tools for parsing and extracting files from Nintendo 3DS save (DISA) and extdata (DIFF) containers.
  • 3ds-snes-sc - Converts save data between the 3DS Virtual Console SNES format and the standard .SRM format used by SNES emulators.
  • HomeMenuEditor3DS - Tool for editing the Nintendo 3DS Home Menu layout database, moving/organizing/renaming titles and folders.
  • eshop-analysis - Python script to analyze and parse Nintendo 3DS eShop title-list data.
  • 3dscrypto-tools - Nintendo 3DS crypto tools: decrypt NCCH, CDN titles/tickets, save images, SpotPass/BOSS containers, and New3DS FIRM ARM9 sections.
  • ctrcdnfetch - Downloads title content from the Nintendo CDN for the 3DS without requiring a console, working around post-11.8 server-side checks.
  • CECTool - Proof-of-concept tool for injecting data into the 3DS's CEC (StreetPass) message format.
Graphics, Models, Textures & Fonts (CTPK/BCH/CGFX/BCLIM)
  • ctpktool - Tool for exporting/importing CTPK texture package files used in Nintendo 3DS games.
  • bchtool - Tool for exporting and importing BCH model files used in Nintendo 3DS games.
  • txobtool - Tool for exporting and importing CGFX graphics files used in Nintendo 3DS games.
  • 3ds-bannertool - Tool for creating Nintendo 3DS banners; fork of carstene1ns/3ds-bannertool adding Windows Unicode fixes and a CMake build system.
  • png2bclim - Converter between PNG and the Nintendo BCLIM texture format.
  • bclimtool - Tool for decoding and encoding the Nintendo BCLIM texture format.
  • splashtool - Generates Nintendo 3DS splash screen files in a custom format, with support for compression and common pixel formats.
  • bclyt-stuff - Research and tools for the Nintendo BCLYT layout format, used across 3DS, Wii U, and Switch UI layouts.
  • 3DS-Font - Extracts and recreates Nintendo 3DS shared BCFNT font files, for use in the Citra emulator or homebrew projects.
  • Ohana3DS-Rebirth - Tool to view, extract, and replace models, textures, and animations from decrypted 3DS ROMs (BCH, CGFX).
  • BcmdlImporter - Tool to import DAE, FBX, and OBJ models into Nintendo 3DS BCMDL (CGFX-based) format without external libraries or toolkits.
  • pycgfx - Program for converting glTF models into the Nintendo 3DS's CGFX format.
  • NSMBHD Wiki (BCRES) - BCRES format documentation for 3DS games.
  • apk-tools - Python tools and a 010 Editor template for unpacking and repacking APK texture archive files found in various Nintendo 3DS game ROMs.
  • 3DS Data Tools - Suite of Python tools for extracting and packing resources found in Nintendo 3DS games.
  • Formats: MSBT (message text extraction/repacking, with color-code handling), SARC (archive extraction/creation with ZLIB compression), BFFNT (font atlas to/from PNG+JSON manifest), BFLIM (texture to/from PNG, with swizzle support).
  • tex3ds - Converts images into the Nintendo 3DS homebrew .t3x texture format (and BCFNT fonts via the bundled mkbcfnt), with atlas, cubemap, skybox, mipmap, and compression options.
Homebrew, CFW & Mod Tools
  • GodMode9 - Full access file browser and manager for Nintendo 3DS handling game file formats and system files.
  • layeredFS - LayeredFS mod for OSX/Linux/UNIX, modified to work from a decompressed code.bin instead of exefs.bin.
  • videoinject - Tool for injecting/creating Nintendo 3DS moflex video files.
  • Lasagna - LayeredFS patch manager for Luma3DS, organizing romfs/exefs mod overlay folder structures.
  • Checkpoint - Fast and simple homebrew save management framework for 3DS and Switch.
  • crotools - Collection of tools for the Nintendo 3DS CRO/CRR shared-library binary format.
  • Magikoopa - Compiles custom C code for Nintendo 3DS games and injects it into existing code.bin files, patching the exheader accordingly.
  • Anemone3DS - Theme and splashscreen manager for the Nintendo 3DS, handling BCSTM audio and theme/splash archive formats.
  • libctru - Reverse-engineered Nintendo 3DS system library (CTRULib) exposing OS/hardware services (filesystem, graphics, audio, networking) to homebrew, forming the base library underlying GodMode9, Checkpoint, and most other 3DS homebrew tools listed above.

GameCube & Wii

Disc Images, Filesystem & Memory Card Formats
  • gc-gcm - Tool for GameCube GCM file format.
  • LibGCM - Library for GameCube memory card formats.
  • gci-bt - GameCube GCI file tool with Bluetooth support.
  • nod - Rust library for reading and writing Nintendo Optical Disc images (GameCube and Wii). Includes nodtool CLI for extraction, conversion, and verification.
  • Formats: ISO (GCM), WIA/RVZ, WBFS, CISO, NFS (Wii U VC), GCZ, TGC.
  • GCReLink - Tool for unpacking and repacking GameCube and Wii relocatable modules (REL files).
  • triforce-nand-iso-extract - Converts Triforce (Namco/Sega/Nintendo GameCube-based arcade board) NAND images to ISO files.
  • triforce-header-patcher - Verifies Triforce arcade disc images and patches in the correct headers.
  • pyisotools - Python library for working with GameCube ISOs (GCM).
Executables, Code Injection & Modding
  • gc-c-kit - Toolkit for compiling C code using devkitppc and injecting it into a GameCube Executable (DOL). Can be adapted to different GC games.
  • dolreader - Reader for GameCube/Wii DOL executable format.
  • ida-wii-loaders - IDA Pro loader plugins for the GameCube/Wii REL (relocatable module) and DOL executable file formats.
  • HopperPPC-Plugin - GameCube/Wii .DOL loader and PowerPC (Gecko) disassembly plugin for the Hopper Disassembler.
  • Kamek - Code injection engine for GameCube and Wii games, compiling and linking custom C++ code against the original DOL/REL executables.
  • GeckoLoader - Extends the available code space for Gecko codes on Wii/GameCube games, allowing thousands of lines of Gecko code per game.
  • mapdas - Tools for working with Metrowerks symbol map (.map) and Gekko/Dolphin executable (.dol) files.
  • Kuribo - Embedded Wii Channel mod loader, installing mods from an SD card. Loads its own .kxe executable format (supporting GCC, Clang, and CodeWarrior) as well as legacy Kamek .kmk executables.
  • geckocode-libs - Python library for parsing and editing Gecko Codes for the Wii/GCN.
  • GekkoAssembler - Assembles Gekko Assembly to Action Replay or Gecko Cheat Code format. Used for GameCube and Wii game modding.
SDK, System Libraries & Decompilations
  • WiiTools - Tools for Wii reverse engineering and function identification to help hacking Wii games.
  • Chihuahua - Tool for GameCube/Wii file formats.
  • cgrr-gamecube - Tools for GameCube file formats.
  • dolsdk2001 - Decompilation of the 5-23-2001 version of the Dolphin (GameCube) SDK libraries.
  • open_rvl - Decompilation of the RVL SDK (Nintendo's Wii operating system libraries), archived but a reference for the Wii's system-level formats.
  • EGG - Decompilation of Nintendo's EGG library, a Wii-era in-house engine used across multiple first-party Wii games.
  • gc-ipl - Open source reimplementation of the GameCube IPL (boot ROM).
  • wii-shop-channel - Decompilation of the Wii Shop Channel, reading an existing WAD dump of the channel.
  • Kaitai-Files - Kaitai Struct definitions documenting proprietary Wii file formats, including WiiConnect24 channel data (e.g. the Forecast Channel), compilable into parsers for any Kaitai-supported language.
Emulation, Audio, Video & Wii Channel Tools
  • libansnd - Audio library for Wii and GameCube homebrew with support for ADPCM audio decoding and arbitrary resampling. Supports up to 48 simultaneous voices with hardware ADPCM decoding.
  • Dolphin - GameCube and Wii emulator that parses and implements support for GameCube/Wii disc and asset file formats.
  • noclip.website (Wii Banners) - Renderer for NW4R LYT UI layouts, used to play back animated Wii channel banners from banner.bin archives. Parses BRLYT layouts, BRLAN animations, and NW4R bitmap fonts.
  • FunKii - Command-line downloader for Wii content from the Nintendo CDN, packaging titles into installable WAD files (including DLC handling).
  • DTMText - Converts Dolphin emulator DTM tool-assisted-speedrun movie files to and from a human-editable text format, to support diffing/version-controlling TAS inputs (GameCube, single controller only).
  • DTMEditor - GUI editor for Dolphin emulator DTM tool-assisted-speedrun movie files.

Nintendo DS / DSi

  • Nitro Files - Documentation for Nintendo DS file formats.
  • narchive - Tool for extracting and creating NARC archives used in DS games.
  • Tinke - Viewer, converter, and editor for Nintendo DS file formats (images, text, sounds, fonts, textures), extensible via .NET plugins. Deprecated by its author; see TinkeDSi below for an actively maintained continuation with DSi support.
  • TinkeDSi - Viewer and extractor for Nintendo DS/DSi file formats.
  • Hatenatools - Python tools for Flipnote Studio (Nintendo DSi) file formats. Supports reading and writing .ppm (Flipnote files), .tmb (thumbnail files), .ugo (user data), and .ntft (image files). Can extract metadata, frames, and audio from Flipnote files.
  • apicula - Converter for Nintendo DS .nsbmd 3D model format.
  • apicula/wiki/FILETYPES - Documentation for Nintendo DS file types.
  • nitro-fs - Nintendo DS filesystem tools.
  • nitro-g3d-tools - Tools for Nintendo DS 3D graphics.
  • nitroefx - Nintendo DS effect tools.
  • NitroEffectMaker - Effect editor for Nintendo DS.
  • narc - NARC archive tool for Nintendo DS.
  • NitroSDK - Official Nintendo DS SDK.
  • NitroSystem - Nintendo DS system library.
  • NTRGhidra - Ghidra plugin for Nintendo DS.
  • NitroSharp - Nintendo DS file format library.
  • nitrog3d - Nintendo DS 3D tools.
  • nitrogfx - Nintendo DS graphics tools.
  • Ekona - Nintendo DS file format library.
  • Nds4j - Java library for Nintendo DS formats.
  • REGames Editor - Full-featured editor for Nintendo DS games.
  • NitroModel ConverterGUI - Converts between Nintendo DS Nitro model formats (NSBMD/NSBTX from ASS/IMD).
  • sdatxtract - Command-line Nintendo DS Sound DATa (SDAT) extraction utility.
  • DSlash - Nintendo DS ROM viewing/extraction tool based on ndstrim (GitHub mirror of the original Google Code project).
  • Flipnote-Encoder - Cross-platform Flipnote Studio (Nintendo DSi) encoder and signer, producing valid .ppm files.
  • nitromods - Project management tool for modding DS games: unpacks ROM filesystems, installs a custom overlay, compiles/assembles mod code (ASM, C, or D), and repacks everything into a new ROM. Supports Pokémon Diamond/Pearl/Platinum, HeartGold/SoulSilver, and Animal Crossing: Wild World.
  • NintendoNitro4DotNet - .NET libraries for working with file formats in Nintendo DS games.
  • dlpdump - Nintendo DS homebrew project for preserving DS Download Play content in a verifiable way, dumping the Wi-Fi packets a DS Download Play host broadcasts.
  • DSDLP_Assembler - Assembles captured Wi-Fi packets, Nintendo Channel DLC files, and melonDS save states into DS Download Play binaries, complementing dlpdump above.
  • NDWCSHAP_Generator - Generates a Nintendo DS Wi-Fi Connection-style (NDWCSHAP) wireless access point that any Nintendo DS, DSi, or 3DS will auto-connect to, for local wireless testing without official infrastructure.

Nintendo 64

  • N64Recomp - Tool to statically recompile N64 games into native executables. Converts N64 binaries into C code that can be compiled for any platform.
  • AudiobankToC - Scripts for converting between N64 Audiobank bank files and C code. Matches on binary -> C -> binary for banks in OoT.
  • seq64 - Full-featured editor for Nintendo 64 music sequencing (Audioseq format). Supports Super Mario 64, Mario Kart 64, and The Legend of Zelda: Ocarina of Time.
  • ipl3checksum - Python and Rust library to calculate the IPL3 (boot code) checksum for N64 ROMs, used to validate/patch ROMs in decompilation and recompilation workflows.
  • N64-IPL - Matching disassemblies of the N64 boot code (IPL1, IPL2, and IPL3).
  • UltraCIC - Reverse-engineered clone of the Nintendo 64 CIC lockout/authentication chip.
  • ido-static-recomp - Static recompilation of the SGI IDO 5.3/7.1 C compilers for modern platforms, letting N64 decompilation projects rebuild with the original toolchain to verify byte-matching output.
  • ultralib - Reverse engineering and matching decompilation of libultra (the N64 SDK), supporting multiple IDO/GCC compiler and library versions.
  • sdk-tools (decomp) - Decompilation of the Nintendo 64 SDK's developer tools, complementing ultralib above.
  • glankk/n64 - Collection of N64 development tools.
  • Tools: gfxdis (F3DEX2 display list disassembler/decompiler), gru (Lua environment for manipulating raw binaries, N64 ROMs, Zelda64 file systems, UPS patches, and GameShark codes), grc (resource compiler for linkable N64 texture objects), ed64rdb/gs (remote debugging and GameShark upload utilities).
  • gzinject - WAD editing utility primarily used for patching N64 Virtual Console emulators and replacing the embedded ROM, with a documented patch file format.
  • ido-rs - Rust programs for handling SGI IDO compiler data formats (st, ucode, binasm), complementing ido-static-recomp above in N64 decompilation toolchains.
  • n64soundtools - Node.js reimplementation of the N64 SDK's SGI sound tools (sbc sequence bank compiler and related utilities) for building N64 homebrew audio data.
  • n64os-info - Reverse-engineered and documented version history of the official Nintendo 64 OS (libultra, microcode, headers, release notes), based on SDK discs and leaks, complementing ultralib above.
  • ultra64 - Detects libultra (N64 SDK) library function signatures embedded in N64 ROM binaries.
  • n64-mr-backup-z64-python - Builds verified Mr. Backup Z64 Zip100 disk images from an N64 ROM collection: 8.3 naming, FAT16 layout, provably minimal disk count, and byte-reproducible output; ships no ROMs, only hashes to identify them.

SNES / NES

  • SuperFamiconv - Command-line tool to convert graphics to Super Nintendo format.
  • M1TE2 - SNES Mode 1 Tile Editor for generating, editing, and arranging SNES tiles and tilemaps (2bpp/4bpp) with palette support. Designed for Mode 1 but works with any mode needing 2bpp or 4bpp graphics.
  • upernes - NES to Super NES recompiler; disassembles NES ROMs and converts 6502 code to SNES 65C816 assembly with hardware emulation.
  • nesrecomp - Static recompiler ecosystem for NES games (part of the R.A.I.D. community), converting 6502 ROM code into portable native code, similar in approach to upernes and GB Recompiled above.
  • jamulator - Early static recompiler converting NES ROMs into native executables via LLVM (unmaintained, historically notable predecessor to upernes/nesrecomp).
  • DiztinGUIsh - Super NES ROM disassembler with tracelog capture/analysis and a focus on collaborative workflow; exports .asm files that reassemble back into the original binary.
  • asar - SNES assembler for applying patches to existing ROM images or building new ones from scratch; the long-standing standard assembler used across SNES ROM hacking projects.
  • nes-header-info - Tool for parsing and displaying iNES/NES 2.0 header information from NES ROM files.
  • go-nes - Go library and CLI utilities for NES ROM and CHR data: unpacking/repacking iNES ROMs into PRG/CHR banks, converting between CHR tiles and PNG/bitmap, metatile and font conversion, and ROM usage-map visualization.
  • SatellaWave - Satellaview (BS-X) server manager/tool exporting broadcast satellite data as BSX-*.bin files playable in bsnes-plus and snes9x, covering channels including Derby Stallion 96.
  • BSFlashManager - Tool for managing BS-X / Satellaview memory pack flash cartridges for the SNES, reading and writing the Satellaview's flash memory format.
  • bsnes-plus - Debug-oriented fork of bsnes with a tracer, memory/VRAM viewers, and breakpoints, widely used for SNES ROM hacking and reverse engineering.
  • snes-tile-tool - SNES tile graphics conversion tool.
  • nintendulatordx - Modified version of the Nintendulator NES emulator adding source-level debugging capabilities for NES ROM reverse engineering.
  • Dispel - Disassembler for 65816/SNES ROM images.
  • snes-assembly-book - 65c816 assembly guide covering opcodes and the inner workings of the SNES, aimed at ROM hacking and reverse engineering.
  • NES-Sprite-Editor - Simple sprite editor for NES games.
  • snes-sdd1-python - Python reimplementation of the SNES S-DD1 compression coprocessor (used by Star Ocean and Street Fighter Alpha 2), checked against the snes9x reference decoder across 4,000 golden test vectors.
  • Same author also publishes patchers that rebuild Street Fighter Alpha 2/Zero 2 and two Star Ocean rebuilds as plain ROMs with the S-DD1 requirement designed out of the header, built from your own cartridge dump.
  • snes-driver-python - Recovers the command protocol a SNES cartridge uses to talk to its coprocessor, read directly out of the cartridge's own driver code; checked against 42 real cartridges.
  • snes-st-python - Emulator for the Seta ST010/ST011 navigation coprocessors used in SNES racing cartridges, settled against their own reference implementation.
  • snes-rtc-python - Emulator for the two real-time-clock coprocessors used in SNES cartridges (S-RTC), held to the chips' own reference implementations.
  • snes-obc1-python - Emulator for the OBC1 sprite-remapper coprocessor carried by one SNES cartridge, validated byte-for-byte against its own reference across every addressing state.
  • snes-dsp-python - Emulator for the SNES DSP-1/2/3/4 coprocessor family (built on the nec-upd7725-96050-python core), running the microcode dump you supply rather than a from-scratch reimplementation of it.
  • sony-s-dsp-python - Sony S-DSP audio-unit model for the SNES sound engine, cross-checked sample-for-sample against register configurations taken from real SPC music dumps.
  • sony-spc700-python - Cycle-accurate SPC700 CPU interpreter for the SNES's audio processor (all 256 opcodes), validated against the SingleStepTests conformance corpus.
  • snes-spc7110-python - Python reimplementation of the SNES SPC7110 decompression coprocessor (all three of its modes), checked against the chip's own reference implementation over 102,400 bytes of generated streams.
  • snes-graphics-python - Encoder/decoder for the Super Nintendo's tile, tilemap, and palette graphics formats, validated bit-exact against the hardware's own behavior.
  • snes-mapper-python - SNES cartridge memory map and DMA engine in Python, resolving every header-declared layout to its address-space mapping; checked against 5,145 real cartridges.
  • snes-rom-image-python - Python library treating a SNES cartridge dump as a file rather than an address space: strips copier stubs, joins split ROM sets, identifies a dump by digest, and rewrites the header to drop a declared coprocessor with the checksum recomputed across every mirror; validated against 7,317 real cartridges.
  • noiSNESs_Brr_Finder - Statistically analyzes SPC dumps and SNES ROM images to rip embedded BRR (Bit Rate Reduction) sound sample data, exporting to WAV or raw BRR; builds on techniques from SNESSOR and BRRTools while filtering out false-positive matches.
  • snesify - Converts images into SNES-native tile graphics formats (2bpp/4bpp/8bpp), including a custom "scan16" 16-colors-per-scanline format that transfers to VRAM in half the time and space of 8bpp while looking better than 4bpp; used to make the large animations in the SNES port of Five Nights at Freddy's possible.

Game Boy / GBA

ROM Tools, Disassemblers & Format Libraries
  • cgrr-gameboy - Tools for Game Boy file formats.
  • HexManiacAdvance - Hex editor for Game Boy Advance ROMs with scripting support.
  • UnkrawerterGBA - Game Boy Advance ROM extractor and converter for games using the Krawall sound engine. Exports audio as XM or S3M module files. Supports automatic detection of instrument/sample lists and modules, direct rip mode for lossless extraction, and can be used as a library.
  • See also krawall, the original XM/S3M player engine source used by these games.
  • GB Recompiled - Static recompiler for Game Boy and Game Boy Color ROMs that translates LR35902 assembly directly to portable C code.
  • Tilemap-Creator - Tileset and tilemap editor for the Game Boy Advance.
  • gba_explorer - Explorer for Game Boy Advance ROMs, browsing and extracting embedded text, graphics, and sound data.
  • gba-lz77 - LZ77 compressor/decompressor producing byte-identical output to the GBA's LZ77 implementation, verified against LEGO Island 2 (GBA).
  • gba_dumper - Set of utilities for text modifications in GBA ROMs. Since GBA games use homebrew text encodings rather than ASCII, streamlines building a translation table from search matches, dumping translated ROM text, and re-injecting edited strings.
  • mgbdis - Game Boy ROM disassembler with RGBDS-compatible output.
  • windfish - Tracing disassembler and UI for Game Boy ROMs, integrated with SameBoy for emulation and debugging.
  • gbadisasm - Game Boy Advance ROM disassembler.
  • luvdis - Pure-Python Game Boy Advance disassembler.
  • GhidraGBA - Game Boy Advance ROM loader for Ghidra.
  • gba-ghidra-loader - Game Boy Advance ROM loader for Ghidra, targeting modern Ghidra versions.
  • gvasm - Assembler and disassembler designed specifically for Game Boy Advance homebrew.
  • gba-tileeditor - Simple tile editor for the Game Boy Advance.
  • gfx2agb - Graphics converter for the Game Boy Advance, converting images to Mode 3/4/5 bitmap and palette data with configurable gamma, dithering, and output stride direction.
  • gameboy-rom-parser - Rust parser for (Super) Game Boy (Color) ROM headers.
  • gba_lib_func_sig - Game Boy Advance library function signature database for reverse engineering, used to identify known compiler/SDK library functions embedded in GBA ROMs.
  • gba-disasm-decomp-tools - Bootstraps a disassembly or decompilation project for a Game Boy Advance game, scaffolding the toolchain and directory structure.
  • ida_gba_stuff - IDA Pro scripts and loaders useful when reverse engineering GBA games.
  • gba_opening_movie - Guide and reference implementation for inserting a custom AVI-converted opening movie into a Fire Emblem GBA ROM.
  • bnGB - Binary Ninja loader and architecture plugin for Game Boy ROMs, enabling GB/GBC disassembly and analysis directly within Binary Ninja.
  • Un-GameBoy - Interactive terminal-based tool for reverse-engineering Game Boy and Game Boy Color ROMs, with disassembly, labeling, and navigation features.
  • GBRE - Research and interoperability toolkit for analyzing user-supplied Game Boy ROMs and building native reimplementations, providing ROM-range data modeling, source-map generation, HTML coverage maps, and emulator-trace/evidence tooling.
  • gba-reversing-notes - Notes on reverse engineering GBA ROMs.
  • GBA-IDA-Pseudo-Terminal - IDAPython tools aiding analysis, disassembly, and data extraction, tailored for the GBA architecture.
  • gba-recomp - Static recompilation tool and runtime for Game Boy Advance ROMs.
  • gba-mapper - LLM-driven automated disassembly and mapping toolkit for GBA ROM images.
  • SLaDe-AGBCC - Neural GBA decompiler experiment targeting AGBCC-compiled code.
  • super-game-boy-border-converter - Converts a 256x224 PNG image into Super Game Boy border SNES tile data.
  • super-game-boy-border-injector - Injects a custom Super Game Boy border into (almost) any Game Boy ROM, complementing the border-converter above.
  • ezgba - Applies SRAM, IPS, and EZ4 patches to Game Boy Advance ROMs.
Hardware & Die-Level Reverse Engineering
  • metroboy - Repository of gate-level simulators and reverse-engineering tools for the original Game Boy hardware.
  • gbrom-tutorial - Tutorial for extracting the Game Boy boot ROM from die photographs.
  • maskromtool - CAD tool for extracting bits from mask ROM die photographs, used to recover boot ROM and other on-die data.
  • ninmonitorroms - Recovered Game Boy debug monitor ROMs, partial ROM images pulled from an official Nintendo Game Boy emulator.
  • dmg-schematics - Reverse engineered schematics of the Game Boy's DMG-CPU B chip, including the SM83 CPU core. Successor to the archived DMG-CPU-Inside project.
  • gb-schematics - Reverse engineered Game Boy-related hardware schematics.
  • nds-slot2 - Nintendo DS slot-2 (GBA slot) reverse engineering documentation.
  • gba-cartridge - Experiments documenting how Game Boy Advance cartridges work.
  • gba-cartridge (repro RE) - Reverse engineering attempt of a Chinese repro Game Boy Advance cartridge.
  • gameboy-audio-dumper - Dumps Game Boy ROMs and save files over an analog audio connection.
  • FlashGBX - Cross-platform (Windows/Linux/macOS) tool to read and write Game Boy and Game Boy Advance cartridge ROM and save data, including RTC registers, via GBxCart RW, GBFlash, Joey Jr, and Game Bub hardware.
  • Features: Wide support for cartridge memory mappers and reproduction/flash cartridges, flash chip identification, decoding and extraction of Game Boy Camera photos from save data, and ROM dump report generation for game preservation.
  • ems-qart - Cross-platform Qt application to read and write ROM and SRAM save data on EMS 64M USB Game Boy flash cartridges. See also ems-flasher, the original command-line flasher for the same hardware.
  • GBA_MultiMenu - Menu program and ROM-compilation builder for Game Boy Advance bootleg cartridges equipped with a multi-game mapper, supporting several common mapper chips and per-game save slot configuration. Compatible with cartridges dumped/flashed via FlashGBX above.
  • gba-auto-batteryless-patcher - Patches a GBA ROM for batteryless saving on bootleg cartridges containing SRAM but no battery, flushing save data a few seconds after an in-game save or on a button-trigger.
  • libsavgba - Library to access various backup media (SRAM, flash, EEPROM) in GBA cartridges. Successor to the archived libgbabackup.
  • ags_aging (decomp) - Decompilation of the AGS Aging Cartridge 7.0, a Nintendo diagnostic/burn-in test cartridge for Game Boy Advance hardware.
  • See also AGSTests, a (semi-)decompilation consolidating the AGS test programs in one central place.
Game Boy Camera & Printer
  • gbcam-rev-engineer - Tools used to reverse engineer the Game Boy Camera's sensor and communication protocol using an Arduino UNO.
  • gbp-decode - Set of functions to decode Game Boy Printer print job data.
  • gbcamextract - Extracts photos from Game Boy Camera / Pocket Camera save files, including the Hello Kitty camera variant.
  • game-boy-camera-manager - Tool for managing Game Boy Camera data, including both save (SRAM) photos and ROM contents.
  • arduino-gameboy-printer-emulator - Arduino-based Game Boy Printer emulator that captures the raw serial protocol between a Game Boy/GBC/GBA and the printer, decoding print jobs into images. See also GameboyPrinterSniffer, a standalone packet sniffer for the same protocol.
  • NeoGB-Printer - Open-source, standalone ESP32-based Game Boy Printer emulator 100% compatible with all 110 officially released compatible games, saving printed images as BMP. Co-developed with the author of arduino-gameboy-printer-emulator above.
  • The TinyGB Printer - Raspberry Pi Pico-based Game Boy Printer emulator storing decoded print jobs directly as PNG images on an SD card, battery powered for portability.
  • Built on mofosyne's arduino-gameboy-printer-emulator protocol parser above; described by its author as a Pico "demake" of NeoGB-Printer above.
  • See also the same author's earlier GameboyPrinterPaperSimulation (simulates physical/e-paper printout look from the decoded data) and PC-to-Game-Boy-Printer-interface (bridges a PC to a real Game Boy Printer, encoding images into Game Boy tile format), both since folded into this project.
  • wifi-gbp-emulator - ESP8266-based Game Boy Printer emulator that exposes received print job data over a WiFi connection instead of local storage.
  • gb-link-printer - Firmware turning a GB-Link-Adapter into a Game Boy Printer emulator, allowing photos to be downloaded straight from the browser.
  • gbpxl - Game Boy Printer XL: transparent interface bridging the Game Boy Camera/Printer protocol to ESC/POS-compatible thermal receipt printers. See also cristofercruz's fork with multi-tone printing support.
  • gameboycameralib - Java library encoding, decoding, injecting, and extracting Game Boy Camera 2BPP images as PNGs or BufferedImages to/from Game Boy Camera save files.
  • GameBEye - Python library for processing Game Boy Camera images.
  • gbpinter_dump2image_py - Python script batch-converting raw Game Boy Camera image dumps into PNG files.
  • gb-printer-web - Web app for organizing, editing, and sharing Game Boy Camera photos.
  • GBCamera-Android-Manager - Android app to manage a Game Boy Camera photo gallery, communicating over USB serial with an Arduino Printer Emulator or GBxCart RW to pull images.
Mobile Adapter GB
  • libmobile - Reimplementation of the Mobile Adapter GB protocol used by Pokémon Crystal, Mario Golf, Mario Tennis, and other Game Boy/GBC games for early-2000s online connectivity, enabling connections to custom replacement game servers. See also ArduinoAdapterGB for a real-hardware emulation of the same physical adapter.

Cross-Platform Formats & Archives

Archive & Container Formats
  • Nintendo-File-Formats - Documentation for Wii U and Switch file formats.
  • sarc - Rust library for reading and writing Nintendo SARC and SZS (yaz0 compressed SARC) archive formats.
  • sarc-extract - Extractor for SARC archive format.
  • GARC-Unpack - Unpacker for Nintendo GARC archive format.
  • lzarc - Rust library and CLI for working with LZARC compressed archives used in Paper Mario Color Splash.
  • Lzarc-Tool - Tool for LZARC compressed archive format.
  • darctool - Tool for extracting and creating DARC archive files used in Nintendo games.
  • ninfs - FUSE filesystem tool to mount Nintendo 3DS and Switch container/filesystem formats (CCI, CDN, CIA, NAND, NCA, RomFS, SD, etc.) for direct file browsing.
  • sarctool - Command-line tool for working with Nintendo SARC archive files.
  • rust_lzss - Rust library implementing Nintendo's LZSS decompression, used across many Nintendo game formats.
  • 3DSkit - Tool to extract and repack many file formats found on Nintendo DS, DSi, 3DS, Wii U, and Switch.
  • Jungle - Accurate parser/encoder for various Nintendo file formats.
  • zbic - Python package implementing the ZBIC compression algorithm used on Nintendo Switch.
  • Nintendo-File-Samples - Test set of Nintendo file format samples covering various edge cases, for validating tools against.
  • oead - Library for recent Nintendo EAD first-party formats (BOTW/TOTK-era SARC, Yaz0, AAMP, BYML, and more), with Rust core and Python bindings. See also cs-oead for a C# wrapper.
  • SarcLibrary - Modern C# reader/writer for Nintendo SEAD/SEPD SARC archives.
  • GARCTool - Nintendo 3DS GARC (un)packing tool with support for repacking compressed files, complementing GARC-Unpack above.
Text, Message & Localization (MSBT/LMS)
  • msbt2sheets - Converter for MSBT files to spreadsheet format.
  • MSBTEditor - MSBT text extractor/replacer for .msbt and .umsbt LE-files.
  • umsbt_cmd_extractor - Command extractor for UMSBT files.
  • PyMsyt - Python library wrapping MSYT for editing Nintendo MSBT text files, used across Breath of the Wild and other Nintendo games.
  • MSBTConverter - Tool to convert Nintendo MSBT text files to YAML and back.
  • CLMS - C# library for Nintendo LMS (Message Studio) text format files (MSBT, MSBP, MSBF).
  • MessageStudio - Modern C# implementation of Nintendo MessageStudio (LMS) text file formats.
Models, Textures, Fonts & Rendering
  • Syroot.NintenTools.Bfres - Library for reading/writing Nintendo BFRES model format (Wii U).
  • BFRES-Viewer - Viewer for Nintendo BFRES model format files.
  • BFRES-Tool - Tool for working with Nintendo BFRES files.
  • BFRES-Extractor - Extractor for Nintendo BFRES format files.
  • TSCBReader - Reader for TSCB format files.
  • 3dsfont - Toolkit for Nintendo BCFNT and BFFNT font files (3DS, Wii U, Switch).
  • NintyFont - Nintendo binary font editor
  • img2nutexb - Converts standard images (PNG, JPG, GIF, DDS, TGA, TIFF, ICO, BMP) to Nutexb, the Namco texture format used in Smash Ultimate and other Switch games.
  • nutexb - Rust library for working with Namco Nutexb textures, found in Smash Ultimate and other Switch games.
  • bntx - Rust library for working with Nintendo BNTX textures.
  • img2bntx - Converts standard images to Nintendo BNTX texture format.
  • BFRES-to-FBX-Converter - Windows tool to convert Nintendo BFRES model files to FBX, built on the FBX SDK.
  • BfresToCast - Console tool to extract models and textures from Nintendo BFRES container files to the Cast format.
  • BFRES-Model-Importer - Script for injecting and replacing models in Nintendo BFRES files (Switch and Wii U), maintaining and extending smb123w64gb's original work.
  • BFRES-Shader-Maker - Tool for building BFSHA/BNSH shader binaries from scratch using a given BFRES and GLSL code.
  • KCollisionLibrary - Library for reading and editing Nintendo KCL collision file binaries used by various games.
  • SSBHLib - Library for reading and writing Nintendo SSBH rendering format files (used by Super Smash Bros. Ultimate and other Switch games).
  • IONET - .NET library for reading and writing several 3D model formats into a common object model.
  • BntxLibrary - Simple C# IO library for the Nintendo BNTX texture format.
  • ssbh_lib - Rust library for reading and writing Nintendo SSBH rendering format files (used by Super Smash Bros. Ultimate and other Switch games).
  • NintenTools.Bfres (smb123w64gb) - .NET library for reading, writing, and modifying the Nintendo BFRES graphics archive format (Wii U); the original work later extended by KillzXGaming's BFRES-Model-Importer above.
Scripting, Parameters & Game Data
  • KMP-Expander - Expander for KMP format files.
  • pymsc - Python library for MSC format files.
  • msc-debugger - Debugger for MSC bytecode files, the scripting format used in Super Smash Bros. for Wii U character logic.
  • msclang - Custom C-to-MSC-bytecode compiler; MSC is the bytecode format used by Super Smash Bros. for Wii U for character logic.
  • mscdec - Decompiler that converts MSC bytecode (Super Smash Bros. for Wii U) back to C.
  • aamp2xml - Converter for Nintendo AAMP parameter archive files (used across Breath of the Wild and other Nintendo EAD games) to/from XML.
  • AampLibrary - Library for editing v1 and v2 Nintendo AAMP parameter archive files.
  • BymlLibrary - Modern C# library for reading/writing Nintendo BYML (Binary YAML) files, versions 2-7, including Tears of the Kingdom's v7 nodes.
  • AinbLibrary - C# library for Nintendo AINB (AI Node Binary) files.
  • asb - Base library for parsing and recompiling Nintendo ASB (Animation State Binary) and AINB files.
  • txtg - Experimental parser for the Nintendo TexToGo (TXTG) file format.
  • RstbLibrary - C# IO library for Nintendo Resource Size Table (RSTB/RESTBL) files.
Audio
  • AalSharp - C# IO library for BARS and other Nintendo AAL audio resource file formats.
  • AudioToolkit - IO library for file formats in Nintendo's nw::snd/nn::atk (NintendoWare) audio namespace.
amiibo (NFC Tag Data)
  • amiitool.net - C# port of amiitool, for decrypting/encrypting Nintendo amiibo NFC tag dumps.
  • AmiiboAPI - RESTful API and database of amiibo NFC tag data.
  • Amiibo - Database of amiibo .bin/.nfc NFC tag dumps.
  • emuiibo - Virtual amiibo (amiibo emulation) system for Nintendo Switch, evolved from ogniK5377's switch-nfp-mitm.
  • GameCubeToolkit - Toolkit for reading and editing GameCube-related files.

Sharp X68000 SDKs & Hardware

  • mdxtools - Collection of tools for handling the MDX music format used on the Sharp X68000.
  • wav2adpcm - Converts WAV PCM audio into the Sharp X68000's native ADPCM sound format.
  • png2xsp - Converts PNG spritesheets into the Sharp X68000's XSP sprite library data format.
  • x68k2amiga - Amiga program to convert Sharp X68000 executable files (and various X68000 data formats) to Amiga executables for subsequent reversing.
  • x68000_converters - Set of Python scripts to convert various Sharp X68000 file formats (including ADPCM audio samples) to more usable states.
  • furnace_z68 - Modification of the Furnace chiptune tracker adding X68000 .z68 music export and an ASM replay routine.

PlayStation SDKs & Hardware

Formats and tools generic to PlayStation consoles/SDKs, not tied to a specific game.

  • LibOrbisPkg - Library, GUI, and CLI for creating, inspecting, and modifying PS4 PKG, SFO, PFS, and related package/filesystem formats.
  • psvpfstools - Set of tools to decrypt the PFS (PlayStation File System) filesystem layer used on PS Vita.
  • psvcd - Documents research into hardware-dumping PS Vita game cartridges (PlayStation Vita Cartridge Dump).
  • vita2hos - PlayStation Vita to Horizon OS (Nintendo Switch OS) translation layer (not an emulator), parsing Vita's executable format to run titles under Switch's OS.
  • Vita3K - Experimental HLE PlayStation Vita emulator for Windows, Linux, macOS, and Android, running original PS Vita game data. See also nckstwrt's fork with extensive per-game compatibility fixes for 30+ commercial titles.
  • pkg2zip - Decrypts PlayStation Vita PKG files and repackages their contents (apps, DLC, patches, themes, PSM, PSX, PSP) into zip archives.
  • PSY-Q SDK Version Finder - GUI tool for PS1 decompilation projects that identifies which Sony PSY-Q SDK version(s) a binary was built with, via color-coded byte-level signature diffing across 10+ SDK releases.
  • psp-media-engine-cracking-the-unknown - Research documentation on the PSP's Media Engine, covering its Virtual Mobile Engine (VME), specialized move instructions, bitstream/context handling, local DMACs, VLD unit, and H.264 decoder.
  • PsxVram-SDL - PlayStation 1 VRAM viewer.
  • uofw - The Unofficial Official FirmWare, a complete reverse engineering project for the latest PSP firmware.
  • pspdecrypt - Simple tool to decrypt PSP binaries.
  • kirk - IDA Pro processor module for the PSP's KIRK crypto engine.
  • psp-ghidra-scripts - Collection of scripts to aid in reverse engineering PSP binaries in Ghidra.
  • psp-arc-sdk - Tools for building and extracting the DES-CBC encrypted .arc format updates found within early PSP SDKs.
  • PSPLibDoc - Documents symbols (NIDs) of PSP modules across firmware versions, with tools to load PSPLibDoc XML, PSP export (.exp), and PPSSPP HLE source files.
  • pkgrip - Fast Linux tool for decrypting PS3/PSP PKG files.
  • nploader - PSP plugin for directly reading and loading DLC content in decrypted EDAT/PGD/SPRX form.
  • DTP-T1000-Pre-IPL-dumper - Dumps the PSP's Pre-IPL loader segment from kbooti/bootdispi boot files.
  • qcma - Cross-platform, open-source alternative to Sony's Content Manager Assistant for transferring content to/from the PS Vita.
  • VitaMTP - Library implementing the PS Vita's USB MTP-based content transfer protocol, used by qcma and similar tools. Archived.
  • mkpsxiso - ISO disc image maker written specifically for PlayStation homebrew development. Tool to build and extract PlayStation 1 CD images from XML. Modern cross-platform replacement for BUILDCD from PsyQ SDK. Supports mixed-mode CD-XA with audio/video streams.
  • LibOrbisPkg - Library, GUI, and CLI tools for creating, inspecting, and modifying PlayStation 4 PKG, SFO, PFS, and related filetypes. Open-source alternative to Sony SDK tools.
  • SGXDataBuilder - Creates and builds Sony SGX/SGXD Audio Banks from standard audio formats. Used in various PSP and PS3 games including Gran Turismo 5/6, LocoRoco Cocoreccho, Ape Escape Move, and more.
  • Formats: sgd/sgh/sgb (output), WAV/AC3 (input).
  • LibreFios - PSARC library in C# for working with PlayStation PSARC archive format.
  • memcardrex - Advanced PlayStation 1 memory card editor for managing save files with support for multiple formats.
  • mymc - Utility for working with PlayStation 2 memory card images (PCSX2 format). Supports importing/exporting save games in MAX Drive (.max) and EMS (.psu) formats, viewing memory card contents, creating new memory card images, and adding/extracting individual files. Includes GUI and command-line interfaces.
  • sfo - Fast C program that reads a file to print or modify its SFO parameters. Can be used for automation or to build param.sfo files from scratch. Also available as .exe file for Windows command line.
  • ps3-ckit - PS3 C code injection framework. Toolkit for running arbitrary C code in games, hooking existing functions, and inserting custom functionality.
  • ps3recomp - Static recompilation runtime libraries for PlayStation 3 titles.
  • AteliELF - Python ELF reverse engineering and patching toolchain for PowerPC64 Big Endian binaries (Cell Broadband Engine), originally built for PS3 game text extraction/reinsertion; also has partial PS Vita and PS2 support.
  • Features: text detection (English/Japanese heuristics, CP932/Shift-JIS), pointer resolution (direct and PPC lis/addic split-pointer patterns), bin-packing string reinsertion with automatic pointer/phdr updates, EBOOT decrypt/re-encrypt integration, DeepL/Google Translate hookup, Tkinter GUI.
  • dynlib - IDA Pro plugin to aid PS4 user mode ELF reverse engineering. Loads PS4-specific DYNLIBDATA segment, resolves obfuscated symbol NIDs to label imports/exports, loads symbol table, and patches relocations.
  • PS4-Package-Assessor-Java - Java tool that evaluates PS3/PS4 .PKG files and displays information about them in a clean manner.
  • create-fself - Takes PC-compatible ELFs and generates fake SELF files that run on the PlayStation 4.
  • pkgrename - Renames PS4 PKG files based on param.sfo information, online search, and predefined patterns.
  • ps4-pkg-manager - Light-weight, cross-platform desktop application to manage large collections of PS4 PKG files.
  • ps4-pkg-compatibility-checker - GUI tool with drag-and-drop that checks PKG checksums to determine whether PS4 game and update PKG files are compatible ("married").
  • psxavenc - PS1 audio/video encoding tool; converts standard audio/video into the PlayStation 1's native STR/SPU/XA formats.
  • ps4-pup_unpack - PS4 PUP (firmware/system update package) unpacking tool.
  • PlayStation 1 VST Instruments - VST instruments replicating the PS1 SPU sound chip for music production: an ADPCM sampler that plays back original PS1 .VAG samples with authentic ADSR/interpolation behavior, plus a matching SPU reverb module. Built from the SPU emulation code in the same author's PsyDoom.
  • PSn00bSDK - Open source SDK for PS1 homebrew development, defining the toolchain and native formats used by the author's TIMedit, img2tim, and smxtool below.
  • TIMedit - Graphical converter and management tool for PlayStation 1 TIM texture files.
  • img2tim - Converts standard images to the PlayStation 1 TIM texture format.
  • smxtool - Editing tool for PlayStation RSD and SMX model data formats. See also Blender-RSD-Plugin, a Blender plugin for exporting models in the PlayStation SDK RSD format.
  • psx_psyq_signatures - Signatures for PlayStation 1 PsyQ SDK LIB/OBJ files in JSON form, for identifying statically-linked SDK code in PS1 binaries. See also psx_psyq_flair, the same signatures in IDA FLAIR format.
  • ps2-tim2-tool - Tool for working with the PS2 TIM2 texture format, used across many PS2 titles.
  • mipsasm (cakehonolulu fork) - MIPS assembler targeting the PS2 Emotion Engine and IOP; fork of imaandrew/mipsasm (originally targeting the N64) retargeted for PS2.
  • psvimgtools - Decrypts PlayStation Vita CMA backup images.
  • psximager - Tools for dumping and mastering PlayStation 1 ("PSX") CD-ROM images.
  • PicoMemcard - Emulates a PlayStation 1 memory card (or controller) using a Raspberry Pi Pico, reading/writing real memory card data over the console's controller port. See also MrPalloncini's fork with GameID support, and alex-free's fork adding compatibility with the Tonyhax/FreePSXBoot soft-mod exploit.
  • MemCardPro-ASM - 8BitMods MemCard Pro firmware library/object source, written in MIPS R3000 assembly, for the PS1 hardware memory-card-emulation device.
  • Memory Card Annihilator - PS2 memory card management tool with native exFAT filesystem support, covering ProtoKernel PS2 consoles (SCPH-10000/15000) and separate builds for Arcade, Developer, and Prototype memory card hardware variants.
  • PS2-ECC-Memory-Card-Converter - Converts PS2 memory card images between ECC and non-ECC binary formats, including images created by Memory Card Annihilator, for use with PCSX2 and vice versa.
  • libcrypt-patcher - All-in-one patcher for PS1 disc images protected by Sony's LibCrypt anti-piracy scheme, removing the protection directly from the CD image.
  • ECCScan - PS1 EDC/ECC scanner and fixer for raw CD dumps (mode 2, 2352 bytes/sector); checks and repairs Error Detection/Correction Code mismatches, complementing the check-only edccchk tool.
  • edcre - Regenerates EDC/ECC data for PS1/PS2 CD images (BIN+CUE) after the image has been edited, so patched discs still pass integrity checks.
  • aprip - Generator for PS1 Anti-Piracy Protection bypass patches, analyzing a disc image's specific protection implementation to produce a working bypass.
  • psx-undither - Disables the dithering effect in PS1 games, either by patching the CD image directly or by generating GameShark codes from a DuckStation RAM dump.
  • psexe2rom - Converts PS1 executables (PS-EXE) into flashable GameShark-compatible ROM files.
  • lib-enigma - C library for patching and identifying PS1/PS2 CD images; spiritual successor to (and supersedes) the author's earlier lib-ppf and lib-ps-cd-id libraries.
  • pops2cue - Reverse-engineered (via Ghidra disassembly) reconstruction of POPS2CUE and CUE2POPS, Sony's original tools for converting PS2/PS3 "POPS" PS-one Classics packages to and from CUE+BIN disc images.
  • Ps2IsoTools - Tools to read, build, and edit PS2 ISO images that use the UDF filesystem.
  • KELFBinder - DVD Player and System Updates manager for the PS2, building and patching the console's signed KELF (kernel-ELF) files.
  • MkPFS - Command-line tool and Python library (PyPI-packaged, with GUI) for building, verifying, inspecting, browsing, and extracting PlayStation FileSystem (PFS) disk images (.ffpfs, .ffpfsc, .pfs, .dat, .exfat, .bin), including PKG/FPKG inner-PFS generation for PS4/PS5.
  • DirectPackageInstaller - Tool to preview and send PKG files directly to a PS4 or PS5 over the network, supporting three different transfer methods.
  • PS5-SELF-Decrypter - PS5 payload that uses kernel arbitrary read/write to decrypt Signed ELF (SELF) binaries from the filesystem and dump the plaintext ELFs to a USB drive.
  • psio-helper - Cross-platform Go tool that prepares PS1 CUE/BIN disc images for use with the PSIO optical drive emulator cartridge.
  • pkg_pfs_tool - PKG/PFS unpacker for PS4, extracting package and filesystem contents.
  • ps5-pup-decrypt - Decrypts PS5 PUP (firmware update package) files by directing an exploited PS5 console to decrypt them itself.
  • ps4-cfw-toolkit - Decrypts and encrypts various PlayStation 4 firmware files.
  • Playstation-4-Save-Mounter - Mounts PS4 save data with read/write access via ps4debug, for decrypting, replacing, sharing, and exporting save files. See also n0llptr's fork, which adds PS5 save mounting support.
  • Save-Transfer-Wizard - Windows GUI tool for transferring, decrypting, and browsing PS5 save data over FTP.
  • ps5-app-dumper - PS5 payload that dumps installed application files from the console's mounted pfsmnt filesystem to a USB drive.
  • make_npdata - Encrypts, decrypts, and bruteforces dev_klic keys for PS3 EDAT/SDAT (NP DRM) files. Originally written by Hykem.
  • ps4-re-utilities - Dependency-free Python utilities for PS4 reverse engineering: extracting Secure Kernel/Secure Module/SELF keys from decrypted firmware binaries, splitting the AMD μBIOS from the appended FreeBSD kernel in a decrypted kernel ELF, and extracting embedded SELF files (mini-syscore.elf, safemode.elf, etc.) from it.
  • PAKerUtility - Command-line tool to (un)pack .PAK files used by the Sony Utility Discs for PS2 and PSX.
  • romman - Image manager for creating, extracting, and inspecting PlayStation 2 ROM and IOPRP images.
  • ps3mca_tool - CLI tool for the PS3 CECHZM1 Memory Card adapter, adding arcade MagicGate support and KELF card unbinding on top of the original PS3MCA-TOOL.
  • HDL-Batch-installer - GUI front-end for HDL Dump, featuring batch installation and management of PS2 games on internal/USB hard drives.
  • ps2vmc-tool - PS1/PS2 VMC (virtual memory card) manager tools.
  • pfsshell - Browses and edits PFS filesystems on APA-formatted PlayStation 2 hard drives.
  • ps2mcfs - FUSE driver that mounts PlayStation 2 memory card images, from emulators or real hardware, as a Linux filesystem.
  • psyz - PlayStation 1 porting SDK, providing PSY-Q-compatible headers and libraries for building native ports of decompiled PS1 games.
  • IDAPy-PS2 - IDA Pro Python scripts for reverse engineering PlayStation 2 Emotion Engine (EE) and IOP executables.
  • PSV-PUP-Extractor - PS Vita homebrew app that extracts PSP2UPDAT PUP firmware update package files.
  • OrbisGL - Open-source graphical UI framework for PS4 homebrew development, using C# and OpenGL for shape/text rendering, audio playback, and input handling.
  • PS4-OpenOrbis-Mono - Sample Mono entry point for PS4 homebrews built on OrbisGL.
  • ps4_remote_pkg_installer - Remote PKG installer for jailbroken PS4 consoles, pushing package files over the network for installation.
  • ps4_payload_ldr - Loads fake SELF (fPKG) applications on a jailbroken PS4 via a server, for running homebrew ELFs signed as fake SELF binaries.
  • ps4_stub_lib_maker_v2 - Generates stub libraries for linking PS4 homebrew against system PRX/SPRX modules. Second version of the author's original ps4_stub_lib_maker. See also StubMaker, an independent alternative for creating custom library stubs for PS4 Official SDK projects.
  • LibProsperoPKG - .NET library for creating, inspecting, and modifying PS5 PKG, GP5, and PFS package/filesystem files. PS5 counterpart to LibOrbisPkg.
  • ps4-wee-tools - GUI app for working with PS4 SPI/NOR flash and Syscon firmware dumps.
  • ps5-wee-tools - Tools for working with PS5 SPI/NOR flash dumps.
  • PlayStation-5-NOR-ErrorLog - Decodes the Error DBI crash log embedded in PS5 NOR flash dumps.
  • ps4-pup-decrypt - Payload to decrypt the contents of a PS4 firmware update file (PUP).
  • Ps4-Syscon-Read-Write-Helper - Script using SYSGLITCH to dump and validate a PS4 Syscon's RL78 firmware, converting the extracted 512KB image to Motorola S28 format and writing it back with rl78flash.
  • PS4_Nor - Script to check and patch the UART debug flag in PS4 NOR flash dumps.
  • PS5 NOR/UART toolkit (apewalkers) - Small utilities for working with PS5 NOR flash dumps and UART error logs, companion to PlayStation-5-NOR-ErrorLog above.
  • Tools: PS5-NOR_Fw_Snoop (extracts EMC/Southbridge firmware details from NOR .BIN dumps), Ps5_Nor_Validator (validates dumps via header checks and entropy analysis), Play-Station-5-Southbridge-Swap-Script (patches NOR dumps to swap EMC/Southbridge firmware for an exploitable auth state), Playstation-5-UART-Reader (UART terminal/decoder for PS5 error logs), PS5-Software-ErrorLookup (GUI lookup for PS5 software error codes).
  • ShadowMountPlus - Automated background auto-mounter payload for jailbroken PS5 consoles that detects, mounts, and installs game backups from internal or external storage, supporting UFS, exFAT, PFS, and nested compressed PFS containers. Actively maintained, substantially expanded fork of RDX-Sci01's ShadowMount1.3GBT.
  • PS4pkg_to_ffpfsc - Converts a PS4 PKG (or an already-unpacked PS4 game) into .ffpfsc (compressed) or .exfat (raw) disk images for ShadowMountPlus above, merging base game and update PKGs without modifying the source files.
  • UFS2Tool - Cross-platform (Windows/macOS/Linux) manager for FreeBSD UFS1/UFS2 filesystem images, the filesystem used by PS4/PS5 game dumps.
  • ps5-bar-tool - PS5 payload that parses PS5 Backup and Restore (BAR) archive.dat files and dumps the embedded filesystem, using the console itself as an oracle.
  • ps5-uart - Toolkit for interfacing with a PS5 mainboard's service processors over UART and decoding NAND dumps from its Titania storage controller.
  • Components: uart/tool.py (Raspberry Pi Pico bridge for live EMC/EFC/EAP access), titania (standalone Python library/CLI decoding a NAND capture through the scrambler, LDPC, FTL, and namespace layers to plaintext, no hardware needed).
  • selfutil - Converts a PS4/PS5 SELF (fake-signed ELF) executable to a plain ELF and back. See also xSpecialFoodx's fork, which cleans repetitive segment padding, adds a version segment, and adds more conversion options.
  • dump2ufs - Converts PS4/PS5 game dump folders or archives (RAR, 7z, etc.) directly into optimized UFS2 filesystem images compatible with ShadowMountPlus above, auto-detecting block size and the game root without an intermediate extraction step.
  • PSFFPKG - GUI wrapper for UFS2Tool above, automating the creation of .ffpkg (UFS2) images from PS5 game dump directories for installation via the ShadowMount payload.
  • ps5-dlc-toolchain - Merges any number of PS5 DLC F-PKGs into the latest PATCH PKG: unpacks with orbis-pub-cmd, converts eboot.bin from SELF to ELF via SelfUtil, patches in entitlement stubs, regenerates a GP4 project, and repacks a new PATCH PKG.
  • ps4-eboot-dlc-patcher - Patches a PS4/PS5 eboot (or other executable) to replace calls into libSceAppContent/libSceNpEntitlementAccess with a custom PRX, so DLC loads from the base F-PKG when the DLC F-PKGs themselves don't work.
  • PS5PKGReader - Reads PS5 PKG files and extracts (some) content. Archived/no longer maintained.
  • garlic-savemgr - PS5 payload that decrypts, encrypts, and browses PS5 save data through an embedded web UI.
  • pkgdec5 - Decrypts and extracts the "meta" files inside a PS5 PKG that are encrypted with entry-3 keys; port of RedEyeX32's original pkgdec for the PS5.

WonderSwan SDKs & Hardware

Formats and tools generic to the WonderSwan platform/SDKs, not tied to a specific game.

  • ws-ieepview - Viewer/editor for the WonderSwan's internal EEPROM data.
  • wonderswan-tools - Various tools for working with WonderSwan cartridge data, by Dekadence.
  • splashbuilder - Builds custom boot splash images for the WonderSwan.
  • WonBe - WonderWitch BASIC development environment for the WonderSwan.
  • WonX - WonderWitch on X, a WonderWitch compatibility layer for Unix/X11.
  • swancc - Tentative WonderSwan C compiler based on BCC.
  • MiracleMage - WonderWitch emulator for Win32, for running WonderSwan homebrew built with the WonderWitch development kit.

Xbox SDKs & Hardware

Formats and tools generic to the Xbox platform/OS, not tied to a specific game.

  • SlimEra - Slim Win32 reference implementations of select DLLs from the Xbox ERA operating system (e.g. D3DCompiler_46.dll, xg_x.dll), intended for research/analysis tooling rather than running full games.
  • XDL Compiler - Compiler for XDL, an IDL-like interface definition language (with versioning support) used to generate headers for reversing Xbox ERA OS components.
  • XboxAudio2 - XAudio2 wrapper providing XMA2 audio format support for Xbox TitleOS applications.
  • dump-xbox-dvd - Dumps original Xbox game discs (XGD) to redump preservation standard using Kreon-firmware optical drives.
  • xbox-dvd-compress - Proof-of-concept tools to inspect redump-format Xbox DVD images: extracts embedded authoring-tool version tags and traces the RNG seed used to generate sector padding, as groundwork for compression.
  • UnXiP - Extracts XIP archive files from the original Xbox dashboard, based on Voltaic's PIXIT research.
  • WinDurango - Xbox One compatibility layer for Windows, allowing Xbox One executables to run natively on PC.
  • iso2god-rs - Actively maintained, cross-platform (Windows/Linux/macOS) Rust CLI that converts Xbox and Xbox 360 ISOs into the Xbox 360 "Games on Demand" (GoD) container format. See also r4dius/Iso2God, a decompiled C# rewrite of the original tool with quality-of-life improvements.
  • Xbox360BadUpdate - Non-persistent, software-only hypervisor exploit for Xbox 360 working on the latest (17559) dashboard/kernel version. See also bibarub's fork.
  • PiPROM - Reads, writes, and erases original Xbox EEPROM chips using a Raspberry Pi.
  • XboxImageGrabber - Research tool that generates images visualizing the memory profile/layout of an Xbox console, originally built to aid development of the Halo 2 Vista/HD patch.

Games for Windows Live (GFWL)

Formats and tools generic to the Games for Windows Live (GFWL) middleware, not tied to a specific game.

  • xlive-research - Research pertaining to Games for Windows Live (GFWL) xlive.dll internals.

Tamagotchi (Bandai) Hardware

Formats and tools generic to the original Tamagotchi handheld toy hardware, not tied to a specific software release.

  • tamalib - Hardware-agnostic emulation library for the first-generation Tamagotchi, reverse-engineering its E0C6S46 CPU and ROM dump format.
  • mcugotchi - First-generation Tamagotchi (P1) emulator for microcontrollers, built on tamalib. See also pebblegotchi, a port for Pebble smartwatches.

Tamagotchi Paradise

  • tama-para-research - Reverse-engineering notes on the Tamagotchi Paradise handheld, documenting its sprite and archive file formats, CJK text/charset handling, and ghost/save data structures.

Digimon Color (Bandai) Hardware

Formats and tools for Bandai's Digimon Color handheld toy line.

  • DigimonColorSpriteTool - Sprite import/export tool for the Digimon Color handheld, decoding and re-encoding its BMP-based sprite data format.

Sega SDKs & Hardware

  • sega2asm - Sega Genesis/Mega Drive disassembler and splitter written in Golang, producing reassemblable, annotated source from ROM images.
  • PscdPack - ROM packer for the SEGA Genesis Classics compilation's packaged ROM format.
  • netboot - Utilities for netbooting and communicating with a NetDimm installed in a Sega Naomi, Triforce, or Chihiro arcade system.

FMOD

Audio middleware used in thousands of games for sound bank management and streaming.

  • python-fsb5 - Python library and command-line tool for extracting audio from FMOD FSB5 (FMOD Sample Bank) files. Decodes samples to WAV/OGG depending on codec.
  • Fmod5Sharp - Managed C# library for decoding FMOD 5 sound banks (FSB5 and .bank files). Extracts individual audio samples and converts them to WAV or OGG.
  • Formats: PCM8, PCM16, PCM32, GCADPCM, IMAADPCM, VORBIS, FADPCM.
  • See also AssetRipper's fork with additional fixes used by the AssetRipper project.
  • Fmod5Sharp (AssetRipper fork) - AssetRipper's maintained fork of SamboyCoding/Fmod5Sharp; a C# decoder for FMOD 5 FSB sound banks used internally by the AssetRipper Unity asset extraction pipeline.
  • FMODSoundBankEditor - GUI editor for FSB4 version FMOD sound bank (.fsb) files. Supports viewing, replacing, and exporting audio samples. Primarily developed for Xbox 360 Forza titles.

SpeedTree

Procedural vegetation middleware used in many AAA games.

  • Spt2Fbx - Converts SpeedTree .spt files (up to v4.1) to .fbx static meshes. Drag-and-drop tool that preserves UV sets for diffuse, leaf card dimensions, pivot data, and leaf dimming.

Wwise

Audio middleware by Audiokinetic used in many AAA titles for sound bank management.

  • bnkextr - C++ command-line tool for extracting WEM audio files from Wwise BNK soundbank containers. Works with any game using Wwise audio middleware.
  • BnkExtractor - C# extraction library for Wwise audio containers. Extracts WEM audio files from BNK soundbanks and PCK file packages. Works with any game using Wwise audio middleware.
  • Unreal Engine Wwise Extractor - Python script to extract and convert Wwise BNK audio files from Unreal Engine pak files.
  • wwiser-utils - Companion utilities for wwiser, covering Wwise SoundBank (.bnk) and .wem audio files.
  • ExportUtilityWwise - Console tool that exports Wwise audio events from Unreal Engine-based games (Valorant, Sea of Thieves, and others) to WAV files, automating sound extraction.
  • wemkit - Toolkit for working with Wwise WEM audio files.

Prism3D

Steam (Valve) Platform Tools

Libraries for interacting with Valve's Steam network/platform protocols, not tied to a specific game.

  • SteamKit - .NET library implementing Valve's Steam network protocol, providing programmatic access to Steam services (CDN/depot downloads, game coordinator messages, etc.).
  • steam - Python package for interacting with the Steam network, including a CDNClient for depot/manifest access. See also ValvePython/csgo for the CS:GO Game Coordinator protocol.
  • steam-shortcut-editor - Node.js library to read and write Steam's binary shortcuts.vdf file (the non-Steam game shortcuts database), parsing it to a JSON object and back to the original binary format.