How to Use PKHeX: Edit Pokémon Saves in 10 Steps [2026]

Last updated 18 October 2026.

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. With version 26.08.26, released August 26, 2026, PKHeX covers Pokémon games from Generation 1 through Generation 9 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. With PKHeX’s download count passing 13.5 million by September 20, 2026 and still climbing into October, this guide reflects the workflow used by the vast majority of the Pokémon emulation community today.

·

Google · Preferred Sources

Don't miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

Add Now

What PKHeX Actually Does (and What It Doesn’t)

Save File Editing vs. Save States

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.

Legality Checking Has Its Limits

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.

System and Runtime Requirements

• 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 10 Desktop Runtime for the current release track, with current builds compiled using C# 14. PKHeX moved from .NET 7 to .NET 8 with version 23.12.18, then to .NET 9 with the 25.10.26 release, and on to .NET 10 during 2026 — confirmed as the live requirement in an October 16, 2026 Hysen Labs guide to the editor.
• Disk space: Under 50 MB for PKHeX itself; the download package is approximately 26.2 MB.

Emulator and Backup Checklist

• 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

Where to Download 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.

1. Go to the GitHub releases page for the PKHeX repository and download the latest PKHeX_win_[version].zip asset.
2. 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.

Installing and Launching PKHeX for the First Time

3. If you don’t already have the required runtime, download the .NET 10 Desktop Runtime from Microsoft’s official .NET download page. Select the “Desktop Runtime” installer, not the ASP.NET or SDK variant.
4. 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

3DS Saves: Finding the File in Azahar

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.

Switch Saves: Using the Built-In Export Tool

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

1. Launch PKHeX.exe.
2. Go to File → Open, or simply drag the save file directly onto the PKHeX window.
3. 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.”
4. 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 event block and fashion block editors added in the 25.10.26 release, which the 26.01.31 build in January 2026 followed with Gen9a support for 9,999 Mega Shards.

Step 5: Navigate the Box Viewer and Party Editor

What’s Inside the Box Viewer

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 Editing Uses

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

Reading a Legality Report

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.

Running Verify All on an Entire Save

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. GitHub’s notes for the 26.01.31 build (January 2026) then added Swampertite legality support and fixed Showdown IV/EV parsing in nonstandard order. To use Verify All:

1. With a save open, go to the Tools menu.
2. Select Verify All (or the equivalent bulk-check option in your version’s menu layout).
3. 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

Copying a Pokémon Between Two PKHeX Windows

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.

1. Open your source save file (the one containing the Pokémon you want to move) in one PKHeX window.
2. Open a second instance of PKHeX and load your destination save file.
3. 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).
4. In the destination window, right-click an empty box slot and choose Paste.
5. 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.
6. Save the destination file with File → Save, then close both windows.
7. 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 Transfer Rules

Cross-generation transfers follow the same logic as the real Pokémon HOME 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. Pokémon Bank is scheduled to shut down on February 25, 2027, which will end transfers from Bank to Pokémon HOME.

Step 8: Edit Trainer Info and Bag Items

Editing Trainer Info

The Trainer Info tab lets you view and adjust your in-game trainer name, ID number, badges, and playtime.

# 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:33

Editing Bag Items and Quantities

The Bag/Items tab shows every item category, Poké Balls, medicine, TMs/TRs, key items, and berries, as an editable list with quantity fields.

Item 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

1. In PKHeX, go to File → Export SAV → Export main to write your edits back to the save (or the quicker File → Save, which overwrites the same filename most emulators expect to auto-detect the save). Project Pokémon’s own October 5, 2026 coverage of PKHeX walked through this identical open-edit-export sequence independently, corroborating it as the standard way to get edits back into a save file.
2. Close PKHeX completely before launching your emulator, to avoid any file lock conflicts.
3. 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.
4. 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

Writing a Batch Editor Script

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=255

Batch 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.

Undo, Redo, and Safer Batch Edits

