Pegasus Frontend Setup: 13 Steps, 60 Min [2026]

Most emulation guides walk you through one system at a time: install RetroArch, then install Dolphin, then install PCSX2, then figure out how to jump between three different launchers to play three different consoles. Pegasus Frontend exists to erase that friction. It is a free, open-source launcher that sits on top of whatever emulators you already have installed, pulls your entire library into one controller-navigable menu, and, as of October 2026, spans seven platforms from the same codebase — Windows, Linux, macOS, Android, Raspberry Pi, Odroid, and more, according to iTechGuides. According to DataForSEO keyword data pulled in September 2026, “pegasus frontend” draws roughly 590 monthly searches in the US with low competition, a sign that a steady trickle of emulation enthusiasts keep rediscovering it even though the project rarely makes headlines.

This guide covers the full setup process in 13 concrete steps: installation on every supported platform, the configuration directory layout, writing your own metadata.pegasus.txt files, wiring up RetroArch cores, adding Steam and GOG games automatically, installing QML themes, and getting controllers working before you ever touch a Steam Deck Game Mode shortcut. Expect to spend 45 to 75 minutes on a first full build if you are starting from a folder of ROMs and a blank Pegasus install.

·

Google · Preferred Sources

Don't miss new tech stories on Google

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

Add Now

What Is Pegasus Frontend?

Pegasus Frontend is an open-source, cross-platform game launcher maintained by developer Mátyás Mustoha under the GitHub handle mmatyas. The project describes itself as a graphical frontend for browsing a game library and launching emulators from a single interface, with a stated focus on customizability, cross-platform support (including embedded hardware), and performance. It is not an emulator itself, and it does not bundle RetroArch cores, BIOS files, or ROMs the way an all-in-one package like EmuDeck or Batocera does. Instead, Pegasus is an orchestration layer: you point it at your existing games and emulators, and it builds a browsable, theme-able front end around them.

The project has been public since 2017 and has shipped 27 tagged releases on GitHub. The most recent tagged release on GitHub itself is “Weekly release #38, 2024” (git tag weekly_2024w38), published October 5, 2024, which is the version this guide references for file paths and configuration syntax — but third-party trackers suggest the project is more current than that tag implies: as of October 2026, TheToolPicker lists Pegasus Frontend’s latest tracked update as October 5, 2026. Separately, GitHub activity data shows commits still landing on the master branch well into 2025 and 2026, including a GCC 16 compatibility fix on October 2, 2026, so the codebase has not gone fully dormant even though formal tagged releases have slowed. Treat Pegasus as stable and usable rather than under active weekly development, and double-check the official releases page before you start in case a newer build has shipped since this guide was written.

Unlike a packaged distro, Pegasus does not ship as a disk image you flash and boot from. It is a single application you install on top of whatever operating system you already run, which is why the official getting-started documentation spends most of its space on per-platform installation quirks rather than a universal installer. That same documentation is also the most reliable place to confirm exact download links, since community mirrors occasionally lag behind the canonical GitHub releases.

Telling Pegasus Frontend Apart From Other Pegasus Products

Searching for Pegasus turns up more than one product, and release news for those products does not describe this launcher. TwelveLabs offers a Pegasus video-and-image-understanding model through its API and SDKs, and Pegasus 1.6, released October 6, 2026, is its newest model. That model and its API pricing are a separate entity from this open-source frontend, so they have no bearing on the launcher’s features, installation steps, or configuration files covered in this guide.

Pegasus Tools is another similarly named product. Its official update page says Pegasus Tools 5.6 concentrates on update compatibility and application readiness. A release note like that belongs to its own tool, and attributing it to the frontend would be speculation.

For this launcher, the signals worth trusting are the ones tied to the mmatyas repository: the official releases page, the commits on the master branch, and the getting-started documentation. If a changelog or article mentions TwelveLabs, Marengo, Jockey, or API prices per hour of video, you are reading about a different product, and you can safely ignore it while following the 13 steps below. Checking the source of any version number before you act on it saves you from hunting for a download that does not exist for this frontend.

Why Use Pegasus Instead of EmulationStation, Batocera, or LaunchBox

If you already run Batocera or EmuDeck, you may not need Pegasus at all, since both ship a complete frontend out of the box. Pegasus earns its place in a different scenario: you want to keep your existing operating system, whether that is a stock Windows install, a vanilla Arch or Fedora desktop, or SteamOS on a Steam Deck, and you want a single unified library view without replacing the OS or installing a monolithic emulation distro.

