ApolloLauncherExport

A Python script to generate launcher files for Pegasus Frontend, Daijishō (Android), ES-DE (EmulationStation Desktop Edition), and generic platforms to stream PC games via Apollo. Artemis is used as the client (referred to as Apollo/Artemis in this script's context for the client-side launchers it generates).

This script reads your Apollo server's application list and host details to create the necessary files for these frontends, enabling a seamless game launching experience. This script is specifically for Apollo and Artemis and does not support the original Sunshine and Moonlight.

Features

• Pegasus Frontend: Generates .art files and metadata.pegasus.txt with app images and enhanced metadata support.
• Daijishō: Generates .art files and an Artemis.json platform/player configuration file.
• ES-DE: Generates .art files, an Apollo.uuid (host UUID file), es_systems.xml (system configuration), and es_find_rules.xml (emulator configuration).
• Generic Platform: Generates basic launcher files for custom or unsupported frontends.
• Enhanced metadata and asset fetching (available for Pegasus, Daijishō, and ES-DE):
  • Fetches game assets (logos, grid images, marquees, tiles) from SteamGridDB
  • Fetches rich game metadata (summaries, descriptions, ratings, genres, release dates, developers, publishers) from IGDB.com
  • Downloads and organizes media assets into appropriate directory structures for each frontend
  • Enriches metadata files with detailed game information for better frontend presentation
• Parses Apollo server's apps.json and sunshine_state.json from sunshine.conf file.
• Provides a graphical user interface (GUI) to select configuration files, choose target frontends, and configure scraping options.
• Smart asset management: Skips image fetching for existing ROM files while still updating metadata when "Skip existing" option is enabled.
• Outputs organized files into an export/<frontend_name>/<host_name>/ directory.

Requirements

• Download from Releases

or

• Python 3.8+
• Core dependencies (for basic functionality):
  • Standard Python libraries only (tkinter, configparser, json, shutil, pathlib). No external packages are needed for basic launcher generation.
• Enhanced features dependencies (optional, for metadata and asset fetching):
  • requests library: pip install requests
  • igdb-api-v4 library: pip install igdb-api-v4
  • or simply pip install -r requirements.txt
• Apollo server installed and configured on your host PC.
• Artemis installed on the device running Daijishō or ES-DE (if ES-DE is on Android).

API Setup (Optional - For Enhanced Features)

SteamGridDB API Key

SteamGridDB provides high-quality game assets including logos, grid images, and artwork.

1. Create a SteamGridDB account: Visit steamgriddb.com and sign up for a free account.
2. Navigate to API preferences: Go to SteamGridDB Preferences > API
3. Generate an API key: Click "Generate API Key" to create your personal API key.
4. Copy the API key: Save this key - you'll enter it in the application's GUI.

Features provided: Game logos, grid images (steam format), marquees, and tile artwork for better visual presentation in Pegasus Frontend.

IGDB API Credentials

IGDB (Internet Game Database) provides comprehensive game metadata including descriptions, ratings, and release information.

Note: IGDB uses Twitch's API infrastructure, so you'll need to create a Twitch application.

1. Create a Twitch Developer account: Visit dev.twitch.tv and log in with your Twitch account (create one if needed).
2. Navigate to Console: Go to Twitch Developer Console
3. Create a new application:
   • Click "Register Your Application"
   • Name: Choose any name (e.g., "ApolloLauncherExport")
   • OAuth Redirect URLs: Enter http://localhost (required field, not used by this script)
   • Category: Select "Application Integration"
   • Click "Create"
4. Get your credentials:
   • Client ID: Copy the "Client ID" from your application page
   • Client Secret: Click "New Secret" to generate a client secret, then copy it
5. Important: The script will automatically fetch and manage the App Access Token using your Client ID and Secret.

Features provided: Game summaries, detailed descriptions, ratings, genres, release dates, developer/publisher information, and additional game metadata for richer Pegasus collections.

API Documentation: For more details, see IGDB API Documentation

Setup

1. Prepare Apollo Configuration

This script needs to know where your Apollo server's apps.json and sunshine_state.json files are located. The script will prompt you to choose the sunshine.conf file to read the configs automatically.

2. Configure API Keys (Optional)

For enhanced metadata and asset fetching:

1. Run the script: python export.py
2. Set SteamGridDB API Key: Click the "Set" button next to "SteamGridDB API Key" and enter your API key from the setup above.
3. Set IGDB Credentials: Click the "Set" button next to "IGDB Credentials" and enter your Client ID and Client Secret from the setup above.

Note: These steps are optional. The script works without API keys but will only generate basic launcher files without enhanced metadata or downloaded assets.

3. Run the Script

1. Download or clone this project.
2. Run the script: python export.py
   • If you have a PyInstaller-compiled .exe version, simply run the executable.
3. A GUI window titled "Apollo Launcher Export" will appear with your configured settings.

4. Generate Launcher Files

1. Choose options (available for Pegasus, Daijishō, and ES-DE):
   • Check "Download game assets from SteamGridDB" to fetch high-quality game images
   • Check "Fetch game metadata from IGDB.com" to enrich your game collections with detailed information
   • Check "Skip image fetching for existing ROM files" to speed up subsequent runs while still updating metadata
   • Note: Generic platform generation does not support metadata and image fetching
2. Select frontend: Click "Pegasus", "Daijishō", "ES-DE", or "Generic" button, depending on which frontend you want to generate files for.
3. Select Apollo config: A file dialog will prompt you to "Select Apollo config file (sunshine.conf)". Select the helper .conf file you created in Step 1.
4. The script will process your Apollo server data and create the launcher files.
   • Output directory: export/<frontend_name>/<your_apollo_host_name>/ (e.g., export/pegasus/My Gaming PC/ where "My Gaming PC" is your sunshine_name from the .conf)
   • A confirmation message will appear when complete.

Frontend Configuration

Pegasus Frontend

• Run the script and select "Pegasus".
• Select your sunshine.conf file.
• A new folder will be created under export/Pegasus/<Your Host Name>/.
• This folder contains:
  • metadata.pegasus.txt: The main metadata file for Pegasus. It defines a collection for your streamed games, using your computer's name (from sunshine.conf) as the collection title. Enhanced with rich metadata from IGDB including game summaries, descriptions, ratings, genres, release dates, and developer information when API access is configured.
  • A series of .art files, one for each game, named with the game's name. Each file contains the game's name and its UUID.
  • Media assets (when SteamGridDB/IGDB is enabled): A media/ directory containing subdirectories for each game with high-quality images:
    • steam - Grid images from SteamGridDB
    • logo - Game logos from SteamGridDB
    • marqee - Marquee images from SteamGridDB
    • tile - Tile artwork from SteamGridDB
    • boxFront - Cover art from IGDB (if not available from SteamGridDB)
    • screenshot - Game screenshots from IGDB
    • background - Background artwork from IGDB
• Setup in Pegasus Frontend:
  1. Copy the generated folder (e.g., <Your Host Name>) into one of your Pegasus game directories.
  2. In Pegasus, go to Settings -> Set game directories and ensure the path to this folder (or its parent) is added.
  3. Pegasus should now find your games with rich metadata and artwork. The launch command is configured to use am start to launch Moonlight directly with the correct host and game UUIDs.

Daijishō

The script generates an Artemis.json platform file and multiple *.art files (one for each game). Enhanced with metadata and asset fetching support.

1. Transfer Files:

   • Copy the generated Artemis.json file.
   • Copy all the *.art files from the output directory (e.g., export/Daijishō/My Gaming PC/) to a folder on your Android device (e.g., /sdcard/Roms/Artemis/).
   • If scraping was enabled: Copy the media/ directory containing game assets to your device alongside the .art files.

2. Import Platform in Daijishō:

   • Open Daijishō.
   • Go to Settings > Library > Import platform.
   • Navigate to and select the Artemis.json file you copied to your device.
   • This step is similar to adding a platform manually as described in the [