PKHeX 26.08.26 introduced Batch Editor undo/redo in August 2026, and GitHub’s release notes for that build, updated October 8, 2026, describe the real safety nets it adds to the Batch Editor: undo/redo support, so a bad filter no longer means reaching for your backup as the only fix, plus a count of affected slots shown before you commit a script, confirming whether you’re about to touch 30 Pokémon in Box 1 or your entire save. Reset/apply handling was also cleaned up, making it faster to clear a script and start over. None of this replaces backing up your save first, but it does shrink the cost of a mistyped filter.

Common Pitfalls

These are the mistakes that come up most often for people using PKHeX with emulators for the first time.

Before You Start: Setup Mistakes

• 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 10 while only .NET 9 is installed causes an immediate crash on launch with no useful error message in some Windows configurations.

While Editing: Save and Legality Mistakes

• 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.

1. 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.
2. Back up all three into a dated folder before opening anything.
3. Open the DS save in one PKHeX window, identify Pokémon you want to move, and copy them.
4. 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.
5. Repeat with the 3DS save, opening it in place of the DS window and pasting more Pokémon into the destination file.
6. Run Verify All on the destination save to catch any flagged slots from the transfer process.
7. Fix any flagged Pokémon individually using the Legality Report to see the specific failing rule.
8. 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.
9. 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/tutor

Troubleshooting

Below are the issues most commonly reported when combining PKHeX with emulator saves, and how to resolve each one.

Installation and Launch Problems

• 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).
• 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.

Save File and Emulator Problems

• “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 and Batch Editor Problems

• 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, the Batch Editor’s undo/redo feature (added in the 26.08.26 release notes updated October 8, 2026) can also roll back the last script if you catch the mistake right away.

Advanced Tips

Once the basics are working, a few advanced techniques make PKHeX considerably more useful for a real emulator collection:

Power-User Techniques