Three things set Pegasus apart from rivals like LaunchBox, Playnite, and ES-DE. First, it is genuinely cross-platform: as of October 2026, iTechGuides counts seven supported platforms — Windows, Linux, macOS, Android, Raspberry Pi, Odroid, and more — all running the same QML-based interface, where LaunchBox and Playnite are Windows-only and ES-DE’s macOS and Android support trails its Linux and Windows builds. Second, its theming system is written in QML, the same declarative UI language Qt uses for desktop and embedded interfaces, which means a theme author can redesign the entire interface rather than just skin an existing template. Third, Pegasus can read EmulationStation-style gamelist.xml files, so if you are migrating away from an EmulationStation-based setup you do not have to rebuild your metadata from scratch.

The tradeoff is setup effort. Pegasus expects you to write or adapt metadata.pegasus.txt files by hand for anything outside of Steam and GOG, which are auto-detected on desktop platforms. If you want a turnkey experience with zero manual configuration, RetroDECK or EmuDeck will get you there faster. If you want full control over how your library looks and behaves, Pegasus is the tool built for that trade.

That control extends to multi-device households, too. Because the same metadata format and theme files work across Windows, Linux, and Android, a family running one emulation setup on a living-room PC and another on an Android tablet can share a single theme and a near-identical set of collection definitions, something that is much harder to pull off when the Windows and Android halves of your library run on completely different frontends with incompatible theming engines.

Prerequisites: What You Need Before You Start

Pegasus itself is lightweight, but your emulators and BIOS files are not covered by this guide. Gather the following before Step 1:

• A PC, laptop, Steam Deck, or Android device running one of: Windows 10 or 11, a modern Linux distribution with Flatpak support, macOS, or Android 5.0 (Lollipop) or newer.
• At least one emulator already installed and tested outside Pegasus, such as RetroArch, PPSSPP, or a standalone console emulator. Pegasus launches these; it does not install them for you.
• Your own legally dumped ROMs, ISOs, or game files, and any required BIOS files for the systems you plan to emulate. Only use files pulled from hardware and discs you own.
• A graphics driver current enough to support hardware-accelerated Qt rendering. Update GPU drivers first if you are on an older integrated chipset.
• On Windows, a video codec pack such as K-Lite Basic, since Pegasus uses the OS media engine for video previews and missing codecs can crash playback on some themes.
• A game controller if you plan to navigate Pegasus the way it is designed to be used, though keyboard and mouse work fine for initial setup.
• Roughly 200 MB of free space for Pegasus itself, plus whatever your ROM and BIOS library requires.

Pegasus Frontend System Requirements and Config Paths by Platform

Before installing, it helps to know where Pegasus stores its settings on each platform, since you will be visiting these folders repeatedly to add themes and metadata files.

Platform	Install Method	Configuration Directory
Windows 10/11	Download and extract a .zip archive from pegasus-frontend.org	C:\Users\[username]\AppData\Local\pegasus-frontend\
Linux (native)	Project release archive or distro package	~/.config/pegasus-frontend/
Linux (Flatpak)	flatpak install flathub org.pegasus_frontend.Pegasus	~/.var/app/org.pegasus_frontend.Pegasus/config/pegasus-frontend/
macOS	Download the macOS build from the Downloads page	~/Library/Preferences/pegasus-frontend/
Android 5.0+	Sideloaded APK from pegasus-frontend.org	<storage>/Android/data/org.pegasus_frontend.android/files/pegasus-frontend/
Portable mode (any desktop OS)	Create an empty portable.txt beside the executable	<Pegasus program directory>/config/

Minimum hardware is modest: Pegasus needs a working Qt and OpenGL (or equivalent) stack, which almost any PC from the last decade already provides. The real requirements live downstream, in whatever emulator you are launching. A PS1 core needs very little; a PS2 or GameCube core needs a far more capable CPU and GPU, which is a separate consideration from running Pegasus itself.

Steps 1-3: Install Pegasus on Windows, Linux, and macOS

Step 1 (Windows). Go to the official Pegasus Frontend site and download the current Windows build. Extract the archive to a folder you control, such as C:\Emulation\Pegasus\. Run pegasus-fe.exe directly; there is no installer wizard to click through. If video previews crash on launch, install a codec pack like K-Lite Basic before trying again.

