An IPS patch is a small file that contains changes made to another file, usually a video game ROM. Instead of distributing an entire modified game, ROM-hack creators can distribute an IPS patch containing only the differences between the original game and the modified version.
To use an IPS patch, the player applies it to the correct original ROM using a compatible patching tool. The tool combines the original ROM with the patch and produces a new, modified ROM that can be opened in a compatible emulator.
IPS is one of the oldest and most widely recognized patch formats in the ROM-hacking community. It has commonly been used for fan translations, difficulty modifications, graphical changes, custom levels, bug fixes and early Pokémon ROM hacks.
What Does IPS Stand For?
IPS is commonly expanded as International Patching System.
The IPS format was developed as a simple way to record and distribute changes made to binary files. Although it is strongly associated with ROM hacking, an IPS patch can technically modify many kinds of binary files.
IPS became especially popular during the early years of console ROM hacking because it was simple, lightweight and supported by several patching programs.
What Is an IPS File?
An IPS file is normally identified by the following extension:
.ips
For example:
pokemon-hack.ips
The IPS file is not normally a complete game. It contains instructions telling a patching program which parts of the original file must be changed.
An IPS patch may contain changes such as:
- New maps or levels
- Modified Pokémon encounters
- Different trainer teams
- Updated dialogue
- Fan translations
- New graphics
- Changed character sprites
- Difficulty adjustments
- Bug fixes
- Gameplay improvements
- Edited music or sound data
- New items, moves or abilities
The exact contents depend on what the ROM-hack creator changed.
Is an IPS Patch the Same as a ROM?
No. An IPS patch and a ROM are two different types of files.
A ROM is a digital copy of the data stored on a game cartridge or another game medium. It contains the complete game data needed by an emulator.
An IPS patch normally contains only the modifications that must be applied to that ROM.
For example, imagine that a creator modifies Pokémon FireRed by changing the maps, story, Pokémon locations and trainer battles. Instead of distributing the complete modified FireRed ROM, the creator can compare the original ROM with the modified ROM and create an IPS patch containing the changed data.
The user must then provide the correct base ROM and apply the IPS patch to it.
In simple terms:
Original ROM + IPS Patch = Patched ROM
The resulting patched ROM contains the original game data together with the creator’s modifications.
How Does an IPS Patch Work?
An IPS patch records the locations where data must be changed inside the original file.
When an IPS patch is created, a patching program generally compares two files:
- The original, unmodified file
- The modified version of that file
The program identifies the differences and saves those changes inside an IPS file.
When someone applies the patch, the patcher reads the IPS instructions, moves to the specified locations in the original ROM and replaces or adds the required data.
At a technical level, a standard IPS file begins with a five-byte header spelling PATCH. It then contains one or more patch records, followed by a three-byte EOF marker. Each normal record includes a three-byte offset, a two-byte data length and the replacement data. IPS also supports basic run-length encoding for repeated byte values.
Most users do not need to understand this internal structure. The patching program handles the process automatically.
Why Are ROM Hacks Distributed as IPS Patches?
ROM-hack developers often use patches because a patch is usually much smaller than a complete ROM and focuses on the creator’s modifications.
For example, an original game ROM may be several megabytes in size, while an IPS patch containing a limited set of changes may be only a few kilobytes or megabytes.
Distributing a patch can provide several advantages:
Smaller downloads
An IPS file usually contains only changed data, making it smaller and easier to download than a full modified ROM.
Easier updates
A developer can publish a new patch when bugs are fixed or additional content is added.
Separation from the complete game
Players must provide the required original game file themselves. However, distributing a patch is not automatically lawful in every situation. Copyright rules vary by jurisdiction, and a patch can still contain protected material depending on how it was created and what it includes.
Simple patch creation
IPS is relatively easy for patching tools to read and create. This simplicity helped it become popular in early ROM-hacking communities.
What Is a Base ROM?
A base ROM is the original game file to which the IPS patch must be applied.
Every IPS patch is created for a particular version of a game. A patch made for the US version of Pokémon FireRed may not work correctly with a European, Japanese or differently revised version.
Even two files with similar names may contain different internal data.
A patch creator may specify requirements such as:
- Exact game title
- Region
- Language
- Revision number
- File size
- Headered or unheadered ROM
- CRC32 checksum
- MD5 checksum
- SHA-1 checksum
You should always read the documentation included with the patch before applying it.
Why Does the Correct Base ROM Matter?
IPS tells the patcher where to place new data, but the traditional format does not include the strong source-file and output-file verification features found in some newer formats.
If the wrong base ROM is used, the patch may still appear to apply successfully. However, the resulting game may:
- Display a blank screen
- Crash after starting
- Freeze in certain areas
- Show corrupted graphics
- Contain broken text
- Have missing events
- Produce emulator errors
- Fail to boot completely
This is why file checksums are useful.
A checksum such as CRC32, MD5 or SHA-1 acts like a digital fingerprint for a file. If your ROM’s checksum matches the checksum provided by the developer, you are more likely to have the correct base version.
Some modern patching tools display CRC32, MD5 and SHA-1 values before patching. Rom Patcher JS, for example, can display these hashes, remove headers, create patches and automatically extract supported files from archives.
What Is a Headered or Unheadered ROM?
Some older ROM files, especially Super Nintendo ROMs, may contain an additional copier header that is not part of the original game data.
A common copier header is 512 bytes long. Its presence shifts the location of every byte that follows it.
Therefore, an IPS patch created for a headered ROM may not work correctly with an unheadered ROM, and a patch created for an unheadered ROM may fail on a headered file.
For example, a patch that expects to modify data at one location may write the changes 512 bytes too early or too late when the ROM has the wrong header status.
Patch documentation should tell you whether a headered or unheadered ROM is required. Some patchers can remove or temporarily account for headers, but it is still important to follow the developer’s instructions.
How to Apply an IPS Patch
The exact process depends on your device and patching program, but the general steps are similar.
Step 1: Obtain the IPS patch
Download the patch from the developer’s official page or another trusted source.
The patch may be inside a ZIP, RAR or 7Z archive. Extract the archive before patching unless your chosen tool supports automatic archive extraction.
Step 2: Read the included instructions
Look for a README, documentation page or text file. Check which base game, region, revision and checksum are required.
Step 3: Prepare the correct base ROM
Use a legally obtained dump of the original game that matches the developer’s requirements.
Do not rename or modify the ROM before patching unless the instructions tell you to do so.
Step 4: Create a backup
Make a copy of the original ROM before applying the patch. This prevents you from losing the clean base file.
A useful folder structure might look like this:
Original ROM/
Patch Files/
Patched Games/
Save Backups/
Step 5: Open an IPS patcher
Launch a patching program that supports the IPS format.
Common options include:
- Floating IPS
- Rom Patcher JS
- UniPatcher
- Lunar IPS
- MultiPatch
- Other compatible desktop or browser-based patchers
Floating IPS supports applying and creating IPS and BPS patches through graphical and command-line interfaces.
Rom Patcher JS supports IPS and several other formats in modern web browsers, including mobile browsers.
UniPatcher is an Android patching application that supports IPS, IPS32, UPS, BPS, PPF, XDelta3 and several additional formats.
Step 6: Select the IPS patch
Choose the file ending in .ips.
Step 7: Select the base ROM
Choose the clean ROM required by the patch developer.
Step 8: Apply the patch
Select the option to apply or patch the file. The patcher may ask where the finished ROM should be saved.
It is better to create a new output file instead of overwriting the original ROM.
Step 9: Open the patched ROM
Load the newly created ROM in an emulator that supports the original game’s platform.
For example:
- Game Boy Advance ROMs require a GBA emulator
- Game Boy Color ROMs require a GB or GBC emulator
- Super Nintendo ROMs require an SNES emulator
- Nintendo Entertainment System ROMs require an NES emulator
The IPS patch does not determine which emulator is required. The base game’s platform determines the emulator.
Can You Open an IPS File in an Emulator?
No. An IPS file is not normally playable by itself.
An emulator expects a complete game file, not a set of patching instructions. You must first apply the IPS file to the correct base ROM.
Incorrect:
Emulator → game.ips
Correct:
Base ROM + game.ips → Patched ROM → Emulator
A few emulators may support automatic or soft patching, but manually creating a patched copy is often easier for beginners and makes troubleshooting more straightforward.
What Is Soft Patching?
Soft patching is a feature in which an emulator applies a patch temporarily when the game is loaded.
The emulator may require the ROM and patch to have matching filenames.
For example:
Pokemon FireRed.gba
Pokemon FireRed.ips
Both files may also need to be stored in the same folder.
The original ROM remains unchanged because the patch is applied in memory. However, not every emulator supports soft patching, and naming requirements can differ.
Manual patching is usually more reliable when transferring a game between devices or emulators.
Common IPS Patching Errors
The patcher says the file is invalid
The patch may be corrupted, incomplete or incorrectly extracted. Download it again from a trusted source and confirm that the file ends in .ips.
The patched game shows a white screen
This commonly happens when the wrong base ROM, region or revision was used. It may also be caused by an incompatible emulator.
The game crashes or freezes
The patch may have been applied to the wrong ROM, or the hack itself may contain a bug. Compare your base ROM checksum with the one specified by the developer.
The graphics are corrupted
This can be caused by an incorrect base ROM, a header mismatch, a damaged patch or an emulator compatibility problem.
The patcher cannot find the ROM
The ROM may still be inside an archive. Extract ZIP, RAR or 7Z files before selecting the ROM, unless your patcher explicitly supports compressed input.
The output file has no extension
Rename the output using the extension of the original system when appropriate, such as .gba, .gbc, .nes or .sfc. Changing the extension does not convert a file, so only do this when the output is already the correct type.
My existing save does not work
Save compatibility depends on the ROM hack. A major update may change maps, events, Pokémon data or save structures.
Before updating a patched game:
- Back up the save file.
- Read the update instructions.
- Check whether the developer recommends starting a new game.
- Keep the previous patched ROM until the new version is confirmed to work.
Advantages of IPS Patches
IPS remains useful because it is:
- Simple to create and apply
- Supported by many patching tools
- Recognized across ROM-hacking communities
- Suitable for small and older ROMs
- Often smaller than distributing a complete modified file
- Compatible with many desktop, mobile and browser-based patchers
- Easy to implement in patching software
For older NES, SNES, Game Boy and Game Boy Advance modifications, IPS may still work perfectly well.
Limitations of the IPS Format
IPS is an old format and has several important limitations.
Limited address range
A standard IPS record uses a 24-bit offset. As a result, traditional IPS can directly address only the first 16 MiB of a file. This makes it unsuitable for many larger games and modern disc images.
Limited record length
A normal IPS record uses a 16-bit length field, allowing up to roughly 64 KiB of data in an individual record. Larger changes must be divided into multiple records.
No strong built-in ROM verification
Traditional IPS does not normally store source and target checksums in the way newer formats such as BPS do. Therefore, a patcher may not be able to confirm that the user selected the exact intended base ROM.
BPS includes checksum information for the source file, target file and patch, providing stronger validation during patching.
Limited handling of file restructuring
IPS is mainly designed to overwrite data at specified locations. It is less efficient when a modification moves large amounts of data or substantially restructures a file.
Risk of including unchanged data
Depending on how a patch is created, an IPS file can contain more original data than necessary. Patch creators should use reputable tools and inspect the generated file when copyright concerns are important.
No metadata standard
A basic IPS patch does not contain standardized fields for the game title, author, version, required ROM checksum or description. This information usually has to be provided in a separate README file.
IPS vs UPS vs BPS vs Xdelta
Several newer patch formats address some of IPS’s limitations.
| Format | Common Use | Verification | Large-File Support | Main Advantage |
|---|---|---|---|---|
| IPS | Older cartridge ROM hacks | Limited | Limited | Simple and widely supported |
| UPS | ROM patches | Better than IPS | Better | Supports reversible patching |
| BPS | Modern ROM hacks | Strong checksums | Good | Efficient and reliable |
| Xdelta | Large files and disc-based games | Depends on implementation | Very good | Suitable for large binary differences |
IPS
IPS is simple and widely compatible, but it lacks robust input verification and has file-size limitations.
UPS
UPS was designed specifically for binary patching and normally contains checksums that help detect incorrect files.
BPS
BPS is frequently preferred for newer ROM hacks because it can verify the source ROM and patched output. It is also more efficient at representing certain types of changes.
Xdelta
Xdelta is commonly used for larger files, including disc-based games and projects where IPS would not be practical.
The best format is normally the one selected by the hack developer. Users should not convert a patch to another format unless they understand the consequences.
Can an IPS Patch Contain a Virus?
An IPS file is a data file rather than a normal executable program. However, files should still be downloaded from trusted sources.
The greater security risk may come from:
- Fake patching programs
- Modified installer files
- Password-protected archives from unknown sources
- Misleading download buttons
- Executable files pretending to be patches
- Bundled adware or unwanted software
A genuine IPS patch normally ends in .ips. It should not require you to run an unknown .exe, .bat, .cmd, .scr or other executable file merely to access the patch.
Use reputable patching tools, keep security software enabled and scan unfamiliar downloads before opening them.
Is Using an IPS Patch Legal?
The legal position depends on the patch’s contents, how the base game was obtained and the copyright laws that apply in the user’s country.
A patch that contains only independently created modifications may be different from distributing a complete copyrighted game. However, a patch can still include copyrighted graphics, dialogue, music, code or other protected material.
Using a personally dumped copy of a game does not automatically make every modification or distribution method lawful in every jurisdiction.
ROM-hack developers and users should avoid distributing complete commercial ROMs and should obtain legal advice when a project involves significant copyrighted material.
Frequently Asked Questions
Do I need the original game to use an IPS patch?
You need the correct base ROM or binary file specified by the patch creator. The IPS file usually cannot be played by itself.
Can IPS patches be applied on Android?
Yes. Android-compatible tools such as UniPatcher support IPS files. Some browser-based patchers also work on modern Android browsers.
Can IPS patches be applied on an iPhone or iPad?
They can be applied using a compatible browser-based patcher or supported iOS patching application. Browser access and file handling may vary depending on the iOS or iPadOS version.
Can I apply an IPS patch on a Mac?
Yes. You can use a compatible macOS application, a command-line tool or a browser-based ROM patcher.
Can I apply multiple IPS patches to one ROM?
It is technically possible, but the patches may conflict if they modify the same locations. Always apply patches in the order recommended by their developers and create a backup after every step.
Floating IPS includes support for applying multiple patches in some workflows, but compatibility between those patches is not guaranteed.
Can I reverse an IPS patch?
Standard IPS is not inherently designed as a reversible format. You may be able to create a reverse patch by comparing the modified file against the original, but the safest option is to keep an untouched backup of the base ROM.
Why is my IPS patch so small?
The patch contains only recorded differences, not necessarily the complete game. A simple translation fix, sprite edit or difficulty adjustment may require changing only a small amount of data.
Can IPS patch files be inside ZIP archives?
Yes. Developers often place IPS patches, instructions and documentation inside ZIP, RAR or 7Z archives. Extract the archive before patching unless your patcher supports automatic extraction.
Does renaming a ROM fix an incompatible patch?
No. Renaming changes only the filename, not the data inside the ROM. The file must match the required game version, region, revision and header status.
What should I do if no checksum is provided?
Follow the developer’s exact base-ROM description, including the region, revision and file size. Check the project’s official documentation or support page for additional information.
Final Thoughts
An IPS patch is a compact file containing modifications that can be applied to an original ROM or another binary file. It allows ROM-hack developers to share their changes without necessarily distributing the complete modified game.
The basic process is simple:
Download the patch
Find the correct base ROM
Verify the ROM version
Apply the IPS file
Open the patched ROM in an emulator
The most important part is using the exact base ROM required by the developer. A patch may appear to apply successfully even when the wrong game version is selected, resulting in crashes, corrupted graphics or other problems.
Although newer formats such as BPS, UPS and Xdelta provide better verification or support for larger files, IPS remains an important and widely supported part of ROM-hacking history.
