Skip to content
Klutch.sh Docs

Deploying RomM

Introduction

RomM (ROM Manager) is a beautiful, self-hosted ROM manager designed to organize and present your retro game collection. With automatic metadata fetching from IGDB and MobyGames, RomM transforms your ROM files into a visually stunning, searchable library accessible from any web browser.

Key highlights of RomM:

  • Beautiful Interface: Modern, responsive web UI for browsing games
  • Metadata Fetching: Automatic game information from IGDB and MobyGames
  • Multi-Platform: Support for numerous retro gaming platforms
  • Cover Art: Automatic cover art and screenshot downloading
  • Search and Filter: Find games quickly across your collection
  • Collections: Create custom game collections
  • Multi-User: Support for multiple user accounts
  • File Management: Download and manage ROM files through the web
  • Mobile Friendly: Responsive design for all devices
  • Docker Native: Easy containerized deployment
  • Open Source: GPL-3.0 licensed with active development

This guide walks through deploying RomM on Klutch.sh using Docker and organizing your ROM collection.

Why Deploy RomM on Klutch.sh

Deploying RomM on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh automatically builds and deploys RomM without complex configuration.

Persistent Storage: Attach persistent volumes for your ROM library and metadata that survive container restarts.

HTTPS by Default: Klutch.sh provides automatic SSL for secure access to your library from anywhere.

Always-On Availability: Your ROM library remains accessible 24/7.

Environment Variable Management: Securely store API keys through Klutch.sh.

Prerequisites

Before deploying RomM on Klutch.sh, ensure you have:

Preparing Your Repository

Create a GitHub repository containing your Dockerfile for RomM deployment.

Repository Structure

romm-deploy/
├── Dockerfile
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM rommapp/romm:latest


# Set environment variables
ENV ROMM_DB_DRIVER=sqlite
ENV IGDB_CLIENT_ID=${IGDB_CLIENT_ID}
ENV IGDB_CLIENT_SECRET=${IGDB_CLIENT_SECRET}
ENV ROMM_AUTH_SECRET_KEY=${ROMM_AUTH_SECRET_KEY}


# Create necessary directories
RUN mkdir -p /romm/library /romm/resources /romm/config


# Expose the web interface port
EXPOSE 8080


# The base image includes the default entrypoint

Environment Variables Reference

VariableRequiredDescription
IGDB_CLIENT_IDYesIGDB/Twitch client ID for metadata
IGDB_CLIENT_SECRETYesIGDB/Twitch client secret
ROMM_AUTH_SECRET_KEYYesSecret key for authentication (generate with openssl rand -hex 32)
ROMM_DB_DRIVERNoDatabase driver (default: sqlite)

Deploying RomM on Klutch.sh

    Obtain IGDB Credentials

    1. Register at the Twitch Developer Portal
    2. Create an application to get Client ID and Secret
    3. These are used to fetch game metadata

    Generate Authentication Secret

    Create a secure secret key:

    Terminal window
    openssl rand -hex 32

    Push Your Repository to GitHub

    Commit and push your Dockerfile to GitHub.

    Create a New Project on Klutch.sh

    Navigate to the Klutch.sh dashboard and create a new project with a descriptive name like “romm” or “rom-library”.

    Create a New App

    Within your project, create a new app. Connect your GitHub account and select the repository containing your RomM Dockerfile.

    Configure HTTP Traffic

    In the deployment settings:

    • Select HTTP as the traffic type
    • Set the internal port to 8080

    Set Environment Variables

    Add the following environment variables:

    VariableValue
    IGDB_CLIENT_IDYour Twitch client ID
    IGDB_CLIENT_SECRETYour Twitch client secret
    ROMM_AUTH_SECRET_KEYYour generated secret

    Attach Persistent Volumes

    Add the following volumes:

    Mount PathRecommended SizePurpose
    /romm/library100+ GBYour ROM collection
    /romm/resources10 GBCover art and metadata
    /romm/config1 GBConfiguration and database

    Deploy Your Application

    Click Deploy to start the build process.

    Access RomM

    Once deployment completes, access RomM at your app URL.

Initial Configuration

First-Time Setup

  1. Access the RomM web interface
  2. Create your administrator account
  3. Configure platform settings

Organizing Your Library

Structure your ROMs by platform:

/romm/library/
├── nes/
│   └── Game Title.nes
├── snes/
│   └── Game Title.sfc
├── genesis/
│   └── Game Title.md
├── gba/
│   └── Game Title.gba
├── n64/
│   └── Game Title.z64
└── psx/
    └── Game Title.bin

Scanning Your Library

  1. Navigate to Settings > Library
  2. Configure platform paths
  3. Trigger a library scan
  4. RomM will fetch metadata for discovered games

Matching Games

  1. Review unmatched games
  2. Manually match games that weren’t auto-detected
  3. Edit metadata as needed

Using RomM

Browsing Your Collection

  • Browse by platform
  • Search across all games
  • View detailed game information
  • See cover art and screenshots

Managing Collections

  1. Create custom collections
  2. Add games to collections
  3. Use collections as playlists or favorites

Downloading ROMs

  • Download individual ROM files
  • Access your library from any device
  • Secure authentication protects your collection

Additional Resources

Conclusion

Deploying RomM on Klutch.sh gives you a beautiful, organized way to manage your retro game collection. With automatic metadata fetching and a modern interface, RomM transforms your ROM files into a proper game library accessible from anywhere with secure HTTPS access.