Step 2 (Linux). The supported graphical path is Flatpak via Flathub. Open a terminal and run:

flatpak install flathub org.pegasus_frontend.Pegasus
flatpak run org.pegasus_frontend.Pegasus

If your distribution does not have Flatpak configured yet, add the Flathub remote first with flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo, then re-run the install command. Flatpak sandboxing matters here: Pegasus running inside a Flatpak container can only see folders it has been granted access to, which trips up a lot of first-time setups when ROMs live outside the default home-folder scope.

Step 3 (macOS). Download the macOS build from the same Downloads page, extract or mount the package, and move the Pegasus application into /Applications if you want it to behave like a normal Mac app. Launch it once from Finder to clear the Gatekeeper warning for an unsigned or community-signed build.

Steps 4-5: Install Pegasus on Android and Steam Deck

Step 4 (Android). Pegasus is not distributed through the Google Play Store, so you will sideload it. Enable unknown-source installs under Settings → Security, download the APK from pegasus-frontend.org, and open it with a file manager to install. On first launch, grant storage access so Pegasus can see your ROM folders, which live under <storage>/pegasus-frontend by default, a separate location from the app’s internal configuration directory listed in the table above.

Step 5 (Steam Deck). There are two realistic paths. The cleaner one: switch to Desktop Mode, open Discover, search for Pegasus, and install the Flathub package exactly as in Step 2. Launch it once in Desktop Mode to confirm your game directories, then switch back to Steam, choose Games → Add a Non-Steam Game to My Library, and add the Pegasus Flatpak entry. Switch to Game Mode and it will appear as a launchable shortcut. The alternative path, running the Windows build through Proton, works but adds a compatibility layer you do not need on a device that already runs Linux natively; reserve Proton for Pegasus only if you have a strong reason to stick with the Windows build’s specific themes or plugins.

Steps 6-7: Configuration Directories and Portable Mode

Step 6. Navigate to the configuration directory for your platform from the table above. Inside, you will eventually create two subfolders that matter most: themes/ for interface themes and whatever folder structure you choose for your ROM metadata, since metadata.pegasus.txt files live beside your games rather than inside the Pegasus config directory itself.

Step 7. If you want to carry a self-contained Pegasus install on a USB stick, or you simply dislike scattering configuration across the Windows AppData tree, enable portable mode. Create an empty file literally named portable.txt in the same folder as the Pegasus executable. From that point on, all settings, themes, and cached data are written to a config folder next to the program instead of the normal per-user location, which makes the whole setup drive-portable.

Steps 8-9: Writing a metadata.pegasus.txt File

Step 8. Pegasus discovers games through plain text files named exactly metadata.pegasus.txt, placed next to the ROMs they describe. The core fields are collection (the display name), shortname (an internal identifier), extensions (file types to scan for), and launch (the command used to start a game, with {file.path} substituted for the selected file). Here is a minimal working example for an SNES folder using a native Linux RetroArch install:

collection: Super Nintendo
shortname: snes
extensions: smc, sfc, zip

launch: /usr/bin/retroarch
-L
/usr/lib/libretro/snes9x_libretro.so
{file.path}

On Windows, quote any path that contains spaces, since a bare space will otherwise break the argument parsing:

collection: Nintendo Entertainment System
shortname: nes
extensions: nes, zip

launch: "C:\Program Files\RetroArch\retroarch.exe"
-L
"C:\Program Files\RetroArch\cores\fceumm_libretro.dll"
{file.path}

Step 9. After saving the file, go to Settings → Game directories inside Pegasus and add the parent folder, or the folder containing the metadata file. Pegasus rescans on this action; if you edit a metadata file later, you need to repeat this step or restart Pegasus for the changes to take effect, which is the single most common “why isn’t my game showing up” mistake.

Field	Purpose	Example Value
collection	Display name shown in the Pegasus UI	Super Nintendo
shortname	Internal/compact system identifier	snes
extensions	Comma-separated file types to scan for	smc, sfc, zip
launch	Executable or command used to start a game	/usr/bin/retroarch
command	Alternate single-line launch syntax used in some third-party examples	/path/to/launcher {file.path}
{file.path}	Placeholder substituted with the selected game’s full path	(auto-filled by Pegasus)

Step 10: Wiring Up RetroArch Cores Correctly

