Textures.ini |link| -

textures.ini configuration file primarily used by the PPSSPP emulator texture replacement

and enhancement. It maps original game texture hashes to new, high-definition image files, allowing users to play classic PSP games with modernized visuals. Core Functionality

The file acts as a database for the emulator, telling it exactly which high-resolution asset to load in place of an original texture. It is structured into two main sections:

: Direct mapping where a specific hexadecimal hash (representing a game texture) is assigned a filename (e.g., 093c5080ade3a490e4bf08a5 = new_texture.png [hashranges]

: Used for more complex texture identification involving ranges of data. Key Features for Modders Dynamic Generation : PPSSPP can automatically create textures.ini Developer Tools

when a game is running, which provides the correct base structure for customization. Asset Categorization

: Developers often group hashes into logical sections (e.g., UI, Maps, FX) to keep the file readable, even though the emulator primarily reads the individual hash-to-file mappings. Version Control : Modern packs, like the Patapon-Remastered-PPSSPP textures.ini

project, use these files to coordinate massive visual overhauls. Common Implementation Challenges Syntax Sensitivity : Simply placing a hash in the file may do nothing if the header tags (

) are missing or if the filename does not match the actual asset in the textures folder. Platform Issues : While generally universal, some users report issues on

where texture replacement fails due to incorrect file paths or permissions. Performance Impact : Loading thousands of high-res textures via textures.ini

can increase RAM usage. For optimal performance, textures should ideally be power-of-2 dimensions (e.g., 1024x1024). Recommended Setup Workflow : Load your game in PPSSPP and use the Developer Tools to "Save new textures." : Find the generated file in PSP/TEXTURES/[GameID]/textures.ini : Open with a text editor to map your new HD files to the captured hashes. : In PPSSPP settings, ensure "Replace textures" is checked under the Graphics/Texture Scaling menu. Are you looking to create a new texture pack for a specific game, or are you troubleshooting an existing pack that isn't loading correctly?

[Android] can't replace textures · Issue #9107 · hrydgard/ppsspp 31 Oct 2016 —

1. What is a textures.ini File?

A textures.ini file is a configuration file (Initialization file) utilized by texture replacement systems. It is most commonly found in Nintendo 64 emulation (using tools like GlideN64 or Rice Video) or in PC games that support "HD Packs" (such as Carmageddon: Max Damage or Rollcage). textures

Its primary function is to map a specific Source Texture (identified by a hash or filename inside the game's memory) to a Replacement Texture (an image file like .PNG or .DDS located on the disk).

Without this file, the game engine would not know which custom image corresponds to which in-game object.

B. The file Property

This is the most critical property. It points to the filename of the new texture.

[game#0D4A2B1C#0#0]
file=hd_textures/brick_wall.png

A. The Section Header (The Identifier)

The header identifies the original texture in the game's memory. In emulation, this is almost always a Hash (a unique alphanumeric string).

Example:

[game#0D4A2B1C#0#0]
  • game: The internal name of the ROM/ISO.
  • 0D4A2B1C: The CRC32 or MD5 hash of the original texture.
  • 0#0: Palette and format indices.

Custom Texture Loading

To use a custom HD texture pack:

  1. Find your Game ID (e.g., GZ2E01 for Wind Waker).
  2. Place your .png files in Load/Textures/GZ2E01/.
  3. Create textures.ini in the same folder with this exact syntax:
[ActionReplay]
# Texture Redirection
OriginalHash = CustomHash

This tells Dolphin: "When the game asks for texture 123ABC, serve CustomHash.png instead."

Warning: Dolphin's textures.ini requires the texture hashes to be exact. Use the built-in hash calculator via the "Debug" menu.

1. Structure and common directives

At heart, textures.ini is human-readable and organized into sections, key/value pairs, and sometimes nested blocks. Typical features include:

  • Section headers
    • Used to group settings for an entire texture, a texture atlas, or a category (e.g., [character_walk], [ui/buttons]).
  • File path and naming
    • Keys such as filename, path, or source specify the image file (PNG, TGA, DDS).
  • Format and compression
    • format, compression, or mipmap settings declare desired output (RGBA8, BC1/BC3/ASTC) or whether to generate compressed runtime assets.
  • Filtering and wrapping
    • filter (nearest, linear, anisotropic) and wrap (repeat, clamp) determine sampling behavior at rendering.
  • Mipmaps and LOD
    • mipmaps = true/false or explicit mip levels guide LOD generation for texture scaling.
  • Alpha and transparency
    • alpha = none|mask|blend, premultiplied = true/false; may include keys to designate an alpha channel or colour key.
  • Atlas and regions
    • When multiple sprites share a single image, regions or frames define rectangles (x,y,width,height) mapped to logical textures.
  • Runtime flags and usage hints
    • usage = diffuse|normal|specular|ui; srgb = true/false affects gamma handling.
  • Platform overrides
    • platform-specific blocks or suffixes allow different compression/perf settings per platform (PC, mobile, console).
  • Metadata and custom attributes
    • developer comments, tags, or custom key/value pairs for tooling or runtime queries.

The exact syntax differs by engine: some use INI-style [sections] and key=value, others adopt JSON-like extensions. Many tools accept comments (# or ;) and support relative paths to source assets.

2. Practical roles in asset pipelines

Textures.ini functions as a bridge between artists, technical artists, and engineers, enabling reproducible builds and automated processing:

  • Source of truth for asset import
    • Build tools read textures.ini to decide how to convert source images into engine-ready formats, ensuring consistent compression, mipmapping, and color space conversions.
  • Performance tuning
    • Explicit control over compression and mipmaps reduces memory and bandwidth usage, crucial on constrained platforms (mobile/console).
  • Visual correctness
    • Declaring srgb, normalmap flags, and premultiplied alpha ensures shaders sample textures correctly; mislabeling can cause gamma errors, lighting artifacts, or blending issues.
  • Atlas management
    • Defining sprite regions avoids runtime atlasing mistakes and minimizes draw calls; atlas entries in textures.ini support stable UV mapping.
  • Conditional builds and platform tailoring
    • Platform overrides allow high-quality assets for PC while providing aggressively compressed versions for mobile, increasing performance without manual rework.
  • Automation and continuous integration
    • CI pipelines use textures.ini to recreate builds reproducibly, enabling deterministic packaging and quicker iteration.

Example workflow:

  1. An artist exports source PNGs into an assets folder.
  2. A textures.ini lists each texture with target compression, mipmap, and usage tags.
  3. The build pipeline reads textures.ini, converts assets to platform-specific compressed formats (e.g., ASTC for Android), generates mipmaps, and places them into packaged resource bundles.

Part 1: What is textures.ini?

At its core, textures.ini is a text-based database that tells a game or application how to handle image data stored in memory or on disk. It maps texture names to specific file paths, defines compression methods, sets resolution caps, and dictates how long a texture stays in cache.

Unlike .exe or .dll files, textures.ini can be edited with any simple text editor (like Notepad++ or Visual Studio Code). Because it lacks a digital signature, modifying it is generally safe, but an incorrect syntax will usually cause the application to ignore the file rather than crash—though silent errors are common.