Lemuroid Setup Guide: 20 Retro Systems [2026]

What Is Lemuroid and Why It’s Worth Setting Up in 2026

Lemuroid is an open-source, Android-only frontend built on top of the Libretro core ecosystem, the same underlying technology that powers RetroArch. The project is maintained by developer Swordfish90 and distributed under the GNU General Public License v3.0, meaning the source is fully public on GitHub and anyone can audit or fork it. As of this writing the repository lists 4,371 stars, 366 forks, and 595 open issues, numbers that put it well ahead of most niche emulation projects on Android.

The pitch is straightforward. Instead of installing RetroArch plus a handful of individual cores and manually wiring up directories for each system, Lemuroid wraps the whole stack in a single APK. Point it at a folder of your own game files, let it scan, and it builds a unified library grouped by console. Each supported system runs through a specific Libretro core under the hood (Snes9x for SNES, mGBA for Game Boy Advance, PCSX-ReARMed for the original PlayStation, and so on), but you never have to select a core manually unless something goes wrong.

What makes late 2026 a reasonable time to set this up is simple continuity: the project hasn’t stalled. Its GitHub repository shows build workflows running into early October, the issue tracker is still active, and the app remains listed on the Google Play Store under the package name com.swordfish.lemuroid, alongside an F-Droid listing and direct GitHub APK downloads. That’s three independent distribution channels, which matters if one of them ever changes its emulator policy.

A lot of Android emulator apps don’t get that kind of redundancy. Google Play has pulled or restricted emulator listings before over trademark complaints or policy reinterpretations, and when that happens, an app that only lived on Play Store simply disappears for anyone who hadn’t already installed it. Lemuroid being mirrored on F-Droid and published as a raw APK on GitHub means a single storefront decision can’t take the tool away from you. If you’re building a library you plan to keep using for years, that distribution spread is worth factoring into which install source you pick in Step 2 below.

Prerequisites: What You Need Before You Start

You don’t need much to run Lemuroid, but a few things are worth confirming before you spend time setting up a library only to find a core won’t launch. Here’s the baseline.

– **Android version:** Android 6.0 Marshmallow
– **Lemuroid version:** 1.17.0 (current GitHub release)
– **Free storage:** 500MB for the app and a small library
– **RAM:** 3GB for 8-bit and 16-bit systems
– **Controller:** Touchscreen controls (built in)
– **Game files:** Your own legally dumped ROMs/ISOs
– **BIOS files:** Required for PS1, PSP, and DS cores

Two things on that list deserve a closer look. First, Android 6.0 Marshmallow is the floor reported for the app to install and run at all, but anything below Android 9 tends to struggle once you get into Nintendo 64 or PSP territory, since those cores lean harder on CPU and GPU drivers that only matured in newer Android releases. Second, Lemuroid ships with zero games built in, by design. Every ROM, ISO, or ROM hack you load has to come from media you actually own, dumped yourself. That’s not a legal footnote, it’s the entire reason emulator projects like this one survive on Google Play at all.

Storage planning deserves a specific mention too, because it’s the prerequisite people most often underestimate. An NES or Game Boy library of a few hundred games fits comfortably in under a gigabyte. A PSP collection of similar size can eat 50GB or more, since individual ISOs routinely run past a gigabyte each. Before you start pulling files onto your phone, decide roughly which systems you care about and check your free storage against that, rather than discovering halfway through a transfer that your device is full. If you’re tight on internal storage, Lemuroid can scan a folder on an SD card or external USB drive just as easily as internal storage, provided Android grants it access to that path.

Lemuroid vs RetroArch vs ClassicBoy vs John GBAC

If you’ve already set up RetroArch, you might wonder why Lemuroid needs to exist at all. The answer comes down to how much friction you’re willing to tolerate before a game actually launches.