RetroArch is the emulator most Pegasus users connect first, and it is also the most common source of launch failures because the core path has to be exact. If you installed RetroArch through Flatpak rather than natively, the core path changes shape entirely. Here is the Flatpak version of the same SNES example, which is also the form you will use on a Steam Deck running RetroArch through Flathub:

collection: Game Boy Advance
shortname: gba
extensions: gba

launch: flatpak run org.libretro.RetroArch
-L
/home/deck/.var/app/org.libretro.RetroArch/config/retroarch/cores/mgba_libretro.so
{file.path}

Before pasting a path into a metadata file, open RetroArch itself and check its core directory under Settings → Directory → Cores. Core filenames and locations vary by distribution and by whether you installed from Flathub, a distro package, or a manual archive, so never assume a path from a tutorial matches your own install without verifying it first.

Step 11: Adding Steam, GOG, and Standalone Emulators

Desktop Pegasus builds on Windows, Linux, and macOS detect installed Steam games automatically with no metadata file required; the same applies to GOG libraries on supported platforms. Toggle these data sources under Settings → Enable/disable data sources if you do not see your Steam library appear after installing.

For standalone emulators that are not RetroArch cores, such as PPSSPP or Dolphin, point launch directly at the emulator’s own executable instead of a core path. On Android, standalone apps often launch through an Android intent rather than a normal executable path, which looks different again:

collection: PSP
extension: iso, cso

launch: am start
--user 0
-a android.intent.action.VIEW
-d {file.path}

If you are migrating an existing EmulationStation-based library, you do not have to rebuild every entry by hand. Pegasus can read EmulationStation v2-style gamelist.xml files directly, which is one of its most useful shortcuts for anyone coming from a Batocera, RetroPie, or RetroBat setup.

Metadata Sources Compared: Manual Files, Steam, and Scrapers

Pegasus pulls game data from more than one place at once, and understanding which source handles which part of your library saves a lot of duplicated effort. The official metadata sources documentation lists each provider and how much manual setup it needs, summarized below.

Source	Setup Required	Best For
metadata.pegasus.txt	Manual, written per collection	Emulated systems, RetroArch cores, custom launch commands
Steam	None, auto-detected on desktop	Native PC games already installed through Steam
GOG	None, auto-detected on desktop	DRM-free PC games installed through GOG Galaxy
EmulationStation gamelist.xml	Point Pegasus at an existing EmulationStation library	Migrating from Batocera, RetroPie, or RetroBat without rescraping
Skraper media folders	Run Skraper once, Pegasus reads the output automatically	Box art, logos, and video previews for emulated collections

In practice, most builds end up mixing two or three of these at once: Steam and GOG for native PC games, a handful of hand-written metadata.pegasus.txt files for emulated systems, and Skraper-generated artwork layered on top so the emulated collections look as polished as the auto-detected ones.

Running Pegasus on Raspberry Pi and Other Embedded Devices

Pegasus’s README specifically calls out embedded hardware, including Raspberry Pi and Odroid boards, as a first-class target rather than an afterthought. This matters for anyone building a living-room retro box instead of using a desktop PC or handheld. The installation pattern is the same as desktop Linux: either grab a prebuilt ARM release if one is published for your board’s architecture, or build from source using the project’s documented Qt dependencies, since not every embedded release lands on the same schedule as the Windows and Linux desktop builds.

On a Pi-class device, expect the Qt rendering stack and controller input handling to behave identically to a desktop Linux install once Pegasus is running, down to the same ~/.config/pegasus-frontend/ configuration path and the same metadata.pegasus.txt syntax covered above. The practical difference is horsepower: a Raspberry Pi can comfortably drive Pegasus’s own interface and lightweight RetroArch cores for systems through roughly the PS1 and N64 generation, but anything heavier should run on a more capable board or a dedicated PC instead.

Steps 12-13: Installing Themes and Mapping Controllers

Step 12. Pegasus themes are written in QML, Qt’s declarative interface language, and each theme lives in its own subfolder inside the themes directory under your platform’s config path. A valid theme folder contains, at minimum, theme.cfg (metadata: name, author, version) and theme.qml (the actual interface code). To install one:

~/.config/pegasus-frontend/themes/
└── MyTheme/
    ├── theme.cfg
    ├── theme.qml
    └── assets/

