Nintendo shut the doors on 3DS eShop purchases years ago, and secondhand 3DS consoles now sell for more than some used iPhones. That price squeeze is why Folium, a paid App Store emulator built by independent developer Jarrod Norwell, has become the go-to way for iPhone owners to replay Pokémon X, Y, Omega Ruby, Alpha Sapphire, Sun, Moon, Ultra Sun, and Ultra Moon without digging out an aging handheld. Unlike Citra, which never had an official iOS release and depended on jailbreaks or shaky sideloading tools, Folium ships straight from Apple’s App Store. That single fact changes almost everything about how you set it up.
This tutorial walks through the full process: buying and installing Folium, pulling the system files your own 3DS console has to provide, dumping your own Pokémon cartridges or eShop titles, importing them into the app, pairing a controller, tuning performance per game, and backing up your saves. As of October 2026, these are still the exact steps Folium’s setup screen asks for, including the audio and frame rate hiccups that show up most on Sun/Moon-generation titles. Budget about 90 minutes for a first-time setup, most of which goes toward the one-time key extraction from your 3DS hardware.
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 Folium Is and Why It Beats Sideloaded 3DS Emulators
Folium is a multi-system emulator that has grown well past its original Game Boy Advance and Nintendo DS lineup. An October 14, 2026 App Store listing review from MWM describes Folium as also covering PlayStation 1 and Sega Genesis titles alongside its Nintendo 3DS emulation, on top of the GBA and DS support it shipped with originally. It’s distributed as a paid app, with the U.S. App Store listing it at $2.99 and Japan’s App Store listing it at ¥500, directly through Apple’s storefront. It added 3DS support in what its developer described as its biggest update, and it has kept shipping updates well past that: Japan’s App Store shows the build at version 1.38 as of July 2026, and Folium’s iPhone listing now requires iOS 16.0 or later to install.
Why Apple’s 2024 Policy Shift Matters
The reason this matters for Pokémon fans specifically: Apple changed its App Store review guidelines in April 2024 to explicitly allow “retro game console emulator apps” for the first time, per Apple’s App Store Review Guidelines. That policy shift is what let developers like Norwell publish emulators like Folium and RetroArch without relying on enterprise certificates that Apple could revoke overnight — a chronic problem for sideloaded apps distributed through AltStore, SideStore, or TrollStore. Because Folium lives inside the normal App Store, it isn’t exposed to the certificate revocation waves that have periodically killed sideloaded emulators for days at a time. You install it, keep it updated through the App Store like any other app, and never touch a developer certificate.
Citra Is Dead — What Fills the Gap
Citra, by contrast, is dead as an actively maintained project — its original team stopped development in 2024, and no official Citra build ever reached the iOS App Store. Anyone running Citra on iPhone in 2026 is using an old jailbreak build or an unofficial fork, neither of which gets security patches. Newer entrants like Panda3DS and its continuation Mandarine push better raw performance in some reports, but they’re distributed outside the App Store and inherit the same sideloading fragility Folium was built to avoid.
Folium’s Own Update History
Folium’s own scope has grown incrementally rather than all at once. It started as a Game Boy Advance and Nintendo DS player, added 3DS emulation later as its headline feature update, and has kept shipping smaller refinements since — version 1.17, which showed up on Australia’s App Store in February 2025, added a new 3DS middle-man screen to smooth over game selection, and version 1.30 followed on the U.K. App Store by March 2025 with further layout adjustments aimed at iOS 16’s newer UI conventions, part of a steady cadence of compatibility patches that don’t always get a public changelog beyond the App Store’s own version notes. Because it’s a one-person project rather than a large open-source effort with a public issue tracker, the pace of fixes for any specific Pokémon title can be uneven — some bugs get patched in weeks, others linger for months. That’s the trade-off for the stability of App Store distribution: you get an emulator that survives iOS updates without breaking, but you’re dependent on a single developer’s release cadence rather than a community of contributors.
The Cytrus Core and Folium’s Growing System List
Folium’s Nintendo 3DS and New Nintendo 3DS emulation runs on a component the developer calls the Cytrus core, according to iTechGuides’ hands-on testing published October 12, 2026. That same testing reconfirms the $2.99 U.S. price and the iOS 16.0 install floor still held as of that date. Cytrus is the specific part of Folium that handles 3DS-format game emulation, separate from the internals Folium uses for its Game Boy Advance and Nintendo DS support, which is one reason a 3DS-specific hiccup, like the audio crackling covered later in this guide’s performance section, doesn’t necessarily say anything about how well a DS or GBA title runs in the same app.
That Cytrus core explicitly covers both standard Nintendo 3DS hardware and the New Nintendo 3DS or New 3DS XL, per iTechGuides. That hardware split matters directly for the New3DS-exclusive titles and Circle Pad Pro support this guide calls out in the prerequisites table and controller section. Knowing the core supports both officially, rather than treating New 3DS compatibility as an unofficial side effect, is useful context if a New3DS-exclusive Pokémon spin-off behaves differently than a standard-3DS mainline title on your specific console dump.
The practical upshot of Folium’s wider system list, now Game Boy Advance, Nintendo DS, Nintendo 3DS, PlayStation 1, and Sega Genesis as of October 2026, is that it’s become less of a single-purpose 3DS tool and more of a general retro console library. That’s convenient if you’re consolidating several consoles’ worth of legally owned backups into one app. It also means Folium’s App Store updates now have to account for compatibility across five separate hardware lineages rather than one, which is worth remembering if a future point release changes 3DS behavior while fixing something unrelated on its PlayStation 1 or Genesis side.
Prerequisites: What You Need Before You Start
Gather everything below before you open the App Store. The single biggest time sink in this whole process is not installing Folium — it’s the one-time trip to your own Nintendo 3DS console to pull the files Folium legally requires you to supply yourself.
The Full Checklist
| Requirement | Minimum | Recommended for Pokémon 3DS titles |
|---|---|---|
| iPhone / iPad | Any device on iOS 16.0+ | iPhone 11 or newer (A13 Bionic or later) |
| iOS / iPadOS version | iOS 16.0 (iPhone) / iPadOS 16.0 (iPad) | iOS 16.0 or later, kept fully updated |
| Free storage | 4 GB | 10+ GB if you plan to keep several 3DS ROM dumps |
| Your own Nintendo 3DS console | Required — used once, to extract keys | New 3DS or New 3DS XL for New3DS-exclusive titles |
| Legally owned Pokémon cartridges or eShop licenses | At least one | Physical carts you can insert into the 3DS for dumping |
| Computer (Windows, macOS, or Linux) | Optional but recommended | Speeds up transferring files to iPhone via cable or AirDrop |
| PlayStation, Xbox, or MFi controller | Optional | Recommended for anything beyond casual menu navigation |
Don’t skip the “computer” line in that table just because it says optional. In practice, extracting files from a 3DS SD card, renaming them sensibly, and batching them for transfer is dramatically easier with a full-size file browser than by shuffling files around inside iOS’s Files app on a phone screen. If you only have an iPad, that works fine too — the process is identical, just with more screen real estate to work with.
A Note on Legality
A note on legality before you go further: emulation software itself is legal in most countries, and courts in the US have generally upheld the right to make backup copies of games you own. What’s not legal is downloading ROMs you don’t own from the internet, or distributing dumps of games or system firmware to other people. Every step in this guide assumes you’re dumping files from a 3DS console and cartridges you personally own, for personal use. The Electronic Frontier Foundation’s reverse-engineering FAQ is a good primer on where those lines sit in US law, and Nintendo’s own statement on illegal copying and distribution makes clear where the company itself draws that line — it targets sharing and downloading, not personal backups of hardware you own.
Step 1: Confirm Your iPhone Can Actually Run 3DS Games Well
3DS emulation is far heavier than the Game Boy Advance or DS emulation Folium also supports, because you’re asking a phone chip to reproduce two ARM11 cores, a dedicated PICA200 GPU, and the 3D stereoscopic rendering pipeline Nintendo built into the original hardware. Folium runs on any device that meets the iOS 16.0 floor its App Store listing now requires, but “runs” and “runs well” are different claims for 3DS content specifically. An iPhone 11 or newer remains the practical starting point for Pokémon’s 3DS-generation titles heading into October 2026.
Performance by iPhone Generation
| iPhone generation | Chip | Pokémon X/Y, OR/AS | Pokémon Sun/Moon, USUM |
|---|---|---|---|
| iPhone 8 / X (A11 and older) | A11 Bionic or earlier | Frequent slowdowns, playable in short sessions | Not recommended — heavy stutter |
| iPhone 11 series | A13 Bionic | Near full speed most of the time | Playable, with occasional dips in busy areas |
| iPhone 12–14 series | A14–A16 | Full speed in most scenes | Mostly smooth, audio glitches still reported |
| iPhone 15–16 series | A16–A18 | Full speed | Generally smooth, but thermal throttling can occur in long sessions |
What Real-World Testing Shows
Independent testers running Pokémon Moon on Folium have rated its playability around 7 out of 10 with audio quality closer to 5 out of 10, summarizing the experience as “playable if muted.” That lines up with broader community reports: audio crackling and desync show up more often than outright frame rate collapse, and Sun/Moon-generation titles are consistently more demanding than the X/Y-generation games because of their heavier lighting and camera effects. If you’re on an iPhone 8 or older, temper your expectations for anything past Omega Ruby and Alpha Sapphire.
Why Emulation Pushes an iPhone’s Thermal Limits Harder Than Native Games
The thermal throttling noted for the iPhone 15–16 series in the table above isn’t a sign of a poorly optimized app so much as a predictable cost of what emulation actually does under the hood. Folium isn’t running 3DS game code natively — it’s translating ARM11 and PICA200 GPU instructions into something the iPhone’s own ARM64 chip and Metal graphics stack can execute, in real time, every single frame. That translation layer is inherently less efficient than running equivalent native iOS code, which is why a 3DS game with modest-looking visuals by today’s standards can push an iPhone’s chip harder than a native game with far more detailed graphics. The practical effect is that sustained play sessions generate more heat per frame of actual on-screen motion than most other apps on your phone, and heat is what triggers iOS’s own thermal throttling, independent of anything Folium’s developer could tune away entirely. Short, cooler sessions and avoiding direct sunlight — already noted in the troubleshooting table — address the symptom; the translation overhead itself is the underlying cause and isn’t something any App Store emulator fully escapes.
Why Folium’s iOS 16.0 Floor and Import Order Trip Up First-Time Setups
Three details scattered through this guide’s checklist and steps trip up more first-time setups than anything else covered here, and none of them are obvious unless you understand why Folium enforces them. Taken together, they explain most of the “it won’t work” reports that have nothing to do with a corrupted dump or an actual bug in the app.
The iOS 16.0 Floor Is a Hard Gate, Not a Suggestion
Folium’s own App Store listing states plainly that the app “Requires iOS 16.0 or later” on iPhone and iPadOS 16.0 or later on iPad, and that floor is an install-time gate rather than a soft recommendation. Older walkthroughs that still cite iOS 15 as sufficient are describing an earlier build of the app — the current listing simply won’t let the App Store download Folium at all if your installed iOS version sits below 16.0, regardless of how capable your phone’s chip is. That’s a meaningfully different failure mode than a performance ceiling: you find out at the “Get” button, before you’ve spent any time on the console-side work in Step 3 through Step 6.
Why Import Order Isn’t Optional
The second detail is the sequence behind Step 7 and Step 8 later in this guide. Folium’s 2026 setup flow calls for importing boot9.bin, boot11.bin, aes_keys.txt, seeddb.bin, and movable.sed into the app before importing a single Pokémon game dump, and that order isn’t a stylistic suggestion. Folium checks each imported .3ds or .cia file’s encryption headers against the AES key slots already sitting in its library at import time. Feed it a game file before the keys exist and there’s nothing for the app to validate that file against, which is why the most common “Folium won’t recognize my ROM” report traces back to import order rather than a bad dump. Reversing this guide’s sequence — games first, keys second — is the easiest way to turn a clean cartridge dump into a support headache that looks identical to file corruption without actually being corruption.
Reading the iPhone 11 Recommendation Against the Performance Table
The “iPhone 11 or newer” guidance in Step 1 above, repeated in the checklist at the end of this guide, isn’t an arbitrary round number — it lines up with the generational split already visible in the performance table above. An iPhone 8 or X, built around the A11 Bionic, is what that table characterizes as “frequent slowdowns” on X/Y-generation titles and “not recommended” for Sun/Moon-generation ones. Two chip generations later, the iPhone 11’s A13 Bionic is where the same table shifts to “near full speed most of the time.” That gap between the minimum iOS 16.0-compatible hardware and the recommended iPhone 11 baseline is why this guide treats “will it install” and “will it run well” as two separate questions, both worth answering before you spend the better part of 90 minutes dumping keys from a 3DS console. Losing $2.99 on a copy of Folium that runs poorly is a small setback; the console-side key extraction is the real time cost, and it’s only worth starting once your specific iPhone generation lands in the “near full speed” tier rather than the “frequent slowdowns” one.
None of this means Folium got worse — if anything, a hard iOS floor and a validation check on import are signs of an app that’s matured past its early releases. As of October 2026, every one of these three checks is invisible until something fails, which is exactly why they’re worth confirming up front rather than discovering them mid-setup. Checking your iOS version, your iPhone’s chip generation against the table above, and the key-then-games import order before you start is the difference between the roughly 90-minute setup this guide budgets for and a multi-session troubleshooting slog that ends at the same destination anyway.
Step 2: Buy and Install Folium From the App Store
Open the App Store app on your iPhone, search “Folium,” and look for the listing from developer Jarrod Norwell. This is the entire installation process — no jailbreak, no AltStore, no trusting a developer certificate in Settings. Purchase the app, let it download, and open it once to confirm it launches. Pricing shifts a bit by storefront — the U.S. listing sits at $2.99, while Japan’s App Store lists it at ¥500 — and the listing now requires iOS 16.0 or later to install, so check your installed iOS version before you buy if you’re on older hardware. Folium’s own listing is explicit that it does not provide any games or system files — both have to come from you, which is exactly what the rest of this tutorial walks through. If the App Store can’t find Folium in your region’s storefront, check the region setting in your Apple ID; availability can vary by country because of local App Store review policies around emulation software.
What the App Store Page Doesn’t Explain
Folium’s own App Store listing is upfront about scope — it states plainly that it doesn’t ship with any games or system files — but it stops there, and that’s by design: Apple’s listing format is built for pricing, screenshots, and star ratings, not step-by-step setup instructions. What it won’t walk you through is everything between “purchased” and “playing a Pokémon game”: the five-file key dump from your own 3DS, the import order that determines whether Folium recognizes a ROM at all, or which iPhone generation actually renders Sun and Moon-generation titles at a playable frame rate rather than a merely installable one. Reading only the App Store page before buying tells you the price and the iOS 16.0 requirement; it won’t tell you that the console-side work, not the purchase itself, is the real time cost — which is the gap the rest of this tutorial exists to close.
What Happens on First Launch
On first launch, Folium will present an empty library. Don’t worry about the “no games” screen yet — you still need to feed it two things before any Pokémon title will boot: your 3DS system’s decryption keys, and the game dumps themselves. Both come from your own hardware, not from Folium or the App Store.
Step 3: Understand the System Files You’ll Need
3DS emulation across every modern emulator core — Citra-derived projects, Lime3DS, Azahar, and the core Folium uses internally — relies on the same set of Nintendo-copyrighted system files to decrypt commercial game data. You cannot download these from the internet legally; they have to come from a 3DS console you own, using homebrew dumping tools run on that console.
The Five Required System Files
Required 3DS system files:
boot9.bin - ARM9 bootROM (protected, contains decryption keys)
boot11.bin - ARM11 bootROM
aes_keys.txt - Extracted AES key slots, used to decrypt cartridge/eShop data
seeddb.bin - Seed database, needed for newer titles using seed encryption
movable.sed - Console-unique key, needed for some eShop/CIA titlesYou do not need to memorize what each file does mathematically. What matters for this tutorial is that all five files (boot9.bin, boot11.bin, aes_keys.txt, seeddb.bin, and movable.sed) typically get pulled from your 3DS in one homebrew session, and Folium needs them placed where it can read them before it will decrypt anything beyond a game’s title screen.
What Each Key File Actually Does
For readers who want the reasoning rather than just the file list: boot9.bin and boot11.bin are the ARM9 and ARM11 bootROMs built into the 3DS’s processor at the factory. They hold the console’s hardware-level decryption keys, and no official Nintendo software ever exposes them directly — the only way to get a copy is to dump them from a 3DS you physically own, which is exactly why every 3DS emulator, not just Folium, treats this as a required step rather than an optional one. aes_keys.txt is the set of AES key slots that GodMode9 derives using those bootROMs, and it’s the file that actually decrypts a cartridge or eShop title’s data the moment Folium imports it — without it, Folium can see a game’s file structure but can’t read its actual content. seeddb.bin and movable.sed each solve a narrower problem. Nintendo added seed-based encryption on top of the standard AES keys partway through the 3DS’s lifespan, so titles released after that point need the extra per-title seed seeddb.bin supplies, layered on top of the keys already in aes_keys.txt. movable.sed is different again: it’s tied to one specific console’s identity rather than to a game or a firmware era, which is why it’s required for decrypting eShop purchases encrypted against your exact 3DS unit, and why — unlike the other four files — it can’t be reused across two different consoles even if you own both of them.
Understanding 3DS File Formats Before You Dump Anything
Before touching your 3DS, it helps to know what you’re aiming for. 3DS game dumps come in a few different container formats, and which one you end up with depends on whether you’re dumping a physical cartridge or an installed eShop title. Folium can generally work with the common formats, but knowing the difference saves confusion when you’re staring at a folder of files with unfamiliar extensions.
Common 3DS File Extensions
.3ds / .cci - Raw cartridge dump format (used for physical Pokémon carts)
.cia - Installable package format (used for eShop titles, some fan patches)
.cxi - Executable content inside a CIA, rarely handled directly by users
.3dsx - Homebrew application format, not used for commercial Pokémon gamesFor most readers following this tutorial with physical Pokémon cartridges, you’ll end up with .3ds or .cci files. If you’re pulling an eShop purchase off your console’s NAND instead, you’ll get a .cia file. Both are legitimate inputs for Folium once your key files are in place — there’s no need to convert between them for typical use.
Step 4: Dump Your Keys Using GodMode9 on Your Own 3DS
Getting Into GodMode9
GodMode9 is the standard homebrew file-management tool the 3DS scene has used for years to read and write low-level system data, and it’s the most common way to generate the files from Step 3. This requires your 3DS already be running the Luma3DS custom firmware stack via a browser exploit appropriate to your console’s firmware version — that setup is console-specific and outside the scope of a Folium tutorial, but it’s a well-documented, one-time process for consoles you legally own.
The exact entry point depends on what firmware your 3DS shipped with and how long it’s been since you last updated it. Consoles on very old firmware typically use a browser-based exploit; newer or fully updated consoles sometimes need a different chain, and New 3DS and New 3DS XL units occasionally have extra steps compared to the original 3DS or 3DS XL because of hardware differences in the New3DS-exclusive titles and their extra CPU core. None of this changes what you’re ultimately dumping — the files in Step 3 are identical across every 3DS hardware revision — but it does mean the console-side setup time can range from twenty minutes to over an hour depending on your starting firmware version.
The GodMode9 Dumping Steps
Once GodMode9 is accessible (usually by holding Start while booting), the general navigation to dump your keys looks like this:
1. Boot into GodMode9 (hold START during 3DS startup)
2. Navigate to: [SCRIPTS]
3. Select: DumpBoot9Boot11.gm9 (or equivalent boot dump script)
4. Navigate to: [SCRIPTS] > Key/movable.sed dump utility
5. Confirm the dump completes without a checksum error
6. Files are written to: 0:/gm9/out/ on your 3DS SD cardMenu wording varies slightly between GodMode9 builds, so treat the sequence above as a map rather than an exact script — if your build’s menu differs, look for a “dump” or “boot9/boot11” entry under Scripts or under the SysNAND options. Once finished, remove the SD card from your 3DS and connect it to your computer (or use the 3DS’s own SD card reader over a cable, if your console supports it) to copy the dumped files off.
Step 5: Dump Your Own Pokémon Cartridges or eShop Titles
With your keys extracted, the next job is turning your physical Pokémon cartridges (or eShop purchases still installed on your console) into files Folium can read. For cartridges, tools like Checkpoint or GodMode9’s own cart-dump function read the cartridge while it’s inserted in your 3DS and write out a decrypted or CIA-format copy to your SD card. For eShop titles, GodMode9 can export an installed title as a CIA file directly from your console’s NAND.
This is the step where owning the cartridge genuinely matters, both legally and practically — Folium and every other 3DS emulator will refuse to run a game that isn’t a legitimate dump matched against the keys from Step 4. If your dump fails a decryption check, it usually means the cartridge or eShop title didn’t dump cleanly, not that Folium is broken.
How Long Dumping Takes
Expect the dump itself to take anywhere from a few minutes to over ten, depending on cartridge size — Pokémon Sun and Moon’s larger ROM sizes take noticeably longer to read off a cartridge than the earlier X and Y carts. Let the process finish completely before removing the cartridge or the SD card; interrupting a dump partway through is the single most common cause of a corrupted file that later fails to import into Folium. If you own more than one Pokémon title, dump them one at a time and verify each file’s size looks reasonable (a full 3DS cartridge dump should be several gigabytes, not a few megabytes) before moving on to the next cartridge.
Step 6: Organize and Transfer Everything to Your iPhone
Before moving files off your computer or 3DS SD card, it helps to rename and group them so you’re not hunting through a flat folder of cryptic filenames on your iPhone’s small screen. If you’re comfortable with a terminal, a quick batch rename on your computer saves time later:
# macOS/Linux example: tidy up dumped 3DS files before transfer
mkdir -p ~/Desktop/3DS_Keys ~/Desktop/3DS_Games
mv boot9.bin boot11.bin aes_keys.txt seeddb.bin movable.sed ~/Desktop/3DS_Keys/
mv *.3ds *.cia ~/Desktop/3DS_Games/
ls -la ~/Desktop/3DS_Keys ~/Desktop/3DS_GamesGetting Files Onto Your iPhone
From there, get both folders onto your iPhone. AirDrop from a Mac is the simplest route; from Windows or Linux, use a cable transfer through the Files app, iCloud Drive sync, or a local network share. However you move them, the destination is the same: iOS’s Files app, under On My iPhone, in whatever folder Folium exposes for its own storage. Open the Files app after transferring to confirm both the key files and the game dumps landed somewhere Folium can browse to.
Step 7: Point Folium at Your Key Files
Open Folium and look for its file import or settings screen — most iOS emulators built around the Files app framework use an “Import Files” or “+” button rather than a hidden config screen, and Folium follows that same convention. Import all five key files (boot9.bin, boot11.bin, aes_keys.txt, seeddb.bin, and movable.sed) one at a time, or as a batch if the import dialog supports multi-select. The app should acknowledge each file rather than silently ignore it; if 3DS games still won’t boot after this step, revisit whether every file from Step 3 actually made it across in Step 6.
One wrinkle worth checking before you assume this step matches an older walkthrough exactly: RottenWiFi’s review of Folium’s setup flow, published October 13, 2026, notes that the import process itself has shifted in recent updates, specifically around how the app handles 3DS update-file support. In practice, that means the exact wording or layout of the import screen may not match screenshots from guides even a few months old, even though the basic rule hasn’t changed: import keys before games, as covered above. Because Folium is a one-person project without a public changelog beyond the App Store’s own version notes, treat the current App Store listing and whatever Folium’s import screen actually shows you as the source of truth, and follow what’s on your screen if a prompt or button here doesn’t match this guide’s exact wording.
Step 8: Import Your Pokémon ROM Dumps
With keys in place, import your dumped .3ds or .cia Pokémon files the same way — through Folium’s file browser or import button, pointed at the folder where you placed your game dumps. Folium should list each title with its box art once it successfully parses the file header, which is a quick visual confirmation that decryption is working before you even hit play.
If a Title Won’t Import
If a title imports but shows a generic icon instead of box art, that’s usually cosmetic — the game will often still launch. If a title fails to import at all, double check it against Step 5; a corrupted or partial dump is the most common cause, not a Folium bug.
Step 9: Set Up Controls — Touch and External Controllers
Folium ships with on-screen touch controls by default, which work fine for casual Pokémon play but get uncomfortable during longer battle or Pokéathlon-style sessions. iOS has built system-level support for MFi and Bluetooth game controllers since iOS 13, and modern iOS emulators — Delta, RetroArch, and Folium included — plug into that same framework rather than building their own custom Bluetooth stack. Folium’s own App Store listing spells this out directly as of October 2026: it tells players to use a compatible controller and names PlayStation, Xbox, or MFi pads specifically, rather than leaving the choice open-ended.
How to Pair a Controller
To pair a controller: open iPhone Settings, go to Bluetooth, put your controller into pairing mode, and select it once it appears in the device list. Back in Folium, check its input or controller settings screen to confirm the controller is recognized, and remap any buttons that don’t match your preference — the 3DS’s second analog “circle pad pro” input, used in a handful of Pokémon spin-off titles, is one area where mapping conventions vary between emulators, so it’s worth testing before a long session.
Pairing steps differ by brand. A PlayStation DualSense or DualShock 4 pad pairs by holding the Create (or Share, on DualShock 4) button and the PS button together until the light bar flashes rapidly, then selecting it from the iPhone’s Bluetooth list. An Xbox Wireless Controller pairs by holding the Xbox button and the small pairing button on the controller’s top edge until the Xbox button starts flashing, and older Xbox One pads that only speak the proprietary Xbox Wireless protocol instead of Bluetooth won’t show up in that list at all, so check your controller’s generation before assuming something is broken. MFi controllers that clip directly onto the iPhone, such as Backbone or Razer Kishi, skip the Bluetooth pairing screen entirely, since they connect through the phone’s charging port instead of a wireless radio.
If a PlayStation or Xbox pad shows as paired in iPhone’s Bluetooth settings but Folium doesn’t react to button presses, that’s almost always Folium needing a fresh launch rather than a bad pairing. Force-close the app and reopen it once the controller connects, the same fix covered in the troubleshooting table below. MFi controllers rarely hit this problem, since the physical connection gives Folium a clear signal the moment it’s plugged in, rather than relying on a Bluetooth handshake that can finish slightly before or after the app loads.
Matching Controller Buttons to the 3DS’s Layout
PlayStation, Xbox, and MFi pads all expose more buttons than the Nintendo 3DS hardware Folium is emulating, and that mismatch is worth understanding before a long play session rather than during one. The 3DS itself has a single analog Circle Pad, a D-pad, X/Y/A/B face buttons, and L and R shoulder buttons, with no second analog stick on original or XL hardware. The New 3DS and New 3DS XL added a small C-Stick nub for a handful of titles, but nothing close to a full second stick. That leaves a modern controller’s right stick and ZL/ZR triggers with nothing to map to for most mainline Pokémon games, since those titles were coded long before any of these controllers existed.
The one place this actually matters is the Circle Pad Pro, an accessory Nintendo sold for a small number of 3DS spin-offs that added a second analog input to the base hardware. Games built around it expect that second input to exist, and how Folium maps a controller’s right stick against that expectation is one of the few spots where a default mapping isn’t obviously correct out of the box. Open Folium’s input remapping screen and test the right stick in any Circle Pad Pro title before committing to a long session, instead of finding out mid-battle.
For most players the choice comes down to what’s already sitting in a drawer. A PlayStation or Xbox pad bought for other games pairs over Bluetooth at no extra cost and handles casual Pokémon sessions without trouble. An MFi controller that clips onto the phone gives up that flexibility for one real advantage: a physical connection can’t drop the way a paired Bluetooth pad occasionally does mid-session, which matters more across a multi-hour playthrough than during a quick battle. None of the three families has a meaningful input-accuracy edge over the others for a turn-based series like Pokémon, where a few milliseconds of Bluetooth latency matter far less than they would in a reflex-driven action game.
Step 10: Tune Performance Settings Per Game
Not every Pokémon 3DS title needs the same settings. X and Y, along with Omega Ruby and Alpha Sapphire, run closer to full speed on mid-range iPhones because they’re built on the earlier, lighter 3DS engine revision. Sun, Moon, Ultra Sun, and Ultra Moon push more geometry and lighting per frame and are the titles most likely to need a resolution or rendering scale reduction if you’re on an iPhone 11 or 12.
Resolution and Audio Tweaks
If Folium exposes internal resolution scaling in its settings menu, dropping from native to a lower internal render resolution is the single most effective fix for stutter in busy areas like Lumiose City or the Alola region’s town centers — you’re trading a small amount of visual sharpness for a large frame rate gain. If audio crackling is the main issue rather than frame drops, muting in-game music while keeping sound effects (or vice versa) is a workaround players have used consistently across Folium’s 3DS support, since the audio pipeline tends to desync under load before the video pipeline visibly drops frames.
Battle Animations vs. Overworld Performance
Battle animations are worth testing separately from overworld exploration, since they stress the emulator differently. Overworld frame drops in Folium tend to correlate with how many NPCs and background objects are on screen at once, while battle-scene stutter is more closely tied to particle effects and camera movement during move animations. If you find battles are the weak point on your device but exploring towns feels fine, turning off battle animations in the Pokémon game’s own in-game settings (an option every mainline 3DS Pokémon title includes) reduces emulator load without touching Folium’s settings at all — it’s a simple fix that’s easy to overlook because it lives in the game, not the emulator.
Step 11: Back Up Your Save Files
3DS emulator saves are organized by the game’s internal title ID rather than by filename, which is why manually copying a save between two different emulators (say, from a desktop Citra-based setup to Folium) doesn’t always work cleanly — the folder structure and metadata have to line up exactly.
Typical 3DS emulator save organization (structure varies by emulator):
/saves/
00040000000xxxxx/ <- Title ID folder, unique per game
data.bin <- Actual save data for that title
00040000000yyyyy/
data.binBacking Up the Right Way
Because Folium's own save format isn't fully published, don't assume a save copied from another emulator will drop in and work — back up your Folium saves regularly through the Files app or iCloud Drive before testing any cross-emulator save transfer, and treat any successful transfer as a bonus rather than a guarantee. If you're coming from a physical 3DS and want your actual save data (not a fresh start), that also has to be dumped from the console itself using the same homebrew tools from Step 4, since Folium can't read a physical cartridge's save chip directly.
Step 12: Know What Folium Doesn't Do — Multiplayer and Online Features
Folium is built around single-player emulation. There's no documented support for 3DS local wireless trading and battling, StreetPass, SpotPass, or any reconstruction of Nintendo's shuttered 3DS online services. If your plan involves trading Pokémon between two emulated copies or battling a friend over local wireless the way the original hardware allowed, Folium in its 2026 form isn't the tool for that — you'd need physical 3DS hardware, or a same-emulator local link setup on a platform that documents one, which Folium currently does not.
Common Pitfalls When Setting Up Folium for Pokémon
A handful of mistakes account for most of the "it won't boot" reports around Folium and 3DS emulation generally. Watch for these before you assume the app itself is broken.
- Downloading keys or ROMs from the internet instead of dumping your own. Beyond the legal problem, third-party key dumps are a common source of corrupted or mismatched files that produce cryptic decryption errors.
- Skipping seeddb.bin. Newer Pokémon titles using seed-based encryption will fail to decrypt without it, even if boot9/boot11/aes_keys are correct.
- Assuming an eShop dump doesn't need movable.sed. CIA-format eShop titles typically need this console-unique file even when cartridge dumps don't.
- Transferring files with a method that strips metadata. Some cloud-sync tools alter file timestamps or truncate large files; verify file sizes match after transfer, especially for larger Sun/Moon-generation dumps.
- Judging performance from a single busy scene. Frame rate on 3DS emulation dips hardest in specific hot spots (crowded towns, particle-heavy battle animations) — test more than one area before deciding your device "can't handle" a title.
- Expecting cross-emulator save compatibility as a default. Treat any successful save import from another 3DS emulator as unverified until you've confirmed your progress actually loaded correctly.
Troubleshooting: 8 Common Folium Problems and Fixes
| Problem | Likely cause | Fix |
|---|---|---|
| Game won't launch, black screen on boot | Missing or corrupted key file | Re-dump boot9.bin/boot11.bin/aes_keys.txt and re-import into Folium |
| Title imports but crashes when loading save | Save data mismatch or corruption | Delete the in-app save and start fresh, or re-dump the save from original hardware |
| Heavy audio crackling | CPU load spikes during 3D rendering, common on Sun/Moon-era titles | Lower internal resolution or mute background music |
| Frame rate drops only in specific towns/cities | Particle and NPC-heavy scenes exceeding phone thermal headroom | Lower resolution scaling; avoid extended play sessions in direct sunlight or hot rooms |
| Folium can't find imported ROM files | Files landed in the wrong Files app location | Re-check the folder Folium was actually pointed to during import |
| App Store shows Folium as unavailable | Region restriction on your Apple ID storefront | Check Settings > [your name] > Media & Purchases > Country/Region |
| Controller pairs in Bluetooth but isn't recognized in-app | Folium not refreshed after pairing | Fully close and reopen Folium after pairing the controller |
| eShop CIA dump fails to decrypt | Missing movable.sed file | Re-dump movable.sed from your console's NAND using GodMode9 |
Advanced Tips for a Smoother Pokémon 3DS Setup
Back Up Your Keys Somewhere Safe
Once the basic setup is working, a few habits make ongoing use noticeably smoother. First, dump your keys once and store a backup copy in a password-protected archive on a computer — you'll need those same files again if you ever reinstall Folium, switch to a new iPhone, or want to test an alternative 3DS emulator down the line, and re-running the console-side dumping process is the most tedious part of this whole workflow.
Batch Your Dumps When You Own Multiple Titles
Second, if you own multiple Pokémon 3DS titles, dump and import them in a single batch session rather than one at a time across several days — it's easier to verify file integrity (checking file sizes, confirming box art loads) when you're doing it systematically rather than piecemeal.
Watch the App Store Update Notes
Third, keep an eye on Folium's App Store update notes. Because it's a single-developer project, performance and compatibility fixes for specific games sometimes land in point releases rather than being publicly tracked in a changelog you'd see elsewhere — checking the in-app or App Store version history before assuming a bug is permanent can save you a wasted afternoon of troubleshooting something that's already been patched.
When to Consider Sideloaded Alternatives
Finally, if you're chasing maximum frame rate over convenience and don't mind sideloading, community reports suggest experimental emulators like Panda3DS and its Mandarine fork can hit 60 FPS in some Pokémon titles on recent iPhones where Folium runs slightly under. That performance gap comes at the cost of App Store stability and update reliability, so it's a genuine trade-off rather than a strict upgrade — most casual players are better served sticking with Folium's App Store convenience.
Managing Storage on Your iPhone
Storage management is the other habit worth building early. A single Pokémon 3DS cartridge dump can run several gigabytes, and if you're archiving multiple titles plus their save backups, that adds up fast on an iPhone that's also carrying photos, apps, and everything else in daily use. Consider keeping your original dumped files backed up on a computer or external drive and only loading the specific titles you're actively playing onto your iPhone at any given time — Folium doesn't require every game to live on-device permanently, and re-importing a file you've archived elsewhere takes a few minutes, not hours.
Storage Math for a Full Mainline Collection
Run the numbers across the full mainline 3DS Pokémon library and the prerequisites table's "10+ GB" recommendation starts to look conservative rather than generous. Eight mainline titles carry save data into Folium — X, Y, Omega Ruby, Alpha Sapphire, Sun, Moon, Ultra Sun, and Ultra Moon — and since a single cartridge dump already runs several gigabytes on its own, as noted above, a completionist library covering all eight can clear 20+ GB before save backups and key file copies are even counted. That math matters most on an iPhone with a 64 GB or 128 GB base storage tier, where photos, other apps, and iOS itself are already competing for space before a single Pokémon ROM gets imported. The archive-and-swap approach described above — keeping a master copy on a computer and only loading what you're actively playing onto the iPhone itself — stops being a nice-to-have and becomes close to mandatory once a collection grows past two or three titles on anything but the largest-capacity iPhone.
That math gets more pressing now that Folium's scope reaches past the 3DS. Since the same app's October 2026 listings cover Game Boy Advance, Nintendo DS, PlayStation 1, and Sega Genesis libraries alongside its 3DS emulation, anyone using Folium as one consolidated retro library, rather than a Pokémon-only install, should budget storage for whichever of those additional systems they're also archiving, on top of the 20+ GB this section already allocates to a full mainline 3DS Pokémon collection.
Recheck for Compatibility Fixes Periodically
It's also worth periodically checking whether Folium has shipped a 3DS-specific update, since performance and compatibility work for the 3DS side of the app has continued well past its initial mid-2024 launch. A title that stutters badly today may run noticeably better after a future update tunes the emulation core further — this is common across every actively developed emulator, not unique to Folium, but it's easy to forget to recheck once you've settled into a routine.
Complete Working Project: Your Folium Pokémon Setup Checklist
Pulling the whole tutorial together, here's the full sequence from a completely stock iPhone to a working Pokémon 3DS library in Folium:
- Confirm your iPhone meets at least the iOS 16.0 floor, ideally an iPhone 11 or newer for 3DS-generation Pokémon titles
- Purchase and install Folium from the App Store
- Boot your own 3DS into GodMode9 via Luma3DS custom firmware
- Dump boot9.bin, boot11.bin, aes_keys.txt, seeddb.bin, and movable.sed
- Dump your owned Pokémon cartridges and/or installed eShop titles as .3ds/.cia files
- Transfer both the key files and game dumps to your iPhone via AirDrop, cable, or cloud sync
- Import the key files into Folium first
- Import your game dumps into Folium's library
- Pair a PlayStation, Xbox, or MFi controller if you want one, and confirm it's recognized inside the app
- Adjust resolution/performance settings per game, especially for Sun/Moon-generation titles
- Back up your in-app saves regularly through Files app or iCloud Drive
- Keep a secure backup of your dumped keys for future reinstalls or device upgrades
Follow that order and you avoid the two most common failure points: importing games before keys are in place, and losing track of which files came from which dumping session.
Folium vs. Other Ways to Play Pokémon 3DS Games
It's worth being clear-eyed about where Folium sits relative to alternatives, since none of them are strictly better across every dimension.
Comparing Your Options at a Glance
| Option | Distribution | Stability | Best for |
|---|---|---|---|
| Folium (iOS) | Official App Store | High — no certificate risk | iPhone/iPad owners who want a set-and-forget setup |
| Panda3DS / Mandarine | Sideloaded (AltStore/SideStore) | Lower — certificate expiry risk | Users chasing maximum FPS, comfortable troubleshooting |
| Desktop 3DS emulator (e.g., on Windows/Mac) | Direct download | High on desktop, not portable | Players prioritizing accuracy over portability |
| Original 3DS/New 3DS hardware | N/A | Highest — original hardware | Anyone wanting local wireless, StreetPass, or 100% accuracy |
If you already run desktop 3DS emulation and just want a mobile-first Pokémon-only setup, Folium's App Store distribution is the simplest bridge — you trade a bit of frame rate ceiling for something that survives iOS updates without breaking every few months.
Total Cost and Time: Is the Folium Setup Worth It in October 2026?
Every row in the comparison table above trades money for time, or the reverse, and it's worth putting real numbers next to that trade-off rather than treating it abstractly. Folium itself costs $2.99 in the U.S. App Store (¥500 in Japan) as a one-time purchase — genuinely the smallest line item in this entire process. The real cost isn't the app; it's the roughly 90 minutes of console-side work this guide has budgeted for since the intro, almost all of which happens on your 3DS, not your iPhone. Understanding where that time actually goes makes it much easier to judge whether this setup is worth doing at all, or worth repeating for a second title.
Where the 90 Minutes Actually Goes
Broken down by stage rather than treated as one lump estimate, here's roughly where the time in Steps 1 through 8 actually goes:
- Getting into GodMode9 (Step 4). Twenty minutes to over an hour, depending entirely on which firmware your 3DS shipped with and whether a browser exploit or a different entry chain applies to your specific console.
- Dumping the five key files once inside GodMode9. A few minutes, and only ever necessary once per console you own.
- Dumping each Pokémon cartridge or eShop title (Step 5). A few minutes to over ten minutes per title, with Sun and Moon-generation carts taking noticeably longer than X and Y because of their larger ROM size.
- Transferring files and importing them into Folium (Steps 6 through 8). Typically well under ten minutes combined, assuming the key-then-games import order is followed correctly the first time.
The console-side entry point, not the iPhone-side import work, is what turns this into a 90-minute job instead of a 10-minute one — and that matters because the entry point and the key dump that follows only ever have to happen once. Back up boot9.bin, boot11.bin, aes_keys.txt, seeddb.bin, and movable.sed the way this guide's Advanced Tips section recommends, and reinstalling Folium on a new iPhone, or after an App Store update, means re-importing files you already have rather than repeating the console trip that consumed most of your original 90 minutes.
Weighing Folium's Setup Against the Alternatives
Set next to the other rows in the comparison table above, Folium's cost profile stands out: a low cash outlay, a moderate one-time time investment, and close to zero ongoing cost beyond whatever update Folium ships next on its single-developer cadence. A secondhand 3DS console sidesteps the key-dumping process entirely, but it reintroduces the original hardware's own problem — Nintendo's 3DS eShop no longer sells anything, and secondhand consoles have climbed in price precisely because supply is fixed while demand for them hasn't gone away. A desktop 3DS emulator reuses the exact same dumped keys and game files this guide walks through, so it adds no real extra time once the console-side work is done, but it drops the portability that's the entire reason to pick an iPhone-based emulator over a laptop in the first place. Sideloaded options like Panda3DS or its Mandarine fork ask for the identical 90-minute key extraction up front, then add periodic re-signing whenever Apple's developer certificates expire, trading that ongoing maintenance tax for a real, if modest, frame rate gain on the newest iPhones.
That leaves a fairly clean recommendation heading into October 2026: if you already own at least one Pokémon 3DS cartridge or eShop license and an iPhone 11 or newer, the 90-minute setup pays for itself the first time a title loads past its splash screen, and it's a one-time tax rather than a recurring one as long as you back up your dumped keys. If you don't yet own the games themselves, no amount of setup speed changes the one requirement every option in this guide shares — a legitimately owned copy of each title has to exist before Folium, or any other 3DS emulator, will load it.
Is Folium Still the Best Way to Play Pokémon 3DS Games in October 2026?
Short answer: yes, for most iPhone owners. The core setup hasn't changed since Folium added 3DS support. You still need iOS 16.0 at minimum, an iPhone 11 or newer for playable frame rates on Sun/Moon-era titles, and the same five files dumped from your own 3DS: boot9.bin, boot11.bin, aes_keys.txt, seeddb.bin, and movable.sed.
What's Changed Since Earlier Walkthroughs
What has changed is how complete the setup feels once you're done. Controller pairing through iOS's built-in Bluetooth framework, per-game performance tuning for the heavier Sun/Moon-generation titles, and regular save backups through the Files app or iCloud Drive are now treated as standard parts of the workflow rather than optional extras. None of that requires a new version of Folium or a different dumping process. Finishing the setup properly just means fewer surprises weeks later, when a save file needs restoring or a new iPhone needs the same keys reimported.
Filling the Gaps From Older Guides
If you followed an older Folium walkthrough that stopped at "import your ROMs and go," the gaps you'll likely hit are exactly those three: no controller mapped for long sessions, default performance settings struggling on Sun/Moon, and no backup when a save gets corrupted. Add those three habits to whatever setup you already have working, and there's little reason to look elsewhere in October 2026.
Frequently Asked Questions
Is Folium legal to use on iPhone?
Yes. Emulator software itself is generally legal, and Apple's own App Store guidelines explicitly permit retro console emulators as of an April 2024 policy change. What remains illegal is downloading ROMs, BIOS files, or keys you don't have rights to — you're expected to dump these from hardware and games you personally own.
What iPhone or iOS version does Folium need?
Folium's App Store listing requires iOS 16.0 or later on iPhone and iPadOS 16.0 or later on iPad just to install — that's a hard gate, not a suggestion. For Pokémon's 3DS-generation titles specifically, aim higher than the bare minimum: an iPhone 11 or newer (A13 Bionic or later) is the practical baseline for playable frame rates, per the performance table earlier in this guide.
What other game systems does Folium support besides the 3DS?
Folium has grown into a broader multi-system emulator. Beyond the Nintendo 3DS and New Nintendo 3DS emulation this guide covers, handled by Folium's Cytrus core per iTechGuides' October 12, 2026 testing, App Store listings reviewed by MWM on October 14, 2026 describe Folium as also supporting Game Boy Advance, Nintendo DS, PlayStation 1, and Sega Genesis titles. None of that changes the 3DS-specific setup steps in this guide. It just means the same app can house a wider retro library if you own games across more than one of those systems.
Do I need a jailbroken iPhone to use Folium?
No. Folium is distributed directly through the App Store, so it installs and updates like any normal iOS app, with no jailbreak, AltStore, SideStore, or TrollStore required.
Can I use Folium without owning a physical 3DS console?
No. Folium needs system key files (boot9.bin, boot11.bin, aes_keys.txt, and related files) that can only be legally obtained by dumping them from your own 3DS hardware using homebrew tools. Folium's listing is explicit that it doesn't provide games or system files itself — there's no legitimate way to acquire these without a console.
Will Pokémon Sun and Moon run well on Folium?
They're playable on most iPhones from the iPhone 11 generation onward, but expect more audio crackling and occasional frame drops than with the lighter X/Y-generation games. Reviewers have rated Sun/Moon's playability around 7/10 with audio closer to 5/10 on typical hardware.
Can I transfer my save file from a real 3DS or from Citra?
Sometimes, but it isn't guaranteed. 3DS saves are organized by title ID and internal formatting that can differ between emulator cores, and Folium's exact save format isn't fully documented publicly. Back up before attempting any transfer, and treat success as a bonus rather than an assumption.
Does Folium support trading Pokémon between two emulated games, or local wireless battles?
Not currently. Folium's documented feature set focuses on single-player emulation; there's no advertised support for 3DS local wireless, StreetPass, or SpotPass functionality.
Why does Folium cost money when other emulators are free?
Folium is an independent, single-developer project distributed through the App Store, where Apple's review and hosting model doesn't lend itself to donation-funded free apps the way open-source desktop projects do. As of October 2026, the U.S. storefront lists it at $2.99, with Japan's storefront at ¥500, and that one-time purchase funds the ongoing development that's carried the app to version 1.38 in Japan's listing, plus the App Store compliance work that comes with staying off jailbreak tooling entirely.
What controller should I use with Folium for Pokémon games?
Folium's App Store listing specifically recommends a PlayStation, Xbox, or MFi controller as of October 2026, and any pad in those three families works through iOS's built-in controller framework. Pair it through iPhone Settings > Bluetooth first (MFi controllers that clip onto the phone skip this step), then confirm Folium recognizes it in its own input settings before starting a long play session.