– **Lemuroid:** Android only, Low setup complexity, Hidden core management, Best for people who want one library, minimal menus
– **RetroArch:** Android, Windows, Linux, macOS, consoles, High setup complexity, Fully exposed core management, Best for power users who want shaders, netplay, and cross-platform saves
– **ClassicBoy:** Android only, Moderate setup complexity, Built-in core management, Best for casual users who want a paid, ad-light option
– **John GBAC:** Android only, Low setup complexity, Single-purpose, GB/GBC/GBA only, Best for people who only care about Game Boy-era handhelds

The practical takeaway: pick Lemuroid when your collection spans multiple systems and you want one library to manage instead of four or five separate apps. Pick RetroArch when you need shader filters, netplay, or a system Lemuroid doesn’t cover. Pick a single-purpose app only when your entire use case fits inside what that app does and nothing more.

Every System Lemuroid Supports

The official README lists twenty supported systems, each mapped to a specific Libretro core. Knowing which core handles which console matters later, because troubleshooting a crash often comes down to knowing which specific emulator is misbehaving under the hood.

– **Atari 2600:** Stella
– **Atari 7800:** ProSystem
– **Atari Lynx:** Handy
– **Nintendo Entertainment System:** FCEUmm
– **Super Nintendo Entertainment System:** Snes9x
– **Game Boy / Game Boy Color:** Gambatte
– **Game Boy Advance:** mGBA
– **Sega Genesis / Mega Drive:** Genesis Plus GX
– **Sega CD / Mega CD:** Genesis Plus GX
– **Sega Master System:** Genesis Plus GX
– **Sega Game Gear:** Genesis Plus GX
– **Nintendo 64:** Mupen64Plus
– **PlayStation (PS1):** PCSX-ReARMed
– **PlayStation Portable:** PPSSPP
– **Arcade:** FinalBurn Neo
– **Nintendo DS:** melonDS / DeSmuME
– **PC Engine / TurboGrafx-16:** Beetle PCE Fast
– **Neo Geo Pocket / Color:** Mednafen NeoPop
– **WonderSwan / Color:** Beetle Cygne
– **Nintendo 3DS:** Citra

Notice what’s missing: PlayStation 2, GameCube, and Nintendo Switch are not on this list, and the official documentation doesn’t claim otherwise. Those systems need far more processing headroom than a phone-oriented Libretro core can reasonably deliver, which is why dedicated projects like DuckStation for PS1 or desktop-class tools handle those separately. If your collection leans toward sixth-generation consoles or later, Lemuroid isn’t the right tool, and no amount of settings tweaking will change that.

It’s worth grouping these twenty systems by how demanding they actually are on your phone’s hardware, because that context shapes what settings you’ll need later. The 8-bit and 16-bit tier, Atari 2600 through SNES and Genesis, runs comfortably on almost any Android device released in the last decade, including budget phones. The handheld tier, Game Boy through Game Boy Advance plus Neo Geo Pocket and WonderSwan, is even lighter. The step up comes with Nintendo 64, PlayStation, PSP, and arcade titles through FinalBurn Neo, which all require real 3D rendering or heavier CPU emulation and benefit from a phone released in the last three to four years. Nintendo DS and Nintendo 3DS sit at the top of the demand curve among Lemuroid’s supported systems, since both involve dual-screen rendering or, in the 3DS case, genuinely complex 3D hardware that pushes any mobile chipset.

Installing Lemuroid Step by Step

Step 1: Confirm Device Compatibility

Open Settings on your Android device and check the version number under About Phone. You need Android 6.0 at a minimum, but if you’re on anything older than Android 9 and planning to run Nintendo 64 or PSP games, set expectations low. Also check available storage: a library of SNES and Game Boy Advance games barely registers, but PSP ISOs run 200MB to 1.5GB each, and that adds up fast.

Step 2: Pick Your Install Source

Lemuroid is available through three channels, and each has a tradeoff. Google Play is the easiest and handles updates automatically, but Play Store policy changes have historically forced emulator developers to adjust features, so treat it as the convenient default rather than the only option. F-Droid serves the same APK without Google Play Services, which matters if you run a de-Googled phone. The GitHub releases page gives you the raw APK directly from the source repository, useful if you want to verify you’re running exactly version 1.17.0 rather than whatever build Play Store happens to be serving.

