Pokemon Radical Red is a difficulty-focused FireRed overhaul, and its current release, v4.1, ships as a patch rather than a finished game. The official Radical Red patcher expects a clean FireRed base ROM, and the result is a .gba file you open in an emulator. This tutorial walks the whole pipeline in 13 steps and about 45 minutes: verify your base ROM, apply the patch, configure mGBA 0.10.5, and protect your saves.
Most guides stop at “patch it and press play.” That fails more often than it should, and the failures arrive late: a wrong-revision ROM that glitches three hours in, a save that disappears because you leaned on save states, a clock that never advances. We fix those problems up front with a small Python script that checks CRC32 values at every stage, plus a backup routine you run before each session.
If you have never applied a ROM hack before, our walkthrough on how to patch and play Pokémon ROM hacks covers the general ideas. This article is the Radical Red specific version, with the exact files, settings, and failure modes.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Pokemon Radical Red Is and Why Your Emulator Matters
Radical Red is a fan-made ROM hack of Pokémon FireRed. According to the release thread on PokéCommunity, creator soupercell built it with help from a friend, koala4, on top of the Complete FireRed Upgrade engine and the Dynamic Pokemon Expansion, both written by Skeli789, Ghoulslash, and others. Version 4.1 adds Gen 9 DLC Pokémon and character customization. No official price, paid tier, or commercial edition exists, and the project has no connection to Nintendo or Game Freak.
The hack is a difficulty project at heart. The thread describes bosses with maxed IVs and tuned EV spreads, improved trainer AI, a soft level cap tied to the next boss, and a long list of quality-of-life changes. Under the hood it brings the physical/special split, Fairy typing, Mega Evolution, raid battles, DexNav, and a skills menu on the L button that includes Auto Run, an in-game Time Changer, Infinite Repel, and a portable PokeVial.
That feature list explains why emulator choice and configuration matter more here than for vanilla FireRed. The hack leans on timekeeping (day and night encounters), on save data that must survive hundreds of hours, and on button mappings (the L button now opens a menu you will use constantly). An emulator that drops saves, forgets its clock, or maps L badly will cost you real progress.
We recommend mGBA for this job. It is free and open source, it runs on Windows, macOS, and Linux, and the Radical Red team lists it by name for Windows. The same patch-first approach carries over to other FireRed hacks, and we used it in our Pokémon Unbound setup with mGBA if you want a second hack to try afterward.
Why a script instead of a drag-and-drop patcher
GUI patchers work, and we list the good ones below. A script gives you two things they do not. First, it refuses to write a patched ROM unless the base file matches the CRC32 stored inside the patch, so you learn about a wrong revision in two seconds instead of two hours. Second, it leaves the original dump untouched and writes the result to a separate folder, which keeps your project reproducible when v4.2 or another update arrives.
Radical Red vs Vanilla FireRed: What Changes for Your Setup
Players often ask whether they can treat Radical Red like the original game inside an emulator. Mostly yes, but a handful of differences change how you configure things. The table below lists the ones that matter at the emulator level, drawn from the creator’s feature list in the release thread.
| Area | Vanilla FireRed | Radical Red | What it means for your setup |
|---|---|---|---|
| Pokémon available | Kanto and a few Sevii Island extras | Pokémon from up to Gen 8 are obtainable with some exceptions, plus Gen 9 DLC Pokémon in v4.1 | Longer sessions, so back up more often |
| Battle rules | Original Gen 3 mechanics | Physical/special split, Fairy typing, Mega Evolution, raid battles | Heavier battle scripts, so avoid aggressive frameskip |
| Difficulty | Standard | Boss teams with maxed IVs, stronger AI, soft level cap | Rewind and save states matter more for the rule you choose |
| Time of day | No day and night cycle | Day and night encounters, plus an in-game Time Changer | Check the RTC setting from Step 8 |
| Menus | Standard bag and start menu | L button opens a skills menu | Map L before your first session |
| Save data | One battery save | One battery save, but far more content to lose | Run the backup script every launch |
Two rows deserve emphasis. The time-of-day system is the one that surprises people, because vanilla FireRed never had a day and night cycle, so an emulator that has never needed a clock for Kanto suddenly does. The L button mapping is the other, since a keyboard layout that left L unbound works fine in the original game and fails on the first skills menu prompt.
None of this makes Radical Red harder to emulate in raw performance terms. A modern phone or laptop runs it at full speed. The extra care is about data safety and input, not horsepower.
Prerequisites and Versions You Need
Gather everything before you start. The table lists the exact versions this tutorial was written against on October 23, 2026.
| Component | Version | Notes |
|---|---|---|
| mGBA | 0.10.5 (stable) | Free and open source. Development builds labeled 0.11.x exist but are not stable releases |
| Pokémon Radical Red | v4.1 | Fan-made patch, free. The project ships a UPS patch plus an online patcher |
| Base ROM | Pokémon FireRed (USA) v1.0 | Must be dumped from a cartridge you own |
| Python | 3.9 or newer | Only for the verification script in Step 5 |
| Operating system | Windows 10 or 11, macOS, or Linux | mGBA publishes desktop builds for all three |
On versions, mGBA’s own news page shows 0.10.5 as a bugfix release, and its notes say it is the last release before 0.11 unless a major issue turns up. The same notes warn that it may be the last release to support Windows 7 through 8.1 and macOS 10.9 through 10.12. A Linux gamepad bug is reportedly assigned to the 0.11.1 milestone, with a fix in development builds, but no stable 0.11 release exists as of this writing. Stick with 0.10.5 unless you have a reason to test a nightly.
Download mGBA only from mgba.io, the project’s own site. Search results for “mGBA download” also surface mirror sites that bundle installers with extra software, and third-party forks such as iOS ports are not the official desktop emulator. If you want a deeper tour of the interface before you begin, our mGBA setup guide for Pokémon covers every menu.
You also need a way to dump your cartridge. A USB cartridge reader works, and a flash cart with a dump function works too. Section three explains the legal side.
Plan your time before you begin. The estimate below assumes you already own the cartridge and a reader.
| Phase | Steps | Typical time |
|---|---|---|
| Workspace and ROM check | 1 to 3 | 10 minutes |
| Patch download and build | 4 to 6 | 10 minutes |
| mGBA configuration | 7 to 10 | 15 minutes |
| Saves, difficulty, first boot | 11 to 13 | 10 minutes |
That adds up to the 45 minutes in the title. Dumping the cartridge is the part that can stretch longer, because cartridge readers vary in speed and a worn cartridge may need a few attempts.
What you do not need
You do not need a GBA BIOS file. mGBA ships with its own replacement BIOS, so FireRed boots without one, and a dumped BIOS only improves boot-screen accuracy. You also do not need to pay for anything. If a site asks for a fee to “unlock” Radical Red, close the tab.
The Legal Line: Dump Your Own FireRed Cartridge
Emulators are legal software. The gray area is the game data, and the Radical Red project itself draws the line clearly: it distributes a patch, not a ROM. A patch holds only the differences between FireRed and the hack, so it contains none of Nintendo’s code on its own. The patched .gba file you create, however, does contain FireRed, which is why you must start from a copy you dumped yourself and never share the result.
We do not link to ROM sites, and you should treat any “pre-patched Radical Red ROM” download as both infringing and risky. Those files often come from unknown uploaders, and a tampered ROM can ship with the wrong revision or with bundled junk. This is general information, not legal advice, and copyright rules differ by country, so check the rules where you live.
Dumping is straightforward with the right hardware. A cartridge reader copies the ROM and the save file off your original FireRed cartridge, and the process takes a few minutes. Watch out for counterfeit cartridges, because a fake can dump as a different or damaged ROM. A recent guide to spotting fake Game Boy and GBA cartridges is worth a read before you buy a used copy.
If you own a flash cart instead of a reader, you can also skip the emulator entirely. The release thread says the hack works on real hardware, and our EverDrive GBA Pro setup for Pokémon shows how to load a patched ROM that way.
If you do not own a cartridge, there is a legitimate way to play vanilla FireRed today: a digital rerelease of Pokémon FireRed Version is available for the Nintendo Switch family of systems. That version will not give you a ROM to patch, but it lets you play the original game with official support.
Which revision you need
Radical Red patches against FireRed (USA) v1.0, not the later v1.1 revision and not LeafGreen. Hash values for each revision circulate in many guides, and some of them disagree with each other. Skip the guesswork. The UPS patch stores the CRC32 of the exact file it expects, and our script compares it for you in Step 6.
Phase 1: Prepare the Workspace and Verify the Base ROM (Steps 1 to 3)
Step 1: Create the project folder. Keep the clean dump, the patch, the patched output, and your saves in separate folders. Mixing them is how people overwrite a base ROM with a patched one and lose their only clean copy.
radical-red/
roms/
base/ <- your FireRed dump, never modified
patched/ <- script output goes here
patches/ <- Radical Red .ups file
saves/ <- .sav files from mGBA
states/ <- save states
backups/ <- timestamped save snapshots
rr_build.py
backup_saves.pyCreate it with mkdir -p radical-red/roms/base radical-red/roms/patched radical-red/patches radical-red/saves radical-red/states radical-red/backups on macOS or Linux. On Windows PowerShell, run New-Item -ItemType Directory -Force once per folder, or create them in Explorer.
Step 2: Install mGBA 0.10.5 and Python. Download the build for your operating system from mgba.io, extract or install it, and open it once to confirm it launches. Check Help, then About, and make sure the version reads 0.10.5. Next, confirm Python:
python3 --version
# Python 3.9.x or newer is fine. On Windows use: py --versionIf you want mGBA to keep its configuration inside the project folder, create an empty file named portable.ini next to the mGBA executable. That makes the install self-contained, which helps if you move the project to a USB drive or another PC.
Step 3: Copy in and inspect your base ROM. Put your FireRed dump in roms/base and rename it FireRed.gba. Check that the file is a plain .gba and not a .zip, because patchers cannot read archives. Compute a hash for your records so you can recognize the file later:
# macOS
shasum -a 1 roms/base/FireRed.gba
# Linux
sha1sum roms/base/FireRed.gba
# Windows PowerShell
Get-FileHash -Algorithm SHA1 roms\base\FireRed.gbaWrite the result in a text file next to the ROM. You do not need to match it against an online list, because Step 6 performs a stricter check using the patch itself. The hash is simply proof that the file never changes after this point, and it lets you tell your clean dump apart from a patched copy a year from now.
Phase 2: Patch FireRed Into Radical Red (Steps 4 to 6)
Step 4: Get the official patch and understand the format. Download the Radical Red UPS patch from the project’s release thread or its official patcher page. Skip any mirror. The team’s instructions for manual patching say to apply the .ups file with a patching tool, naming specific ones:
Use a patching tool to apply the .ups patch file onto the Fire Red rom (Tsukuyomi/NUPS for Windows, Unipatcher for Android.
That sentence comes straight from the Radical Red development team’s release thread, parenthesis left unclosed in the original. UPS is one of four common patch formats, and the differences explain why we chose a script that reads UPS directly. A format comparison on gametranslate.us covers the history in more depth.
| Format | Built-in checksums | Typical use | Tools that read it |
|---|---|---|---|
| IPS | No | Oldest format, small hacks | Most patchers, including Floating IPS |
| UPS | Yes (CRC32 of input, output, and patch) | Radical Red and many Pokémon hacks | NUPS, tsukuyomi, UniPatcher, RomPatcher.js |
| BPS | Yes | Newer hacks, handles file moves well | Floating IPS (Flips) and others |
| xDelta | Varies by tool | Large changes, translation projects | xDelta UI, web patchers |
Save the file as patches/RadicalRed-4.1.ups. If the download arrives inside a .zip, extract it first.
Step 5: Save the build script. The script below reads UPS patches, checks the base ROM against the CRC32 inside the patch, applies the changes, then checks the output CRC32 too. It refuses to run if you point it at an already patched ROM, and it refuses to overwrite its input. Save it as rr_build.py in the project root.
#!/usr/bin/env python3
"""Apply a UPS patch to a base GBA ROM and verify CRC32 at every stage."""
import argparse
import hashlib
import sys
import zlib
from pathlib import Path
def read_varint(buf, pos):
value, shift = 0, 1
while True:
byte = buf[pos]
pos += 1
value += (byte & 0x7F) * shift
if byte & 0x80:
return value, pos
shift <<= 7
value += shift
def apply_ups(base, patch):
if patch[:4] != b"UPS1" or len(patch) < 20:
raise ValueError("not a UPS patch (missing UPS1 header)")
if zlib.crc32(patch[:-4]) != int.from_bytes(patch[-4:], "little"):
raise ValueError("patch file is damaged (its own CRC32 fails)")
in_crc = int.from_bytes(patch[-12:-8], "little")
out_crc = int.from_bytes(patch[-8:-4], "little")
pos = 4
in_size, pos = read_varint(patch, pos)
out_size, pos = read_varint(patch, pos)
if zlib.crc32(base) == out_crc and len(base) == out_size:
raise ValueError("this ROM is already patched, use the clean base ROM")
if len(base) != in_size or zlib.crc32(base) != in_crc:
raise ValueError(
"base ROM mismatch: expected %d bytes with CRC32 %08X, got %d bytes with CRC32 %08X"
% (in_size, in_crc, len(base), zlib.crc32(base))
)
out = bytearray(base[:out_size])
out.extend(bytes(out_size - len(out)))
end = len(patch) - 12
offset = 0
while pos < end:
skip, pos = read_varint(patch, pos)
offset += skip
while True:
byte = patch[pos]
pos += 1
if offset < out_size:
out[offset] ^= byte
offset += 1
if byte == 0:
break
if zlib.crc32(out) != out_crc:
raise ValueError("patched output failed its CRC32 check")
return bytes(out), in_crc, out_crc
def main():
ap = argparse.ArgumentParser(description="Build a patched GBA ROM from a clean base and a UPS patch")
ap.add_argument("--base", required=True, help="clean FireRed .gba you dumped yourself")
ap.add_argument("--patch", required=True, help="Radical Red .ups patch")
ap.add_argument("--out", required=True, help="where to write the patched .gba")
args = ap.parse_args()
base_path, patch_path, out_path = Path(args.base), Path(args.patch), Path(args.out)
if out_path.resolve() == base_path.resolve():
sys.exit("ERROR: --out must not be the base ROM path")
base, patch = base_path.read_bytes(), patch_path.read_bytes()
print("base : %s (%d bytes)" % (base_path.name, len(base)))
print("patch : %s (%d bytes)" % (patch_path.name, len(patch)))
try:
rom, in_crc, out_crc = apply_ups(base, patch)
except ValueError as err:
sys.exit("ERROR: %s" % err)
out_path.parent.mkdir(parents=True, exist_ok=True)
out_path.write_bytes(rom)
print("input CRC32 OK : %08X" % in_crc)
print("output CRC32 OK : %08X" % out_crc)
print("output SHA-1 : %s" % hashlib.sha1(rom).hexdigest())
print("wrote : %s (%d bytes)" % (out_path, len(rom)))
if __name__ == "__main__":
main()A short note on how it works. UPS stores each change as an XOR against the original byte, so the script walks the patch, skips ahead by a variable-length offset, then XORs a run of bytes until it hits a zero terminator. The last twelve bytes of every UPS file hold three CRC32 values (input, output, and the patch itself), which is what lets the script prove each stage is correct.
Step 6: Run the build and read the result. From the project root, run:
python3 rr_build.py \
--base roms/base/FireRed.gba \
--patch patches/RadicalRed-4.1.ups \
--out roms/patched/PokemonRadicalRed-4.1.gbaA successful run prints five lines that end with the output path. The checksums below are placeholders, since your numbers come from your own files:
base : FireRed.gba (... bytes)
patch : RadicalRed-4.1.ups (... bytes)
input CRC32 OK : XXXXXXXX
output CRC32 OK : YYYYYYYY
output SHA-1 : 40 hex characters
wrote : roms/patched/PokemonRadicalRed-4.1.gba (... bytes)If the base check fails, the script prints the size and CRC32 it expected next to what it found, and it writes nothing. That message tells you whether you have the wrong revision (the size matches but the CRC32 does not), a trimmed or padded dump (the size differs), or a corrupted copy. Fix the input and run again.
If you would rather use a GUI, the same result comes from NUPS or tsukuyomi on Windows, from RomPatcher.js in a browser, or from UniPatcher on Android. The team’s online patcher also works. Whichever route you pick, keep the clean base ROM, and never patch the output of a previous patch.
Phase 3: Configure mGBA for Radical Red (Steps 7 to 10)
Step 7: Load the patched ROM. Open mGBA and choose File, then Load ROM. Pick PokemonRadicalRed-4.1.gba. You should see the standard GBA boot sequence and then the hack’s title screen. If you see a black screen or garbage tiles instead, jump to the troubleshooting section before touching any settings.
Step 8: Check the game overrides and the clock. The Radical Red team gives one emulator instruction that people skip. The line from their release thread is short:
Make sure your emulator has Real Time Clock (RTC) enabled.
In mGBA, open Tools, then Game overrides, and confirm the hardware options for this ROM. Leave the save type on autodetect first. The in-game Time Changer from the L menu covers day and night encounters if the clock misbehaves, so you have a fallback. If saves fail to persist later, come back here and force the 128 KB flash option (labeled Flash 1Mb in mGBA’s menu), which some guides recommend for this hack.
Step 9: Set video, audio, and paths. Open Settings, then Audio/Video, and turn on integer scaling if your monitor allows it, because the crisp pixels suit the hack’s sprites. Leave interframe blending off unless you like the soft look. On the same tab, keep audio sync on, which stops the crackle that appears when a slow PC lets the audio buffer run dry. Our notes on frame sync and audio settings for Pokémon on mGBA go through each toggle and the trade-offs.
Then point mGBA at your project folders so every save lives where your backup script looks. Set the save game path to saves and the save state path to states under Settings, then Paths. A launcher script makes this repeatable:
#!/bin/sh
# run.sh - back up saves, then start mGBA with project-local paths
cd "$(dirname "$0")"
python3 backup_saves.py --keep 30 || true
mgba-qt \
-C savegamePath="$PWD/saves" \
-C savestatePath="$PWD/states" \
"roms/patched/PokemonRadicalRed-4.1.gba"@echo off
rem run.bat - back up saves, then start mGBA with project-local paths
cd /d "%~dp0"
py backup_saves.py --keep 30
mGBA.exe -C savegamePath="%CD%\saves" -C savestatePath="%CD%\states" "roms\patched\PokemonRadicalRed-4.1.gba"The -C flag overrides a configuration value for that launch. On Windows, point the batch file at your actual mGBA executable path if it is not on your PATH.
Step 10: Map the controls, including L. Open Settings, then Controllers, and map A, B, L, R, Start, and Select to a gamepad or keyboard. Do not skip L and R. In Radical Red, L opens the skills menu with Auto Run, the Time Changer, Infinite Repel, and the PokeVial, and pressing L on a move in battle shows its details. Pressing B on the bike gives a speed boost. Then bind a hotkey for fast forward under Settings, then Shortcuts. The release thread boasts about an even faster turbo speed, but the emulator’s own fast forward helps with grinding, egg hatching, and long cutscenes.
Phase 4: Saves, Difficulty Mode, and First Boot (Steps 11 to 13)
Step 11: Understand the two kinds of saves. The game writes a battery save (a .sav file) when you save in the menu. mGBA also lets you freeze the whole machine in a save state. Treat the in-game save as your real progress and save states as bookmarks. A save state ties itself to the exact ROM and emulator version that created it, so never carry a state from vanilla FireRed into Radical Red, and expect old states to break if you swap emulators. Start a fresh game after patching.
Back up the .sav file every session. Save this as backup_saves.py:
#!/usr/bin/env python3
"""Copy every .sav into a timestamped folder and keep only the newest N snapshots."""
import argparse
import shutil
from datetime import datetime
from pathlib import Path
ap = argparse.ArgumentParser()
ap.add_argument("--saves", default="saves")
ap.add_argument("--backups", default="backups")
ap.add_argument("--keep", type=int, default=30)
args = ap.parse_args()
saves = sorted(Path(args.saves).glob("*.sav"))
if not saves:
raise SystemExit("no .sav files found in %s" % args.saves)
snap = Path(args.backups) / datetime.now().strftime("%Y%m%d-%H%M%S")
snap.mkdir(parents=True, exist_ok=True)
for sav in saves:
shutil.copy2(sav, snap / sav.name)
print("backed up %s (%d bytes)" % (sav.name, sav.stat().st_size))
old = sorted(p for p in Path(args.backups).iterdir() if p.is_dir())[: -args.keep]
for folder in old:
shutil.rmtree(folder)
print("pruned %s" % folder.name)On the first launch there are no saves yet, so the script exits with a short message and the launcher carries on to start mGBA. That is expected. Once you save in the game, every later launch makes a snapshot. The release thread also says anything from version 2.0 forward stays compatible with later releases, so a backup from an older run should still work after an update. If you plan a hardcore run, our Pokémon Nuzlocke emulator setup shows how to track deaths and enforce rules around the backup habit.
Step 12: Pick your difficulty mode. Decide on a mode before you start, because you will live with it for the whole run. The descriptions paraphrase the creator’s own guide in the release thread, roughly ordered from hardest to easiest.
| Mode | What the creator says | Good for |
|---|---|---|
| Hardcore | The hardest option, with unfair obstacles and odd team compositions | Experts who want punishment |
| Restrict Mode | Blocks many broken team compositions and set-up cheese, harder than normal | Skilled players |
| Restrict + Min Grinding | Much less grindy, with an easier early and mid game | Streamers running a Nuzlocke |
| Normal | A little grindy, and broken Pokémon work to their full potential | The intended experience |
| Min Grinding | Keeps the challenge but cuts the grind | Players short on time |
| Easy Mode | Still harder than vanilla games and traditional ROM hacks | Newcomers to the hack |
| Easy + Min Grinding | Min Grinding with item use and Switch Mode available | Casual playthroughs |
Normal is the creator’s original vision. If this is your first run, pick Min Grinding or Easy, because even those are harder than most hacks you have tried.
Step 13: Verify the whole setup before you invest hours. Play through the intro, save once in the menu, and then run through this checklist:
- The
savesfolder now contains a.savfile with a recent modified time. - Closing mGBA and reopening the ROM loads your save from the menu, not just from a save state.
- Pressing L opens the skills menu, and the Time Changer responds.
- The launcher creates a new folder inside
backupseach time you start. - Your clean
FireRed.gbastill has the hash you recorded in Step 3.
If all five hold, the setup is sound. If any fails, the pitfalls and troubleshooting sections below map each symptom to a fix.
Which Emulator Fits Radical Red Best
We built this tutorial around mGBA, but the hack runs on several emulators. The Radical Red team names the options by platform, and the table below combines their list with how each choice behaves in practice.
| Platform | Emulator named by the team | Our take |
|---|---|---|
| Windows | mGBA or VBA | Pick mGBA, since it is actively maintained and accurate |
| Mac | OpenEmu | Works well and has a simple library view |
| Android | myBoy | The team’s pick for phones, and UniPatcher handles patching |
| iOS | GBA4iOS | Named by the team, so verify it still installs on your iOS version |
| Linux | mGBA (desktop build) | Same as Windows, using the Linux desktop build |
| Real hardware | Flash cart | The team confirms the hack works on actual consoles |
The team’s wording on emulators is worth reading in full, since it sets the support baseline:
You can play on mGBA or VBA if you are on Windows, openEmu if you are on Mac, myBoy if you’re on Android, and gba4IOS if you’re on iOS.
One caution. Treat that list as the team’s recommendation at the time of writing, because mobile emulators change faster than desktop ones, and some apps drop out of app stores without notice. The desktop picks are the safest bet.
If you want to see how the major handheld emulators compare across Pokémon eras, our breakdown of mGBA, WatermelonDS, and Azahar places mGBA in context. And if mGBA does not suit your hardware, SkyEmu is a lightweight alternative covered in our SkyEmu Pokémon setup. Test any alternative on a throwaway save first, because accuracy differences show up in a hack this heavy.
Radical Red on a phone
Phone players should patch on the phone itself with UniPatcher, then load the result in myBoy. The same rules apply: keep the clean base ROM, keep the output separate, and back up the save file by copying it out of the emulator’s folder every few sessions. Phones offer less room for mistakes because file managers hide folders, so name your files clearly.
Output Examples: What a Healthy Setup Looks Like
Seeing the correct output once saves hours of doubt. After Step 6 succeeds, your folder should look like this:
radical-red/
roms/base/FireRed.gba (unchanged, same hash as Step 3)
roms/patched/PokemonRadicalRed-4.1.gba
patches/RadicalRed-4.1.ups
saves/ (empty until you save in game)After your first in-game save and your second launch, expect this on the console:
backed up PokemonRadicalRed-4.1.sav (... bytes)And a backups folder holding one timestamped directory per session, such as 20261023-203015. The save file name follows the ROM file name, which is why you should not rename the ROM after you start playing. A renamed ROM makes mGBA create a second, empty save next to the old one, and that surprise has ended many runs.
Here is the failure output you want to recognize, because it means the script did its job:
base : FireRed.gba (... bytes)
patch : RadicalRed-4.1.ups (... bytes)
ERROR: base ROM mismatch: expected N bytes with CRC32 XXXXXXXX, got M bytes with CRC32 ZZZZZZZZNothing gets written when that happens. The error is a clean stop, not a crash.
Common Pitfalls That Break Radical Red Setups
These six mistakes account for most of the broken installs we see described in forums.
1. Patching the wrong revision. FireRed shipped in more than one revision, and a v1.1 dump or a LeafGreen file will not match the patch. Fix: let the script’s CRC32 check decide, and dump your cartridge again if it fails.
2. Patching an already patched ROM. People patch Radical Red onto a previous hack, or onto a Radical Red 3.x file, and get a game that boots but corrupts. Fix: always patch from the clean base, which is why the script rejects patched input.
3. Carrying over save states. A state captured in vanilla FireRed, or in an older Radical Red version, restores memory that no longer matches the ROM. Fix: use in-game saves for progress and delete old states after any patch or emulator update.
4. Relying only on save states. If a state file corrupts or an emulator update changes the format, your run goes with it. Fix: save in game at every town, and let the backup script snapshot the .sav.
5. Renaming the ROM mid-run. mGBA ties the battery save to the ROM file name, so renaming creates an empty second save. Fix: pick a final name in Step 6 and keep it.
6. Downloading from random sites. Fake patch pages and “ready to play” ROM pages carry malware and outdated builds. Fix: use only the release thread, the official patcher, and your own dump.
A seventh trap deserves a mention. Cheat codes written for vanilla FireRed do not line up with a hack built on a custom engine, and they can corrupt the save. Use codes written for Radical Red specifically, or skip cheats entirely.
Troubleshooting: 10 Fixes for Radical Red on Emulator
Work through these in order when something breaks.
- The script says “base ROM mismatch.” You have the wrong revision, a LeafGreen file, a trimmed dump, or an archive. Check that the file is a plain .gba, redump the cartridge, and compare the size and CRC32 shown in the message.
- The script says “patch file is damaged.” The download got cut off or arrived inside an archive. Download the .ups again and extract it if it came zipped.
- The game boots to a black or white screen. The ROM is probably unpatched or the patch applied to the wrong base. Delete the output, rerun Step 6, and load the new file. Check that you opened the file from
roms/patched. - Graphics glitch after a few hours. A wrong-revision ROM can run for a while before the broken pointers show up. Rebuild from a verified base and restore your newest
.savfrombackups. - Your save vanishes after closing mGBA. You likely saved with a state only, renamed the ROM, or the save type is wrong. Save from the in-game menu, confirm the file name, and try forcing the 128 KB flash option in Game overrides.
- Day and night never change. Confirm the RTC setting from Step 8, then use the Time Changer in the L menu to move time forward and test the encounter table.
- Audio crackles or the game stutters. Turn audio sync on, close background apps, and drop shaders. If it persists on a laptop, switch to the high-performance GPU profile.
- The controller is not detected on Linux. A multi-controller detection issue has been reported against mGBA on Linux and is assigned to the 0.11.1 milestone, with development builds reportedly carrying a fix. Try a wired pad, a different USB port, or the keyboard until a stable build ships.
- mGBA will not update itself. The 0.10.4 notes say a bug broke the built-in updater for 0.10.3 users, who had to update manually. Download the current installer from mgba.io instead of relying on the updater.
- Cheat codes do nothing or crash the game. The engine under Radical Red moves data around, so vanilla codes miss their targets. For the mGBA cheat workflow itself, our guide to Pokémon Emerald cheats on mGBA explains the editor, but find codes made for Radical Red.
If none of these match your symptom, rebuild the ROM from scratch, start a fresh save, and compare behavior. A clean rebuild takes about two minutes with the script and rules out most file-level causes.
Advanced Tips for Radical Red Players
Once the basics work, a few changes make long runs smoother.
Use rewind sparingly. mGBA has a rewind feature that steps back a few seconds. It is handy for dodging a misclick on a boss turn, and it also undermines any challenge run. Keep it off for Nuzlockes and turn it on for casual play.
Script the emulator. mGBA includes Lua scripting, which lets you read memory and automate repetitive checks. We used it in our mGBA MCP project where Claude plays Pokémon, and the same approach can drive a custom overlay that shows your party’s IVs or your encounter count.
Watch the community tools. Fans maintain trackers and team export tools for the v4.1 release. One team-export tool was reportedly updated on October 22, 2026, and a Nuzlocke tracker was reportedly updated on October 13, so check their pages for current versions before you rely on them.
Version your project. Put the project folder, minus the ROMs and saves, in Git. Commit the scripts and a README with your mGBA version and the date. When Radical Red updates, you add the new .ups, run one command, and keep your old patched ROM beside the new one while you test the move.
Keep a run log. A plain text file next to your save works better than memory. Note the date, the difficulty mode, your badge count, and any rule changes. If a save corrupts, the log tells you which snapshot in backups is the one to restore, and it saves you from guessing across thirty similar folders.
Check your emulator after every update. Emulators change save handling and input defaults between releases, even in bugfix versions. After updating mGBA, open a copy of your save, confirm the L menu still works, and confirm the clock still advances before you trust the new build with your main file.
Back up off the machine. Sync the backups folder with a cloud service or a second drive. A local-only backup does not survive a dead SSD. Keep ROMs out of any public repository or shared folder.
Test updates on a copy. When a new release appears, build it into a separate file name, copy your latest save next to it, and play ten minutes before committing. The release thread says anything from 2.0 forward stays compatible with later versions, but a copy costs nothing and protects a long save.
The Complete Working Project
By now you have a project folder that rebuilds on demand. Here is the final layout and the commands that drive it:
radical-red/
rr_build.py Step 5, CRC32-checked UPS patcher
backup_saves.py Step 11, timestamped save snapshots
run.sh / run.bat Step 9, snapshot then launch
roms/base/ clean FireRed dump (never edited)
roms/patched/ build output
patches/ Radical Red .ups
saves/ states/ backups/Daily use takes one command. Run ./run.sh on macOS or Linux, or double-click run.bat on Windows. Updating takes two: drop the new .ups in patches and rerun the build command from Step 6 with a new output name. Total setup time on a clean machine is about 45 minutes, and most of that is dumping the cartridge.
For more Pokémon emulation projects across the platforms, browse the gaming category for setup guides covering other consoles and hacks.
FAQ
Is Pokemon Radical Red free?
Yes. The hack is a fan project with no official price or paid tier, and you should avoid anyone charging for it. You still need a copy of FireRed, which you must own and dump yourself.
Which version of Radical Red is current?
Version 4.1 is the current release as of October 23, 2026. It adds Gen 9 DLC Pokémon and character customization. No 4.2 release has been confirmed.
Which FireRed ROM does the patch need?
The release instructions call for a clean FireRed (USA) v1.0 base. The patch stores a CRC32 of the exact file it expects, so the script in this tutorial tells you immediately if your dump is the wrong one.
Do I need a GBA BIOS to run it in mGBA?
No. mGBA includes a replacement BIOS and boots FireRed-based games without one. A dumped BIOS only improves boot-screen accuracy.
Can I play Radical Red on my phone?
Yes. The team names myBoy for Android and GBA4iOS for iOS, and UniPatcher handles patching on Android. Patch on the device, keep your clean ROM separate, and back up the save file regularly.
Can I use cheats and save states safely?
Save states are fine as bookmarks, as long as you also save in game. Cheat codes are risky unless they were written for Radical Red, since the hack’s engine changes memory layout compared with vanilla FireRed.
Does it work on real hardware?
According to the release thread, yes. Load the patched ROM on a GBA flash cart, and bring your own cartridge dump for the base.