Download the theme archive, extract it so the folder structure above is preserved, drop it into your themes directory (on Flatpak Linux that is ~/.var/app/org.pegasus_frontend.Pegasus/config/pegasus-frontend/themes/), restart Pegasus, and select it under Settings → Theme. Themes that expose custom settings read and write them through a global QML object called api, which also surfaces game and collection data, keyboard and gamepad bindings, and device information to theme authors. The full theme development documentation is worth bookmarking even if you never write your own theme, since it explains exactly which files a well-formed theme package should contain, which makes it much faster to diagnose a theme that silently fails to load.

If you would rather skip manual file management entirely, Pegasus’s Flatpak build is also listed on Flathub’s own app page, where most Linux software centers such as GNOME Software and KDE Discover will show the same listing with a one-click install button instead of a terminal command.

Step 13. Controllers are generally detected automatically through Qt’s gamepad handling, but confirm bindings under Pegasus’s own input settings menu rather than assuming the operating system’s mapping is what Pegasus sees. If you are testing through Steam’s Big Picture or Game Mode layer, remember that Steam Input can intercept or remap a controller before Pegasus ever receives its signal, which is the most common reason a pad that works everywhere else goes silent inside Pegasus specifically.

Complete Working Example: A Four-System Pegasus Build From Zero

To see the full picture, here is a realistic end-to-end layout for a Linux desktop running Pegasus through Flatpak with RetroArch (also Flatpak) handling NES and SNES, PPSSPP handling PSP as a standalone emulator, and Steam auto-detected for native PC games.

~/Games/
├── NES/
│   ├── metadata.pegasus.txt
│   ├── Contra.zip
│   └── Metroid.zip
├── SNES/
│   ├── metadata.pegasus.txt
│   ├── Chrono Trigger.sfc
│   └── Super Metroid.sfc
└── PSP/
    ├── metadata.pegasus.txt
    └── Patapon.iso

The NES folder’s metadata.pegasus.txt:

collection: Nintendo Entertainment System
shortname: nes
extensions: nes, zip

launch: flatpak run org.libretro.RetroArch
-L
/home/alex/.var/app/org.libretro.RetroArch/config/retroarch/cores/fceumm_libretro.so
{file.path}

The PSP folder’s metadata.pegasus.txt, pointing at a standalone PPSSPP binary instead of a RetroArch core:

collection: PlayStation Portable
shortname: psp
extensions: iso, cso

launch: /usr/bin/PPSSPPSDL
{file.path}

Add ~/Games as a single game directory under Settings → Game directories, confirm Steam detection is enabled, and restart Pegasus. On a successful load, the terminal output from flatpak run org.pegasus_frontend.Pegasus will include scan confirmations similar to this:

[info] Loading providers
[info]   Pegasus Metadata Files: found 3 collections
[info]   Steam: found 1 installed game
[info] Collections ready: Nintendo Entertainment System (2), Super Nintendo (2), PlayStation Portable (1)
[info] Theme loaded: default

From there, the home screen should show three emulated collections plus your Steam library, all navigable with the same controller and the same visual theme, which is the entire point of running Pegasus instead of three separate emulator front ends. Adding a fifth or sixth system from here is mostly repetition: create a new folder, write a metadata.pegasus.txt with the right extensions and launch command for that system’s emulator, and add the folder under Game directories. Once you have one working example for a RetroArch core and one for a standalone emulator binary, as shown above, every additional system is a matter of swapping the collection name, extension list, and executable path rather than solving a new problem from scratch.

Pegasus vs EmulationStation vs ES-DE vs LaunchBox vs Playnite

None of these tools are strict substitutes for one another, but readers evaluating Pegasus usually have one of these four alternatives in mind. The table below lines up the practical differences that matter during setup.

Frontend	Platforms	Theming	Open Source	Best Fit
Pegasus Frontend	Windows, Linux, macOS, Android, embedded	QML-based, full UI control	Yes	Users who want one launcher across multiple OSes without replacing them
EmulationStation (original)	Varies by fork/build	XML-based theming	Yes	Legacy Batocera/RetroPie-style setups
ES-DE	Windows, Linux, macOS, Android (release-dependent)	Polished EmulationStation-derived theming	Yes	Users who want a refined, ready-to-use EmulationStation experience
LaunchBox	Windows only	Built-in theme/skin system	No, commercial	Windows-first users who want paid support and big box art databases
Playnite	Windows only	Plugin and theme marketplace	Yes	Windows gamers who want deep PC-launcher plugin integration