Step 3: Install the App

If you’re sideloading from GitHub instead of using an app store, enable installs from unknown sources for your browser or file manager, download the APK, and install it. For anyone comfortable with a terminal, ADB sideloading is faster and lets you confirm the exact package and version before it lands on the device.

“`bash
# Connect your device with USB debugging enabled, then run:
adb devices
adb install -r lemuroid-1.17.0-release.apk

# Confirm the installed version matches what you downloaded:
adb shell dumpsys package com.swordfish.lemuroid | grep versionName
“`

That last command should print versionName=1.17.0 if the install went through cleanly. If it shows something older, Android likely cached a previous APK, and a clean uninstall before reinstalling will fix it.

Setting Up Your ROM Library the Right Way

Step 4: Launch and Grant Permissions

On first launch, Lemuroid asks for storage access so it can scan your device for game files. Grant it. Without storage permission the app has nothing to scan and the library screen stays permanently empty, which is the single most common source of “it’s not finding my games” confusion among new users.

Step 5: Legally Prepare Your Files

Lemuroid ships with no games and no copyrighted BIOS files, which is why it survives on Google Play while plenty of other emulation apps have been pulled. The responsible path is dumping ROMs from cartridges or discs you physically own, using your own hardware and a dumping device, rather than downloading files from third-party ROM sites. Copyright law varies by country, so check your local rules before assuming personal backups of games you own are automatically covered.

Step 6: Build the Folder Structure

Lemuroid’s scanner is forgiving about exact paths, but organizing files by system saves you a headache later when you’re troubleshooting a specific core. A layout like this keeps things predictable.

“`bash
/storage/emulated/0/Lemuroid/
├── NES/
├── SNES/
├── GB_GBC/
├── GBA/
├── Genesis/
├── SegaCD/
├── N64/
├── PS1/
│ └── bios/
├── PSP/
├── Arcade/
├── NDS/
│ └── bios/
├── PCEngine/
├── NeoGeoPocket/
├── WonderSwan/
└── 3DS/
“`

Keep file extensions standard for each system (.nes, .sfc, .gba, .iso, .cue+.bin for disc-based systems) so the scanner’s file-type detection has the best chance of matching the right core automatically.

Step 7: Point Lemuroid at the Directory and Scan

Inside Lemuroid, open the folder selection screen and choose the root Lemuroid directory you just built. The app recurses through subfolders automatically, so you only need to select the top-level path once. Tap to start the scan, and give it a minute or two for a large collection. When it finishes, your library screen populates with cover art pulled from each game’s metadata where available, grouped by system.

Scan time scales with how many files you’re adding and how fast your device’s storage is. A few hundred ROMs on fast internal storage finishes in well under a minute. A few thousand files spread across a slower microSD card can take several minutes, and Lemuroid will show a progress indicator rather than appearing frozen, so give it time before assuming something broke. If the scan finishes but a system you expected is missing entirely from the library, go back and confirm the file extensions in that folder actually match what the corresponding core recognizes, since an unrecognized extension gets silently skipped rather than flagged as an error.

BIOS Files and Firmware Dependencies

Step 8: Install BIOS Files for PS1, PSP, and Nintendo DS

Most of Lemuroid’s twenty systems run without any BIOS file, but three do not: the original PlayStation core needs a dumped PS1 BIOS, Nintendo DS benefits from a firmware dump for full compatibility, and some PSP titles expect specific firmware files to boot correctly. Place these in the bios subfolder within each system’s directory, matching the exact filenames the core expects (Lemuroid’s in-app help screen for each core lists the required filename and checksum). Mismatched or corrupted BIOS dumps are the most common reason a PS1 game shows a black screen instead of booting.

Only use firmware pulled from hardware you own. Dumping a PS1 BIOS from your own console with the right tools takes a few minutes and avoids the legal and security risk of downloading a BIOS file of unknown origin from a random site. That second point matters beyond copyright: BIOS and firmware files circulating on unofficial download sites are an easy place to hide malware, since most users have no way to verify a binary blob is exactly what it claims to be. A file dumped from your own console carries none of that risk, because you control the entire chain from hardware to file.

