UPS format

UPS Patcher Guide: Applying .ups Files

UPS was designed as the smarter successor to IPS: it handles large files and carries checksums of the expected input and output, so the patcher itself catches a wrong ROM. It’s the format of choice for a huge share of modern GBA hacks — which also means it needs its own tools, because Floating IPS can’t read it.

  • Updated
  • Checked against Delta Patcher 3.1.6
  • 4 min read
  • Verified against primary sources · how we check

In short

  • Floating IPS cannot open UPS files. You need a UPS-capable patcher: NUPS on Windows, or another tsukuyomi-compatible tool.
  • UPS carries CRC32 checksums of the expected input and output — a mismatch warning means the ROM is wrong. Don’t override it.
  • Most modern GBA Pokémon hacks ship as .ups — if you patch Pokémon hacks, you need a UPS tool.
  • The format was created alongside tsukuyomi, the reference UPS creator.

What makes UPS different from IPS

UPS (Universal Patching System) fixes IPS’s two big weaknesses. First, it uses variable-length encoding for offsets, so there’s no 16MB ceiling — it handles GBA ROMs of any size. Second, every UPS patch stores CRC32 checksums of the file it expects as input and the file it should produce. When you apply a patch, the tool verifies both ends: wrong base ROM in, warning out; corrupt result, warning out.

The price of that intelligence is tooling: UPS never reached IPS’s ubiquity, so general-purpose patchers like Floating IPS skipped it. You need a dedicated UPS tool — which is a small download, not a big deal. The upside is significant: where an IPS patch applied to the wrong ROM produces a subtly broken game you might not notice for hours, a UPS patch refuses immediately and tells you exactly why.

UPS patchers

UPS patcher options
ToolPlatformCan also create patches
NUPSWindowsYes — the standard UPS creator/applier
tsukuyomiWindowsYes — the original reference implementation
UniPatcherAndroidYes — also reads IPS/BPS/XDelta
RomPatcher.jsAny browserYes — no install needed

Applying a UPS patch

  1. Open NUPS (or your UPS tool)

    The interface is minimal: a field for the patch, a field for the ROM, and an apply/create toggle. Make sure it’s in apply mode.

  2. Select the .ups patch

    Choose the extracted patch file. The tool may display the patch’s own checksum — that’s the format working as designed.

  3. Select the base ROM

    Pick the dump the hack’s readme names. The patcher compares its CRC32 against the patch’s expectation before writing anything.

  4. Heed the checksum warning

    If it warns of a mismatch, stop. Get the correct revision of the base ROM instead of forcing it — a forced UPS patch is how corrupted ROMs happen. Verify your dump independently too.

  5. Save the output and test

    Save under a new name, keeping the .gba extension, and load it in mGBA or VBA-M. GBA-specific notes.

UPS vs BPS: which to prefer?

Both are checksum-aware IPS successors, and the practical difference for applying patches is small. BPS (via Floating IPS or beat) has broader tool support and also validates; UPS is entrenched in the GBA Pokémon scene because tsukuyomi/NUPS were there first. Use whichever format the hack ships in — converting between patch formats isn’t a thing you do; you re-create the patch from the original and modified files if you ever need to. Creators choosing today usually pick BPS or XDelta.

UPS problems and fixes

Common UPS problems
ProblemLikely causeFix
“Checksum mismatch” on applyWrong base ROM revisionGet the exact revision the readme names — don’t force it
Patcher won’t open the fileYou opened it in Floating IPSUse a UPS-capable tool from the table above
Output CRC doesn’t matchInterrupted write or disk issueRe-apply to a fresh copy; check free disk space
Game glitches after a “successful” patchForced past a warningStart over from a verified dump and respect the checksum

Creating UPS patches

NUPS and tsukuyomi both create UPS patches: point the tool at the original file and your modified file, and it emits the .ups with checksums baked in. Because UPS validates on apply, a patch you create this way protects your users from the wrong-ROM problem automatically — one reason the format caught on with GBA hackers. As always, distribute the patch, never the ROM.

UPS beyond Windows

  • Browser: RomPatcher.js applies (and creates) UPS with no install.
  • Android: UniPatcher handles UPS on-device.
  • macOS/Linux: no native NUPS build — the browser route or a Windows VM covers it; some community command-line tools exist but the GUI tools above are the reliable path.

What’s inside a UPS patch

It helps to know why UPS behaves the way it does. A .ups file contains three things: the variable-length-encoded differences between the files, the CRC32 of the input file the patch was built against, and the CRC32 of the expected output. When you apply a patch, the tool checks the input checksum first — that’s the mismatch warning — then writes the output and verifies it against the output checksum. Two-sided verification is what makes UPS (and BPS) fundamentally safer than IPS: with IPS, only you can catch a wrong input, and only testing catches a bad output.

UPS FAQ

Can UPS patches be stacked (two hacks on one ROM)?

No — each UPS patch expects the clean base file, verified by checksum. A second patch applied to an already-patched ROM will fail its input check by design. Patch separate copies.

Is UPS still a good choice for new hacks?

It works fine, but most creators starting today pick BPS (wider tool support, same safety) or XDelta (for large files). UPS remains dominant where it’s entrenched — the GBA Pokémon scene.

My UPS patch is tiny but the hack is huge. Is that normal?

Yes. Patches store only differences, so a 16MB ROM with modest changes produces a small patch. Size says nothing about the hack’s scope.

NUPS won’t run on my Mac. What are my options?

Use RomPatcher.js in the browser — it applies and creates UPS with no install and works on macOS, Linux and Chromebooks. For repeat work, a small Windows VM also runs NUPS fine.

Continue learning