If your library already lives inside an EmulationStation ecosystem through EmuDeck, RetroDECK, or Lakka, the migration cost of moving to Pegasus is lower than it looks, because of the gamelist.xml compatibility mentioned earlier. If you are starting fresh on Windows and have no cross-platform ambitions, Playnite or LaunchBox will likely get you running with less manual metadata writing.

Common Pitfalls When Setting Up Pegasus Frontend

Most Pegasus setup failures trace back to one of these six mistakes, roughly in order of how often they show up in community troubleshooting threads.

• Forgetting the {file.path} placeholder. Without it, Pegasus launches the emulator with no game argument at all, and you get an empty emulator window instead of a loaded ROM.
• Not quoting Windows paths that contain spaces. “C:\Program Files\RetroArch\retroarch.exe” without quotes gets parsed as two separate arguments and fails silently.
• Assuming a Flatpak core path matches a native install path. Flatpak RetroArch stores cores under ~/.var/app/org.libretro.RetroArch/..., not the system-wide /usr/lib/libretro/ path a native install would use.
• Mixing command: and launch: syntax from different tutorials. Both exist in the wild, but they are not always interchangeable across Pegasus versions; stick to one and test it before scaling to your full library.
• Dropping a theme’s files loose instead of inside their own subfolder. Pegasus expects each theme in its own uniquely named folder under themes/ with both theme.cfg and theme.qml present.
• Expecting Pegasus to supply emulators, BIOS files, or ROMs. It is a launcher only. Every emulator, BIOS file, and game file has to be sourced and installed independently, and only from hardware and media you legally own.

Troubleshooting Pegasus Frontend: Common Issues and Fixes

Work through these in order if something in your setup isn’t behaving.

• Blank or black screen on launch. Update your GPU driver, switch back to the default theme to rule out a broken custom theme, and confirm the issue also happens outside Steam if you reached Pegasus through a non-Steam shortcut.
• Game does not launch when selected. Copy the exact launch command out of your metadata file and run it manually in a terminal with a real file path substituted for {file.path}. If it fails there, the problem is the command, not Pegasus.
• Controller is not detected inside Pegasus. Test the pad in your OS’s own controller panel first, then in Pegasus’s input settings, then inside the emulator itself, to isolate which layer is dropping the signal.
• Installed theme never shows up in Settings. Confirm the theme folder sits directly inside themes/ (not nested an extra level deep) and that both theme.cfg and theme.qml exist, then restart Pegasus completely.
• “No Qt platform plugin could be initialized” error on Linux. This usually means missing XCB/Qt system libraries on a native build; installing via the Flatpak package sidesteps the problem entirely since dependencies ship bundled.
• Pegasus crashes on Windows when a game’s video preview plays. Install a codec pack such as K-Lite Basic, since Pegasus relies on the Windows media engine for video playback.
• Flatpak Pegasus can’t see a ROM folder on an external or second drive. Flatpak’s sandbox restricts filesystem access by default; grant the additional path explicitly with Flatseal or a manual flatpak override command before troubleshooting the metadata file itself.
• Game added but Pegasus still shows the old list after an edit. Re-trigger a rescan from Settings → Game directories, or fully restart Pegasus; metadata edits are not watched live.
• Steam Deck Game Mode shows a black screen when launching the non-Steam shortcut. Confirm you added the native Flatpak entry rather than a Windows build running through Proton, since the extra compatibility layer is the most common point of failure on Deck specifically.

Advanced Tips for Power Users

Once the basics are running, a few extra moves make a Pegasus build feel closer to a commercial console menu.

• Scrape artwork with Skraper. Pegasus recognizes the media directory layout that Skraper generates, so you can scrape box art, logos, and video previews once and have Pegasus pick them up automatically without any Pegasus-specific configuration.
• Use portable mode for a drive you carry between PCs. Combined with relative ROM paths, a portable Pegasus install on a USB drive can follow you between a desktop and a laptop without reconfiguring metadata each time.
• Lean on the theme API for custom dashboards. Theme developers can read device information and persist per-theme settings through the api.device and api.memory objects, which is how more advanced community themes build things like battery indicators or per-collection stat screens.
• Import existing EmulationStation metadata instead of starting over. If you already scraped and organized a library for Batocera, RetroPie, or RetroBat, point Pegasus at the same folders; its gamelist.xml support will save hours of rework.
• Keep one tested metadata file as a template per system. Once you’ve verified a working launch line for a given emulator and OS combination, save it separately and reuse it for every new collection of that system type instead of rewriting paths from memory.