If you do need to confirm a BIOS dump is intact rather than corrupted during transfer, a checksum comparison (the same md5sum approach covered in the advanced tips section below) against a hash you generated from your own original dump is a safer verification method than trusting a checksum posted alongside a download on a forum you don’t control.

Controllers and Per-Core Tuning

Step 9: Pair a Controller

Touchscreen controls work in a pinch, but anything with analog movement, Nintendo 64 platformers especially, is miserable without a real gamepad. Pair a Bluetooth controller through Android’s standard settings menu first, then open Lemuroid, and it should detect the input device automatically on next launch.

“`bash
# List paired Bluetooth devices from a connected ADB shell:
adb shell dumpsys bluetooth_manager | grep -A2 “name:”

# Confirm Lemuroid registers the controller as an input device:
adb shell getevent -lp | grep -B5 “gamepad|joystick”
“`

If the controller pairs with Android but Lemuroid doesn’t recognize button presses, check the in-app controller mapping screen and manually assign buttons once. Most mapping issues come from controllers that report themselves under a generic HID profile instead of a standard gamepad profile.

Step 10: Tune Per-Core Settings

Each core exposes a small settings panel accessible from the in-game menu. For Nintendo 64 and PSP, the two most demanding systems on the list, dropping internal resolution one notch and disabling any enhancement filters usually buys back enough frame rate to make a struggling game playable. For 2D systems like SNES or Genesis, the defaults are typically fine on any phone from the last five years.

Save States, Backups, and Android TV

Step 11: Configure Save States and Back Them Up

Lemuroid writes save states and in-game battery saves to local storage alongside your ROM files. There’s no built-in cloud sync feature in the app itself, so treat your save folder the same way you’d treat any other important local data: back it up manually. Copying the saves directory to a cloud storage folder (Google Drive, Dropbox, whatever syncs on your phone) on a regular basis protects you from losing twenty hours of progress to a factory reset.

“`bash
#!/bin/bash
# Simple backup script, run via Termux on-device or from a PC over ADB pull
SRC=”/storage/emulated/0/Lemuroid/saves”
DEST=”/storage/emulated/0/CloudSync/LemuroidBackups/$(date +%Y-%m-%d)”
mkdir -p “$DEST”
cp -r “$SRC”/* “$DEST”/
echo “Backed up saves to $DEST”
“`

Run that weekly, or after any session where you made meaningful progress, and point the destination at whatever sync folder your cloud provider watches.

Step 12: Set Up Android TV Mode

Lemuroid runs on Android TV devices using the same APK, though the interface adapts to a d-pad-first navigation scheme instead of touch. Install it the same way (Play Store works fine on most Android TV boxes), pair a controller first since there’s no touchscreen to fall back on, and point it at a ROM folder on an attached USB drive or network share if your TV box has limited internal storage.

Verifying Your Setup Works

Step 13: Confirm Each System Boots Correctly

Before calling the setup finished, launch one game from each system category you added. A clean boot looks like this in the library: tapping a cover loads a brief core initialization screen, then drops straight into the game with no error dialog. If a specific system fails while others work fine, the problem is almost always isolated to that core’s BIOS requirement or a corrupted file, not a problem with Lemuroid itself.

A working PS1 boot, for example, should show the original PlayStation startup animation briefly before the game loads, proof the BIOS file is correctly recognized. If you see a black screen that never progresses past a few seconds, that’s your signal to double-check the BIOS filename and checksum rather than assume the game file itself is bad.

5 Common Pitfalls When Setting Up Lemuroid

– **Skipping storage permission:** If the library stays empty after a scan, nine times out of ten the app never got full storage access in the first place. Check Android’s app permissions screen directly rather than relying on Lemuroid’s own prompt.
– **Mixing file formats in one folder:** Dropping .zip, .7z, and raw ROM files together in the same directory confuses the scanner’s file-type matching. Stick to one format