• 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 .pk files. Right-click any box slot and export it as a standalone file (the extension matches the generation, e.g. .pk9 for 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

Generation-Specific File Extensions

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.

Exporting and Importing Individual Pokémon

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.

Exporting and Renaming the Save File

1. Open RetroArch’s Settings → Directory menu and note the path listed under “Savefile.”
2. Locate the .srm file matching your ROM’s filename inside that directory.
3. Copy it out to your working folder and rename the extension to .sav if PKHeX doesn’t detect it automatically.
4. Edit as normal, then reverse the process, rename back to .srm if 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.

Comparing the Options at a Glance

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

A Safe Update Routine

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.01.31 build in January 2026, 26.04.11 in April 2026 (covered by PokémonHex alongside Pokémon HOME’s Z-A transfer update), the 26.05.05 build on May 5, and 26.08.26 on August 26 (which Project Pokémon released on August 27, 2026, and GameBrew also records as August 26, 2026), the current release. 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, .NET 9, and .NET 10 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.

Archiving Known-Good Builds

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.

The newest upstream release is 26.08.26, released on August 26, 2026, with Batch Editor undo/redo among its changes. A separate project, PKHeX.Everywhere, posted an engine release on October 20, 2026, but that is not a new PKHeX desktop build.

That caution is worth it given PKHeX’s reach, by September 20, 2026 the 26.08.26 build alone had logged over 13.5 million downloads on the Project Pokémon leaderboard, reinforcing its place as the primary save editor for Pokémon players moving data between generations and emulators.

What the 26.08.26 Build Means for Your Setup

The PKHeX download page offers v26.08.26 as a .zip, tagged 26.08.26 on GitHub at commit 74b8890. Its highlights include Legends: Z-A encounter and transfer data, expanded Gen 2–5 recursive Egg Move legality checks, Batch Editor undo/redo, and several older-generation editors. If you last used PKHeX before this release, expect those changes to show up in your legality reports and in how you run the batch scripts described earlier in this guide.

The same release migrated PKHeX to the .NET 10 Desktop Runtime on August 26, 2026. The PKHeX download information states that PKHeX 26.08.26 requires Microsoft .NET Desktop Runtime 10.0 to execute properly on Windows, and that if the program does not open, you should download the .NET 10 Runtime directly from Microsoft. Microsoft’s download page confirms active servicing for .NET 8, 9, and 10 alongside a .NET 11 release candidate, so install the 10.0 Desktop Runtime and leave the release candidate alone.

Be careful with similarly named projects when you search for updates. The PKHeX.Everywhere engine 0.27.0 release on October 20, 2026 is a separate project, not proof of a new PKHeX desktop release. Before assuming a newer official build exists, check the kwsch/PKHeX GitHub page or Project Pokémon, and keep your previous ZIP archived as described above until the new build has handled your saves cleanly.

Latest PKHeX Updates and Release History

PKHeX’s release cadence has stayed active all year, and several changes are worth knowing about even if this guide’s core step-by-step workflow still applies to the current build. Here’s what’s shipped recently, in chronological order.

• July 7, 2026, PKHeX 26.07.07 refines diagnostics and item handling. This release focused on practical usability: improved legality checks, a new Pokéathlon editor for HeartGold/SoulSilver, hexadecimal clipboard import, and plugin-information tools, alongside stronger diagnostics for damaged saves and more polished settings behavior, making it easier to catch corrupted or invalid data while editing inventories and party boxes without breaking a save mid-tutorial.
• August 26–27, 2026, PKHeX 26.08.26 adds recursive Egg Move checks and broader save support. The update introduced recursive Egg Move inheritance checks for Generations 2–5, relevant to anyone consolidating older saves, including collections built with tools like our SameBoy setup guide for Pokémon Gold, Silver, Crystal, plus improved Generation 4 encounter and Egg generation handling, new legality rules for Generation 5 Global Link promotions and Mystery Gifts, My Pokémon Ranch IV reversal, faster RNG reversal and lattice recovery, Pokémon Stadium 2 save handling, Pokémon Battle Revolution fixes, and Legends: Z-A encounter crossover data. SaveFinder also added cancellation and smarter drive detection to avoid hangs, useful for readers trading Pokémon between emulators without a link cable at scale.
• August 30–31, 2026, PKHeX-NX v0.9.3 brings drag-and-drop editing to Switch homebrew. This public beta shipped a bundled drag-and-drop install ZIP with the app and data assets included, so homebrew-enabled Nintendo Switch systems can run PKHeX-style editing without a separate PC build, the same on-device convenience readers get from our Folium setup guide for Pokémon 3DS games on iPhone.
• August 31, 2026, Arch Linux’s pkhex-bin package adds auto-updating and .NET fixes. The package was updated to version 26.08.26-2 with a launcher script that automatically fetches the latest PKHeX release, plus fixes for several .NET-related errors, reducing friction for Linux users who keep PKHeX current alongside other self-hosted emulation tooling like RomM.
• September 20, 2026, PKHeX passes 13.5 million downloads. The 26.08.26 build was listed with 13,521,377 downloads on the Project Pokémon leaderboard, confirming PKHeX’s position as the standard save editor across every mainline generation from the Game Boy era through Scarlet/Violet and Legends: Z-A.
• October 8, 2026, GitHub release notes refine the Batch Editor. Updated release notes for 26.08.26 detailed further Batch Editor improvements: undo/redo support, a count of affected slots shown before a script is applied, and improved reset/apply handling, walked through in the batch editing section above.
• October 17, 2026, Generation Amiga spotlights PKHeX 26.07.07’s editing upgrades. The outlet’s coverage of that release reinforced the improved legality checks and damaged-save diagnostics noted above, while also calling out expanded Generation 4 and 5 editing support, item sprites, and an experience-bar indicator in the Pokémon editor view, rounding out the picture of what 26.07.07 changed before 26.08.26 followed it.

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 required version has moved from .NET 8 to .NET 9 and, as of October 2026, to .NET 10 with builds compiled using C# 14, changing 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. On 3DS hardware, homebrew tools like Checkpoint or JKSM export a decrypted save that PKHeX can open directly; Switch owners have similar options in tools like save_manager or SaveDataFiler. Once you have that raw, decrypted 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.