Security Considerations Before You Share a Pegasus Build

A metadata.pegasus.txt file is not just descriptive text, it is executable configuration. Anything placed after launch: or command: runs with the same permissions as the user running Pegasus, which means a metadata file copied from an untrusted theme pack or a stranger’s “complete ROM set” download could just as easily launch a malicious script as it could launch RetroArch. Treat downloaded metadata files, launch scripts, and pre-built ROM-and-metadata bundles with the same caution you would apply to any other executable you did not write yourself, and inspect the launch line before trusting it.

Two platform-specific details are worth flagging. On Flatpak Linux, the sandbox restricts which directories Pegasus and your Flatpak emulators can see by default, which is a security feature as much as it is the source of the “can’t find my ROM folder” problem covered in the troubleshooting section above; grant only the specific paths you need rather than opening the sandbox entirely. On Android, Pegasus requests broad storage access on first launch so it can scan for games, so pointing it at a dedicated ROM folder rather than your entire internal storage limits what it can see if a malicious metadata file ever ends up in that scan path.

Is Pegasus Frontend Still Worth Setting Up in 2026?

The honest answer is conditional. Pegasus’s most recent tagged release dates to October 2024, and while the GitHub repository has continued to receive commits since then (the mmatyas repository picked up a GCC 16 compatibility fix on October 2, 2026), it is not shipping on the frequent release cadence of a project in active feature development. For most users, that is not disqualifying: the tool already does what it was built to do, and a launcher does not need weekly updates to keep working against a stable set of emulators.

Where Pegasus earns its keep in 2026 is the handheld gaming PC boom. With devices running SteamOS, Bazzite, and other Linux gaming distributions now common, a controller-first frontend that runs natively on Linux, launches both Steam games and emulated systems from one screen, and does not require replacing the base OS fills a real gap. If your priority is a one-click, zero-configuration emulation box, EmuDeck or Batocera will get you further, faster. If you want one interface that spans a Windows desktop, a Linux handheld, and an Android tablet, and you don’t mind writing a few text files to get there, Pegasus remains one of the only tools that genuinely covers all three.

Frequently Asked Questions

Is Pegasus Frontend free?
Yes. Pegasus is open source and free to download from the official site or GitHub, with no paid tier or license key required — a status iTechGuides reconfirmed as of October 2026.

Does Pegasus come with emulators or ROMs built in?
No. Pegasus is a launcher only. You must install your own emulators separately and supply your own legally obtained ROMs, ISOs, and BIOS files.

Can I run Pegasus on a Steam Deck?
Yes, either as a native Flatpak installed through Discover and added as a non-Steam shortcut, or as a Windows build run through Proton, though the native Flatpak route is simpler and more reliable in Game Mode.

Why isn’t my game showing up after I added the folder?
Confirm the file is named exactly metadata.pegasus.txt, that its extension list includes your game file’s extension, and that you re-added or rescanned the game directory in Settings after any edit.

Can Pegasus import my existing EmulationStation library?
Yes. Pegasus supports EmulationStation v2-style gamelist.xml files, which makes migrating from Batocera, RetroPie, or RetroBat libraries considerably faster than starting from scratch.

Is Pegasus still actively developed?
Its most recent tagged release is from October 2024, but the GitHub repository has continued to see commits since then, the most recent confirmed one being a GCC 16 compatibility fix on October 2, 2026. It is best described as stable and maintained rather than under rapid, frequent development.

How is Pegasus different from EmuDeck or Batocera?
EmuDeck and Batocera are complete emulation packages that install and configure dozens of emulators for you. Pegasus only provides the front-end interface; you still install and configure each emulator yourself, which trades convenience for flexibility.

Where do I get themes for Pegasus?
Community themes circulate through GitHub repositories and emulation forums rather than a single official store. Each theme must be placed in its own subfolder under your platform’s themes directory and contain both a theme.cfg and a theme.qml file to load correctly.

Does Pegasus work on a Raspberry Pi?
Yes. The project explicitly targets embedded hardware including Raspberry Pi and Odroid boards, using the same configuration directory layout and metadata syntax as the desktop Linux build, though more demanding emulated systems should run on more powerful hardware.

Can Pegasus launch Steam and GOG games alongside emulated ROMs?
Yes. On desktop platforms, Pegasus auto-detects installed Steam and GOG libraries with no metadata file required, and displays them in the same browsable interface as your emulated collections.