- Top Pick: Epilogue GB Operator
- Runner-up: Samsung T7 Portable SSD 1TB
- Also consider: WD Elements Desktop 14TB
You found a fan translation of a game that never left Japan, or a hack that rebalances a childhood favourite, and the download is a tiny file ending in .ips, .bps or .ups instead of a game. That file is a patch: a list of changes that becomes a playable game only when applied to a dump you made yourself. Patching takes a minute once you know the format and which base file it expects.
As an Amazon Associate, we earn from qualifying purchases.
This guide covers the three formats, the tools that apply them, a workflow that keeps your original dump untouched, RetroArch’s softpatching shortcut, and the failure modes behind black screens — including the headered versus unheadered trap that catches almost everyone once.
This article contains affiliate links, and we may earn a commission when you buy through them at no extra cost to you.
Quick Answer
Download the patch file, then apply it to a clean dump of your own cartridge using Floating IPS (Flips) for IPS and BPS files or a UPS-capable patcher for UPS files. The patcher writes a new, separate game file; your original dump is never modified. If the patched game misbehaves, the base dump is almost always the wrong version, region or header state.
Why Patches Exist at All
A patch file contains only the author’s changes: the new text of a translation, the redrawn sprites, the edited level data. It contains none of the original game’s data. That separation is the legal design of the format, not a technical accident. A hacker can distribute their own work freely, while the game itself still has to come from a cartridge you own and dumped yourself. It is also practical: a patch can be a fraction of the game’s size, because unchanged data is never stored twice.
Everything below assumes the patch in one hand and your own clean dump in the other — no reputable hack page offers the finished game.
The Three Formats: IPS, UPS and BPS
IPS: the original, with no safety net
IPS (International Patching System) dates from the copier era of the early nineties. It is a simple list of records: a position in the file, a length, and the replacement bytes. Its offsets are three bytes wide, which limits it to files under 16 MB. Crucially, an IPS patch stores no information about the file it expects. Apply it to the wrong base and the patcher writes the changes anyway, producing a corrupted game that may not fail until an hour in. With IPS, checking the base file is entirely your job.
UPS: checksums join the format
UPS (Universal Patching System) was created by the developer byuu as IPS’s successor. It stores CRC32 checksums of the expected input file and the correct output file, so a UPS patcher can warn you before applying when your base does not match, and confirm afterwards that the result is exactly what the author intended. UPS patches are also bidirectional — one file can patch a game and unpatch it — and the format handles files far larger than IPS’s ceiling, which is why it became common for GBA translations.
BPS: the modern standard
BPS (Beat Patching System), also by byuu, is what most new hacks use. It uses delta encoding — describing how to build the new file from pieces of the old one — so patches stay small even when a hack moves data around. BPS stores checksums for the source file, the patch itself and the expected output, giving it the strongest verification of the three. If your base is wrong, a BPS patcher refuses rather than corrupting. When a hack offers a choice of formats, pick BPS.
The Tools You Need
Floating IPS, usually shortened to Flips, is the standard desktop tool. Written by Alcaro, it applies and creates both IPS and BPS patches, runs on Windows and Linux, and performs the checksum checks those formats carry. For UPS files, use a UPS-capable or multi-format patcher. Browser-based patchers also exist and process files locally in the page — nothing is uploaded. Whichever tool you choose, it must explicitly list your patch’s format; renaming a patch to a different extension converts nothing.
The Patching Workflow, Step by Step
First, prepare the base file. Dump the game from your own cartridge and keep that dump pristine: store it in a folder you treat as read-only, and always patch a copy. Before patching, confirm the dump is the one the hack expects. The hack’s page or readme normally states the required game version and region, and often publishes the expected checksum (a CRC32 or similar value) of the base file. Run a free checksum utility on your dump and compare. This quick check prevents nearly every failure described below.
Second, apply the patch. Open Flips, choose Apply Patch, select the patch file, then select your copy of the base file. For BPS and UPS, the tool verifies the base against the stored checksum and stops with a clear error if it does not match — treat that error as the system working, not as an obstacle to bypass.
Third, name the output clearly and keep it separate. GameName (Hack Name).sfc beside GameName.sfc keeps original and hack side by side and sets you up for softpatching. Never let a patcher overwrite your only clean dump.
Softpatching: Let the Emulator Do It
RetroArch can apply a patch automatically at load time, a feature called softpatching. Place the patch file in the same folder as the game file and give it exactly the same name, changing only the extension: game.sfc beside game.bps. When RetroArch loads the game through a core that reads the file into memory, it applies the patch to the in-memory copy and plays the hacked version, while the file on disk stays original. Libretro’s documentation lists IPS, UPS, BPS and xDelta as supported formats. Softpatching is ideal for trying several hacks of one game: swapping means renaming files, not generating new ones. Its limits are real, though: it applies one patch at a time, and cores that stream the file from disk instead of loading it into memory cannot softpatch. For a permanent copy, hard-patch with Flips instead.
When Patching Goes Wrong
The classic trap is the header. Old SNES copier devices prepended a 512-byte header to dumps, leaving two forms of the same game: headered and unheadered. Modern verified dumps are unheadered, but older hacks were made against headered bases, and their readme will say so. Patch a headered-expecting hack onto an unheadered dump and every change lands 512 bytes early: garbled graphics to instant crash. If the documentation mentions a header, follow it exactly: adjust the header on your working copy with a header utility, never on your archived dump.
The other failures are variations on the wrong base. A patch built for the North American release corrupts the European one — or, with BPS, simply refuses. A revised re-release counts as a different base, and a trimmed or previously patched dump is not a clean base. In every case the fix is the same: return to your verified clean dump, re-check its checksum, and patch a fresh copy.
Gear for a Clean Patching Setup
Epilogue GB Operator
The workflow above starts with a clean dump, and the GB Operator makes one for Game Boy, Game Boy Color and Game Boy Advance cartridges: it reads the cartridge over USB and also backs up save files, so the patch base and your decades-old save both come off the same cart.
Specs:
– Reads GB, GBC and GBA cartridges via USB
– Dumps game data and save files
– Also plays cartridges via its companion app
Samsung T7 Portable SSD 1TB
A patching library is really three libraries — clean dumps, patches and patched outputs — and a fast portable SSD keeps them organised in one place.
Specs:
– 1TB capacity
– USB 3.2 Gen 2, up to 1,050 MB/s reads
– USB-C with both cable types included
– Aluminium body, drop resistant to 2 metres
WD Elements Desktop 14TB
For the archive layer, a large desktop drive holds a lifetime of cartridge dumps and disc images with room to spare — worth it, because the clean dump is the one file in this hobby you cannot simply replace.
Specs:
– 14TB capacity
– USB 3.0 desktop drive
– Formatted for Windows, reformats for Mac
– External power supply included
8BitDo Pro 2 Bluetooth Controller
Most hacks target 8-bit and 16-bit games, and the Pro 2’s proper D-pad and hall-effect sticks suit both testing a fresh patch at the desk and playing it on a handheld later.
Specs:
– Hall-effect analogue sticks
– Bluetooth and USB-C wired connection
– Two remappable back buttons
– Multiple stored profiles
SanDisk 128GB Ultra microSDXC Card
Handhelds and single-board setups run libraries from microSD, and a card this size holds a full patched library for several cartridge systems plus the clean bases behind it.
Specs:
– 128GB capacity
– UHS-I, Class 10, U1, A1 rated
– Up to 140 MB/s read speed
– Includes SD adapter
How to Choose
Choosing here means choosing habits more than software. If a hack offers BPS, take it: its refusal to patch a wrong base turns the most common disaster into a harmless error message. With IPS, compensate for the missing checksums yourself by verifying your base file’s checksum before every patch. Prefer Flips as your default tool because it covers the two formats you will meet most. Decide early whether you hard-patch or softpatch: hard-patch hacks you will keep, so they work in every emulator and on flash cartridges; softpatch when comparing variants.
Who Should Skip
Skip patching entirely if you do not own the game in question. A patch is not a loophole: without your own copy to dump, you have no base file. Also skip the deep end if you only want one famous translation — the softpatching route above reduces the job to renaming a file. Finally, skip any hack whose documentation does not state which base file it needs; a patch without a stated source version is guesswork even for experienced users.
FAQ
Can I patch a game I downloaded instead of dumping it?
No part of this guide assumes that. Patches are distributed legally precisely because they contain no game data; the base file is meant to come from your own cartridge. An unknown file is also the top technical cause of failed patches, since its version, region and header state are all unverified.
Why does Flips say my file does not match the patch?
Because it does not. The patch stores the checksum of the exact base the author used, and your file differs — wrong region, wrong revision, a header added or missing, or an already-modified dump. Check the readme for the required version and compare against your clean dump.
What is the difference between hard patching and softpatching?
Hard patching writes a new, permanently patched game file with a tool like Flips. Softpatching leaves your files untouched and applies the patch in memory at load time, using a same-named patch file beside the game. Hard-patched files work everywhere; softpatching is quicker to undo.
Can one patch be stacked on another, like a translation plus a bug fix?
Sometimes, but only when the second patch was designed for the already-patched game or the author documents the order. Two patches editing the same data overwrite each other unpredictably. Read both readmes; if neither mentions the combination, assume it is unsupported.
Final Verdict
Patching is a one-minute skill wrapped in one discipline: the right base file. Learn the three formats — IPS with no safety net, UPS with checksums, BPS with full verification — keep a verified clean dump of every game you own, and patch copies rather than originals. Do that, and every translation, fix and conversion reduces to one routine: check, patch, play.










