Every Pokémon emulator community eventually runs into the same wall: the game runs fine, the save file loads, but moving a save between mGBA, melonDS, Azahar, and Eden turns into a guessing game of file extensions and folder paths. The tool that solves this is PKHeX, the free, open-source save editor maintained by developer kwsch and the Project Pokémon community. As of version 26.08.26, released August 26, 2026 and still the build this guide tracks heading into September 2026, PKHeX covers every mainline Pokémon title from the original Game Boy era through Scarlet/Violet and the newly added Legends: Z-A, and it is the piece of software that sits between a raw emulator save and a usable, legal Pokémon file.
This tutorial walks through installing PKHeX, pulling save files out of the major Pokémon emulators, opening and editing them safely, running the built-in legality checker, and moving Pokémon between generations without corrupting a save. It also covers the mistakes that trip up nearly everyone on their first run, plus a working example project you can copy step for step.
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 PKHeX Actually Does (and What It Doesn’t)
PKHeX is a save file editor, not a save state editor and not a live memory-injection tool. It opens a raw save file (typically a .sav file, a main file, or an exported Switch save folder), lets you view and modify boxes, party Pokémon, trainer data, and items, then writes the changes back to that same save format so the emulator can load it again. It does not touch emulator save states (the .state or .ss0-style snapshots most emulators create with hotkeys), and it does not read or write memory while a ROM is actively running.
According to the release notes tracked on Project Pokémon, PKHeX 25.10.26 (dated October 27, 2025) added support for Pokémon Legends: Z-A, including a new Pokédex editor, trainer info editor, event block editor, and fashion block editor built specifically for Gen 9a save data. The changelog explicitly warns users not to assume a Pokémon is undetectable online just because PKHeX’s legality checker doesn’t flag it, since the checker is heuristic rather than an absolute guarantee. That distinction matters for this guide: PKHeX is a save-editing and organization tool first, and a legality-checking aid second.
Prerequisites and Version Requirements
Before starting, confirm you have the following. PKHeX is Windows-only in its official desktop build, though the underlying PKHeX.Core library on NuGet lists compatibility targets for other platforms for developers building their own tools.
- Operating system: Windows 10 or Windows 11, 64-bit. Older PKHeX builds (around v25.11.07 and earlier localized builds) list Windows 7 SP1+ with .NET Framework 4.6 as a fallback minimum, but current releases target modern Windows only.
- .NET runtime: .NET 9 Desktop Runtime for the current release track. PKHeX moved from .NET 7 to .NET 8 with version 23.12.18, then to .NET 9 with the 25.10.26 release. The Project Pokémon download notes state this will be the last release cycle on .NET 9 before a move to .NET 10.
- Disk space: Under 50 MB for PKHeX itself; the download package is roughly 37 MB.
- A working Pokémon emulator with a save file already generated — mGBA (GBA), melonDS or DeSmuME (DS), Azahar (3DS), or Eden/Ryujinx-based emulators (Switch).
- A backup location — a separate folder or external drive to store original saves before editing anything.
If you haven’t set up an emulator yet, this tutorial assumes you already have one running. For GBA titles specifically, see our mGBA setup guide for Pokémon GBA games; for DS titles, our melonDS Pokémon setup walkthrough; and for 3DS titles, our Azahar emulator setup for Pokémon covers installation from scratch.
Step 1: Download and Verify PKHeX
PKHeX is distributed through two trustworthy channels: the official GitHub repository maintained by kwsch, and the Project Pokémon file archive, which mirrors official releases and hosts changelog history. Do not download PKHeX from random third-party sites — save editors are a common vector for bundled malware, and PKHeX’s source code being fully open means there’s no reason to use an unofficial mirror.
- Go to the GitHub releases page for the PKHeX repository and download the latest
PKHeX_win_[version].zipasset. - Extract the ZIP to a dedicated folder — for example
C:\Emulation\PKHeX. Do not run it from inside a ZIP file browser, as .NET apps can fail silently when launched directly from an archive. - If you don’t already have the required runtime, download the .NET 9 Desktop Runtime from Microsoft’s official .NET download page. Select the “Desktop Runtime” installer, not the ASP.NET or SDK variant.
- Launch
PKHeX.exe. If Windows SmartScreen flags it as an unrecognized publisher, that’s expected for community open-source tools distributed as unsigned binaries — verify the download hash against the GitHub release page rather than ignoring the warning outright.
If the app crashes on launch with a runtime error, it’s almost always a missing or mismatched .NET version. This is the single most common first-run failure and is covered in the troubleshooting section below.
Step 2: Back Up Every Save File Before You Touch PKHeX
This is the step people skip and regret. Before opening any save in PKHeX, copy the original file to a separate backup folder with a timestamp in the name. PKHeX writes changes back to the same file structure it read, and while it rarely corrupts data outright, generation-specific quirks (particularly around Gen 6-7 3DS saves and Switch save containers) can produce a file the source emulator refuses to load if something goes wrong mid-edit.
# Example backup convention (run in PowerShell from your saves folder)
Copy-Item ".\Pokemon Scarlet.sav" ".\backups\Pokemon_Scarlet_2026-09-11.sav"
Copy-Item ".\melonDS\saves\pkmn_white.sav" ".\backups\pkmn_white_2026-09-11.sav"Keep at least two backup generations — the original untouched file, and the last-known-good file before your most recent edit session. Cloud sync folders (Dropbox, OneDrive) work fine for this as long as you’re not editing the file while it’s mid-sync, which can cause a partial write.
Step 3: Locate Save Files by Emulator
Every emulator stores saves in a different location and format. PKHeX expects a raw save file, not a save state, so you need to find the right one. Here’s where to look for the emulators most commonly used for Pokémon games in 2026.
| Emulator | System | Default Save Location | File Extension |
|---|---|---|---|
| mGBA | Game Boy Advance | Same folder as the ROM, or Documents/mGBA/saves if configured | .sav |
| melonDS | Nintendo DS | Same folder as the ROM by default | .sav |
| DeSmuME | Nintendo DS | Same folder as the ROM, or a designated battery-save folder | .dsv / .sav |
| Azahar | Nintendo 3DS | Azahar/sdmc/Nintendo 3DS/[ID]/[ID]/title/.../data | main (no extension) |
| Eden / Ryujinx-based | Nintendo Switch | Emulator’s user save data directory, exported via the built-in save manager | folder export, then packed |
| Dolphin | GameCube (Colosseum/XD) | Dolphin’s GC memory card folder | .raw / .gci |
For 3DS titles specifically, the save isn’t a single flat file sitting next to the ROM — it’s buried inside Azahar’s virtual SD card structure under the game’s title ID. The easiest way to find it without hunting through folders manually is to use Azahar’s built-in “Open Save Data Location” option from the game’s right-click context menu in the emulator’s game list, which jumps straight to the correct folder in Windows Explorer.
For Switch titles, most current emulator builds include an internal save manager that can export the save directory as a folder or a zipped archive rather than exposing a single file path. Use that built-in export function rather than digging through the emulator’s user data folder by hand, since Switch save containers are structured differently from the flat .sav files older systems use.
Step 4: Open a Save File in PKHeX
- Launch
PKHeX.exe. - Go to File → Open, or simply drag the save file directly onto the PKHeX window.
- PKHeX auto-detects the game and generation based on the save file’s internal structure. The title bar will update to show the detected game — for example “Pokémon Scarlet/Violet.”
- If PKHeX shows an error like “not a valid save file,” double-check you grabbed the raw save and not a save state, a backup with the wrong extension, or a corrupted partial copy.
Once loaded, you’ll see tabs across the top for Trainer Info, Party/Box Data, Bag/Items, and — depending on the generation — additional tabs like the Pokédex editor, Union Circle settings, or (for Legends: Z-A saves specifically) the new event block and fashion block editors added in the 25.10.26 release.
Step 5: Navigate the Box Viewer and Party Editor
The Box Data tab is where most editing happens. It mirrors the in-game PC box layout — a grid you can click through to inspect any stored Pokémon. Double-clicking a slot opens the full Pokémon editor, showing species, level, nature, IVs, EVs, moves, held item, ball, OT (original trainer), and met location data.
Common legitimate uses at this stage include:
- Reorganizing boxes without manually dragging Pokémon in-game one at a time.
- Checking IVs and natures on Pokémon you already legitimately caught, without needing an in-game IV checker NPC.
- Renaming nicknames in bulk, or fixing a nickname typo from years ago.
- Moving Pokémon between save files you own, to consolidate collections across multiple cartridges or emulator profiles.
- Restoring a save after a corrupted emulator crash, using PKHeX to rebuild box structure from an older backup.
Step 6: Run the Legality Checker
Every Pokémon slot in PKHeX has a legality indicator — a green checkmark or a red flag in the editor window. Right-click any Pokémon and select Legality Report to see a detailed breakdown of why a Pokémon is flagged as invalid, whether that’s an impossible move combination, a stat spread outside legal bounds for its level, or an OT/met-location mismatch for its origin game.
The 25.10.26 release added a bulk “Verify All” function that scans an entire save at once rather than checking one Pokémon at a time, flagging issues like mismatched fusion slots or inconsistent Mega Stone inventory states in a single pass. To use it:
- With a save open, go to the Tools menu.
- Select Verify All (or the equivalent bulk-check option in your version’s menu layout).
- PKHeX generates a report listing every flagged slot, along with a short description of the specific rule that failed.
Project Pokémon’s own release notes are explicit that this checker is heuristic, not a guarantee: the changelog states that a Pokémon passing PKHeX’s legality check does not mean it’s safe from server-side detection if it was generated using a method that alters the game’s RNG routine. Treat the legality checker as a tool for catching obvious structural errors in your own legitimately-caught Pokémon — not as proof that an edited Pokémon will be undetectable in any online-connected mode.
Step 7: Transfer a Pokémon Between Save Files
One of the most common uses for PKHeX among emulator users is consolidating a Pokémon collection that’s scattered across different emulator profiles — for example, moving Pokémon caught on a melonDS save of Pokémon White into a Scarlet/Violet save running on a Switch emulator.
- Open your source save file (the one containing the Pokémon you want to move) in one PKHeX window.
- Open a second instance of PKHeX and load your destination save file.
- In the source window, right-click the Pokémon and choose Copy (or drag-and-drop the slot directly onto the second PKHeX window if both are visible on screen).
- In the destination window, right-click an empty box slot and choose Paste.
- PKHeX automatically checks generation compatibility. If the Pokémon’s origin game predates what the destination generation can legally hold (for example, a Gen 3-exclusive move on a Pokémon being moved to Gen 9), PKHeX will flag it and, in many cases, offer to run it through its transfer/conversion logic.
- Save the destination file with File → Save, then close both windows.
- Copy the saved file back to the emulator’s save folder, overwriting the old save (with your backup from Step 2 kept intact).
Cross-generation transfers follow the same logic as the real Pokémon Home/Bank transfer restrictions — a Pokémon that couldn’t legitimately move from Sword/Shield to Scarlet/Violet in-game generally can’t be forced through PKHeX either without triggering a legality flag, since the tool models the same transfer rules Game Freak enforces.
Step 8: Edit Trainer Info and Bag Items
The Trainer Info tab lets you view and adjust your in-game trainer name, ID number, badges, and playtime. The Bag/Items tab shows every item category — Poké Balls, medicine, TMs/TRs, key items, and berries — as an editable list with quantity fields.
# Typical PKHeX Trainer Info fields you can inspect/edit
Trainer Name: ASH
Trainer ID: 12345
Secret ID: 54321
Money: 999999
Badges: 8/8
Play Time: 142:07:33Item quantity fields are capped by PKHeX to the maximum the game engine allows (usually 999 per stack), so entering a number above that ceiling will either get clamped automatically or flagged by the legality checker depending on the item category.
Step 9: Save and Reload in Your Emulator
- In PKHeX, go to File → Save (not “Save As,” unless you specifically want a new filename — most emulators expect the exact original filename to auto-detect the save).
- Close PKHeX completely before launching your emulator, to avoid any file lock conflicts.
- Launch the emulator and load the game. If the emulator caches save data in memory from a previous session, do a full restart of the emulator rather than just closing and reopening the ROM.
- Load your in-game save slot and confirm your edits appear correctly — check the box you edited, or the trainer info you changed.
If the emulator shows a corrupted-save error or resets to a blank save, stop immediately, restore your Step 2 backup, and check the troubleshooting section below before trying again.
Step 10: Batch Editing for Large Collections
For anyone managing hundreds of Pokémon across boxes, PKHeX includes a Batch Editor accessible from the Tools menu. It runs script-style commands across multiple slots at once instead of requiring manual clicks per Pokémon.
# Example PKHeX Batch Editor script
# Sets every Pokémon in Box 1 to level 100 and clears their friendship-based moves
.Box=0
.Level=100
.CurrentFriendship=255Batch scripts are powerful but unforgiving — a mistyped filter can apply changes to your entire save instead of a single box. Always run a batch edit on a copy of your save first, verify the result, then apply it to the real file.
Common Pitfalls
These are the mistakes that come up most often for people using PKHeX with emulators for the first time.
- Editing a save state instead of a save file. PKHeX cannot open
.state,.ss0, or similar snapshot files. If your file won’t open, confirm you grabbed the actual battery/flash save, not a quick-save snapshot. - Skipping the backup step. A failed batch edit or an unexpected legality-forced correction can alter more of the save than intended. Without a backup, there’s no way back.
- Mismatched .NET runtime. Running a build that needs .NET 9 while only .NET 8 is installed causes an immediate crash on launch with no useful error message in some Windows configurations.
- Editing the wrong copy of the save file. If a save is synced through cloud storage or duplicated across folders, it’s easy to edit a stale copy and wonder why changes don’t appear in-game.
- Forcing illegal cross-generation moves. Attempting to push a Pokémon holding a move or item it can’t legally have in the destination generation will get flagged, and forcing it past the checker anyway risks a save the game itself refuses to load correctly.
- Assuming a passed legality check means “undetectable online.” As PKHeX’s own release notes state, RNG-altering generation methods can be detectable server-side even when the local legality checker shows no errors.
- Leaving the emulator open while editing the save externally. Some emulators cache save data and will silently overwrite your PKHeX edits with the old in-memory version when the ROM is next saved in-game.
Complete Working Project: Consolidating a Multi-Emulator Pokédex
Here’s a full end-to-end example: consolidating Pokémon caught across a DS emulator save and a 3DS emulator save into a single Scarlet/Violet save running on a Switch emulator.
- Gather saves. Pull the raw save from melonDS (DS title), Azahar (3DS title, using its “Open Save Data Location” shortcut), and export the Switch save folder from your Switch emulator’s save manager.
- Back up all three into a dated folder before opening anything.
- Open the DS save in one PKHeX window, identify Pokémon you want to move, and copy them.
- Open the destination Scarlet/Violet save in a second PKHeX window and paste the copied Pokémon into open box slots. PKHeX will run its transfer conversion automatically, since DS-generation Pokémon can’t be pasted directly into a Gen 9 save without conversion.
- Repeat with the 3DS save, opening it in place of the DS window and pasting more Pokémon into the destination file.
- Run Verify All on the destination save to catch any flagged slots from the transfer process.
- Fix any flagged Pokémon individually using the Legality Report to see the specific failing rule.
- Save the destination file and copy it back into your Switch emulator’s save directory, replacing the exported folder structure per your emulator’s import process.
- Reload the emulator and confirm the consolidated Pokédex appears correctly in-game.
This workflow mirrors what Pokémon Home does for cross-generation transfers on real hardware, just performed manually through save files instead of a cloud service — useful for anyone running an emulator-only setup without console access.
Sample Output: What a Clean Legality Report Looks Like
Legality Report — Box 1, Slot 3
Species: Charizard
Result: VALID
- Met Location: Route 2 (Paldea) — matches origin game
- Ability: Solar Power — legal for this encounter type
- Moves: Flamethrower, Dragon Claw, Roost, Air Slash — all legal for level 58
- IVs within legal range (0-31 per stat)
- Ball: Poké Ball — consistent with wild encounter
Overall: No legality issues found.Compare that against a flagged result, which typically points to the exact rule that failed rather than a vague error:
Legality Report — Box 1, Slot 4
Species: Charizard
Result: INVALID
- Move "Dragon Dance" is not legal for this species/level/game combination
- Suggested fix: Remove move or verify origin game supports this move via TM/tutorTroubleshooting
Below are the issues most commonly reported when combining PKHeX with emulator saves, and how to resolve each one.
- PKHeX won’t launch / crashes immediately: Reinstall the correct .NET Desktop Runtime version matching your PKHeX build (check the release notes on the download page for the exact version required).
- “Not a valid save file” error: You likely opened a save state, a ROM file, or a corrupted/truncated copy. Re-export the save directly from the emulator’s save folder.
- Emulator won’t load the edited save: Confirm the file size didn’t change unexpectedly — PKHeX should preserve the original save’s byte size and checksum structure. If it changed, restore your backup and retry the edit more conservatively.
- Edits disappear after reloading the emulator: The emulator may have cached the old save in memory. Fully close and restart the emulator application rather than just closing the game window.
- 3DS save won’t open — “unsupported format”: Azahar’s save file needs to be the “main” file itself, not the containing folder. Confirm you selected the actual save file inside the title’s data directory.
- Switch save import fails: Different emulators structure exported Switch saves differently (some as a folder, some as a zipped archive). Check your specific emulator’s save-import documentation for the exact format PKHeX or the emulator’s importer expects.
- Legality checker flags a Pokémon you’re sure is legitimate: This can happen with older DS/GBA-generation Pokémon transferred forward, since transfer rules changed between generations. Check the specific flagged rule in the Legality Report rather than assuming it’s a false positive.
- Batch Editor applied changes to the wrong slots: Restore from your pre-batch backup immediately. Always test batch scripts on a duplicate save file before running them on your primary save.
- Windows SmartScreen blocks the download: This is expected for unsigned open-source binaries. Verify you downloaded from the official GitHub releases page or Project Pokémon’s file archive before proceeding past the warning.
Advanced Tips
Once the basics are working, a few advanced techniques make PKHeX considerably more useful for a real emulator collection:
- Use the PKHeX.Core library for automation. The PKHeX.Core NuGet package exposes the same save-parsing logic the desktop app uses, letting developers build custom scripts or integrations rather than relying solely on the GUI.
- Export individual Pokémon as
.pkfiles. Right-click any box slot and export it as a standalone file (the extension matches the generation, e.g..pk9for Gen 9). This lets you build a personal library of specific Pokémon to drop into any future save without needing the full original save file. - Cross-reference flagged Pokémon against Project Pokémon’s event database. Some legitimately event-distributed Pokémon get flagged by generic legality logic because their origin data is unusual; checking the official event archive can confirm whether a flag is a false positive.
- Keep separate PKHeX installs per major version if testing across generations. Since requirements shift between .NET versions release to release, keeping a stable known-working build archived separately avoids breaking your workflow when a new version changes runtime requirements.
- Pair PKHeX with your emulator’s built-in save-state slots for safer experimentation. Take an in-emulator save state immediately before importing a PKHeX-edited save, so if something looks wrong in-game you can roll back instantly without touching the save file itself.
Understanding the .pk File Format and Generation Codes
Beyond full save files, PKHeX also works with single-Pokémon export files, and understanding this format makes the rest of the tool easier to reason about. Every individual Pokémon exported from a box carries a generation-specific extension — .pk1 and .pk2 for the Game Boy era, .pk3 for Ruby/Sapphire/Emerald and FireRed/LeafGreen, .pk4 for Diamond/Pearl/Platinum and HeartGold/SoulSilver, .pk5 for Black/White, .pk6 for X/Y and Omega Ruby/Alpha Sapphire, .pk7 for Sun/Moon and Ultra Sun/Ultra Moon, .pk8 for Sword/Shield and Brilliant Diamond/Shining Pearl, and .pk9 for Scarlet/Violet and Legends: Z-A.
These files matter for two reasons. First, they let you build a personal archive of specific Pokémon outside of any single save file — useful if you want to keep a “vault” of favorites you can drop into a fresh save without hunting through old backups. Second, PKHeX uses the generation encoded in the file extension to decide what conversion logic applies when you paste that Pokémon into a save from a different generation, which is why a .pk3 file dropped into a Gen 9 save triggers automatic legality conversion rather than a flat rejection.
To export a single Pokémon, right-click any box slot and choose Export PKM, then choose a save location. To reimport, drag the .pk file directly onto an open box slot in a loaded save, or use right-click → Import PKM on an empty slot. Both operations run the same legality checks that apply to full-save pasting, so a flagged import behaves identically to a flagged in-save transfer.
Working with RetroArch Save Files for Pokémon Cores
A meaningful share of Pokémon emulation in 2026 happens through RetroArch’s libretro cores rather than standalone emulators, particularly for GBA titles run through the mGBA core or DS titles run through the melonDS DS core. RetroArch’s save handling adds one extra wrinkle worth covering separately, since its folder structure differs from a standalone emulator installation.
By default, RetroArch stores battery saves in a central saves directory rather than next to the ROM, unless you’ve enabled “sort saves into folders by core” in RetroArch’s saving settings. The save file itself uses the same .srm extension across most cores, which is functionally equivalent to a .sav file for PKHeX’s purposes but is worth renaming to .sav before opening it in PKHeX if the program doesn’t recognize the extension on your build.
- Open RetroArch’s Settings → Directory menu and note the path listed under “Savefile.”
- Locate the
.srmfile matching your ROM’s filename inside that directory. - Copy it out to your working folder and rename the extension to
.savif PKHeX doesn’t detect it automatically. - Edit as normal, then reverse the process — rename back to
.srmif needed and copy the edited file back into RetroArch’s save directory, overwriting the original.
Readers running Pokémon specifically through RetroArch’s core system should also check our dedicated RetroArch setup guide for Pokémon, which covers core selection and configuration in more depth than this save-editing tutorial needs to.
PKHeX Compared to Other Save-Handling Approaches
PKHeX isn’t the only way to move Pokémon between saves, but it’s the only tool offering deep, cross-generation legality checking alongside full editing. The table below shows how it compares to the alternatives available to emulator users.
| Method | Cross-generation support | Legality checking | Cost | Best for |
|---|---|---|---|---|
| PKHeX | Yes, Gen 1 through Gen 9a | Built-in, per-Pokémon and bulk | Free, open-source | Deep editing and multi-emulator consolidation |
| Emulator built-in save manager | No (single save format only) | None | Free (bundled) | Basic export/import within the same emulator |
| Pokémon Home (official) | Yes, on real hardware/cartridges | Enforced by Nintendo servers | Free tier + paid subscription | Legitimate transfers on real consoles |
| Homebrew save managers (Switch) | No (extraction only) | None | Free | Pulling raw save data off homebrew-enabled hardware |
For readers building out a full Pokémon emulation setup rather than just editing existing saves, our guides on DeSmuME for Pokémon DS games and Eden emulator setup for Pokémon Switch titles cover the emulator side end to end, while our roundup of the best Pokémon emulators compares platform coverage across every generation.
Is Using PKHeX Safe?
PKHeX itself is safe software when downloaded from official sources — it’s open-source, actively maintained, and doesn’t inject anything into a running game process. The risk isn’t the tool; it’s how edits interact with online-connected features. Editing offline saves for personal single-player use, box organization, or fixing a corrupted save carries essentially no risk. Using edited Pokémon in online trading, ranked battles, or any Nintendo-server-connected mode carries the same risk any modified save data carries on real hardware — potential detection and enforcement action tied to that specific online account, not to the emulator or PKHeX itself.
Since most emulator setups in 2026 are inherently offline (no real Nintendo Network or Switch online account tied to pirated or homebrew game copies in most configurations), this is less of a practical concern for pure emulation use than it is for people using PKHeX alongside a legitimate, online-connected cartridge or console save. Keep that distinction in mind based on your own setup.
Keeping PKHeX Updated Without Breaking Your Workflow
PKHeX ships updates frequently — sometimes weekly during periods of active game support, as seen with the run of releases covering Legends: Z-A support from late 2025 through 2026, including the 26.05.05 build on May 5 and 26.08.26 on August 26, the release this guide references as of September 2026. Each update can shift two things that affect an existing setup: the required .NET runtime version, and the internal handling of specific save structures for the newest game.
A practical update routine looks like this: before installing a new PKHeX build, check the release notes on the Project Pokémon news page for a line indicating a runtime change (these are called out explicitly, as they were for the .NET 8 and .NET 9 transitions). If the runtime changed, install the matching Desktop Runtime before launching the new build rather than after — launching first just produces a crash you then have to diagnose. If you’re mid-project consolidating saves across multiple emulators, finish that batch of transfers on your current version before updating, since a version change mid-workflow makes it harder to tell whether an unexpected legality flag is a genuine issue or a side effect of updated checking logic.
It’s also worth keeping the previous PKHeX build’s ZIP file archived rather than deleting it after updating. If a new release introduces a regression for your specific generation or save type — which does happen occasionally with fast-moving open-source tools supporting a newly released game — reverting to the last known-good build takes seconds if you kept the archive, versus re-downloading and hoping GitHub still hosts the older release asset.
Frequently Asked Questions
What file types does PKHeX support?
PKHeX opens raw save files across every mainline generation, from Gen 1-2 battery saves through GBA and DS .sav files, 3DS main save files, GameCube .raw/.gci saves for Colosseum and XD, and Switch save containers for titles through Scarlet/Violet and Legends: Z-A. It does not open emulator save states.
Do I need a different PKHeX version for each Pokémon generation?
No. A single current PKHeX release handles all supported generations at once — the program auto-detects the game from the save file’s structure when you open it, so there’s no need to switch versions between, say, editing a Gen 4 save and a Gen 9 save.
Can PKHeX corrupt my save file?
It’s rare when using the standard editing tools as intended, but aggressive batch edits or forcing clearly illegal data into a save can produce a file your emulator refuses to load. This is why backing up the original save before any edit session is the single most important habit in this guide.
Why does PKHeX need .NET installed separately?
PKHeX is built on Microsoft’s .NET framework rather than being a fully self-contained executable, which keeps the download small but means the matching .NET Desktop Runtime has to be installed on your system separately. The exact version required (.NET 8, .NET 9, and eventually .NET 10) changes as PKHeX updates its underlying framework.
Does PKHeX work on Mac or Linux?
The official desktop build is Windows-only. Mac and Linux users typically run it through Wine or a Windows virtual machine, since there’s no native macOS or Linux desktop release of the PKHeX GUI itself.
Is it legal to use PKHeX?
PKHeX itself is legal open-source software with no copyrighted game assets bundled in it — it’s a save file parser and editor, comparable to any save editor for other game franchises. What you do with edited saves in online-connected modes is a separate consideration covered by each game’s terms of service, not by anything related to PKHeX’s legality as software.
Can I use PKHeX to move Pokémon from a physical cartridge save into an emulator?
Yes, provided you can extract the raw save data from the cartridge or console first (typically through a compatible flashcart or homebrew save-dumping tool for the source hardware). Once you have the raw save file, PKHeX treats it identically to an emulator-generated save.
What’s the difference between the legality checker and Verify All?
The Legality Report checks one Pokémon at a time and explains exactly which rule failed. Verify All, added in the 25.10.26 release, runs that same check across every Pokémon and relevant save structure (including fusion slots and item inventory states) in a single pass, which is faster for auditing a large collection after a bulk transfer.
Related Coverage
- Pokémon Stadium ROM Setup on PC: 13 Steps, 90 Min [2026]
- Set Up Pokémon Emulators on Steam Deck: 13 Steps [2026]
- How to Set Up DeSmuME for Pokémon DS Games: 12 Steps [2026]
- Pokémon Randomizer + BizHawk: 10 Steps, 90 Min [2026]
- How to Set Up RomM: Self-Host 400+ Systems in 12 Steps [2026]
