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, tuning performance per game, and fixing the audio and frame rate hiccups that still show up in 2026. Budget about 90 minutes for a first-time setup, most of which is spent on 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 covering Game Boy Advance, Nintendo DS, and Nintendo 3DS titles, distributed as a paid app (roughly $2.99–$4.99 in the US App Store, around €5.99 in the EU) directly through Apple’s storefront. It added 3DS support in what its developer described as its biggest update, and it has continued to receive updates through 2025 and into 2026, including a December 2025 refresh that improved the 3DS interface on iOS 16 and later.
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, 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 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 — interface tweaks for iPad’s larger canvas, layout adjustments aimed at iOS 16’s newer UI conventions, and ongoing 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.
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.
| Requirement | Minimum | Recommended for Pokémon 3DS titles |
|---|---|---|
| iPhone / iPad | Any device on iOS 15.0+ | iPhone 11 or newer (A13 Bionic or later) |
| iOS / iPadOS version | iOS 15 | iOS 16 or later (for the refreshed 3DS layout) |
| 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 |
| MFi or Bluetooth game 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 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 15 floor, but “runs” and “runs well” are different claims for 3DS content specifically.
| 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 |
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.
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. 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.
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.
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 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.
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.
.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
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.
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.
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_GamesFrom 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 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.
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 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.
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.
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.
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 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.binBecause 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
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.
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.
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.
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.
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.
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 15 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 an MFi/Bluetooth 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.
| 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.
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.
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. 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. The one-time purchase price funds ongoing development and App Store compliance work.
What controller should I use with Folium for Pokémon games?
Any MFi-certified or standard Bluetooth game controller supported by iOS's built-in controller framework should work. Pair it through iPhone Settings > Bluetooth first, then confirm Folium recognizes it in its own input settings before starting a long play session.
Related Coverage
- How to Set Up DeSmuME for Pokémon DS Games: 12 Steps [2026]
- Set Up Pokémon Emulators on Steam Deck: 13 Steps [2026]
- How to Use PKHeX: Edit Pokémon Saves in 12 Steps [2026]
- Pokémon Stadium ROM Setup on PC: 13 Steps, 90 Min [2026]
- How to Set Up RomM: Self-Host 400+ Systems in 12 Steps [2026]
