docs: finish Wave 3 ecosystem section (7 pages)

Remaining ecosystem section — 4 ports + 3 new feed pages + Igir
tool port.

- ecosystem/muos-app.md: ported from Integrations/. muOS/ES
  install paths, .env config, plain-vs-HTTPS guidance, "use Grout
  for full sync" pointer
- ecosystem/tinfoil.md: ported, updated for 5.0 improved title-ID
  handling. Full reverse-proxy basic-auth pattern as alternative
  to DISABLE_DOWNLOAD_ENDPOINT_AUTH
- ecosystem/pkgj.md: ported. All four pkgi feed URLs (Vita/PSP
  games/dlcs), config.txt recipe, .pkg-only format requirement
- ecosystem/fpkgi.md: NEW. PS4/PS5 .pkg feed, config pointer to
  upstream fpkgi docs
- ecosystem/kekatsu.md: NEW. Nintendo DS homebrew loader, honest
  legacy-Wi-Fi caveat (DS's WEP-only radio), workaround patterns
- ecosystem/webrcade.md: NEW. Alternative browser frontend pointed
  at RomM's feed, RomM-vs-WebRcade tradeoff guidance
- ecosystem/igir.md: ported from Tools/. Expanded with the
  {romm}-layout igir template, multi-disc .m3u reorg script,
  read-only RomM mount pattern for the verified output

Builds clean with --strict.
This commit is contained in:
Claude
2026-04-18 18:26:02 +00:00
parent 59f584a530
commit 1b3fe291ea
7 changed files with 610 additions and 35 deletions
+63 -5
View File
@@ -1,10 +1,68 @@
---
status: placeholder
wave: 3
title: fpkgi
description: Install PS4 / PS5 packages from your RomM library via fpkgi homebrew.
---
# fpkgi
!!! warning "Placeholder — RomM 5.0 docs overhaul"
This page is part of the RomM 5.0 documentation overhaul (Wave 3) and
has not been written yet. See the overhaul plan for status and ownership.
[fpkgi](https://github.com/CyberYoshi64/fpkgi) is PS4 / PS5 homebrew for installing `.pkg` packages from custom URL feeds. RomM exposes fpkgi-compatible feeds for its PS4 and PS5 libraries.
New in RomM 5.0 — earlier versions didn't have fpkgi feeds.
## Prerequisites
- **PS4 or PS5** with fpkgi installed (requires CFW / jailbreak — setup is out of scope here).
- **RomM reachable from the console over Wi-Fi** — LAN simplest.
- Games stored as `.pkg` files — fpkgi, like pkgj, only handles the Sony installer format.
## Feed URL
```text
{romm_url}/api/feeds/fpkgi/{platform_slug}
```
Where `{platform_slug}` is:
- `ps4` for PlayStation 4 content.
- `ps5` for PlayStation 5 content.
Example:
```text
http://192.168.1.100:3000/api/feeds/fpkgi/ps4
```
The feed returns JSON in the fpkgi-expected schema — titles, title IDs, content types, URLs back to RomM for the actual downloads.
## Configuring fpkgi
Exact steps depend on the fpkgi version, but the gist:
1. Put RomM's feed URL in fpkgi's config (usually a JSON file on the console; check fpkgi's own docs).
2. Restart fpkgi.
3. The RomM library appears in fpkgi's browse view.
Consult [fpkgi's README](https://github.com/CyberYoshi64/fpkgi) for the current config-file location and format — the project moves faster than these docs.
## Authentication
The `/api/feeds/fpkgi/` endpoints support basic auth the same way `/api/feeds/pkgi/` does. Either:
- Set basic-auth credentials in fpkgi's config if it supports them, OR
- Set `DISABLE_DOWNLOAD_ENDPOINT_AUTH=true` on the RomM server (see the [Tinfoil](tinfoil.md) caveat about public exposure).
## File format — must be `.pkg`
PS4 `.pkg` files specifically — not `.iso`, not compressed. RomM filters to `.pkg` when building the feed. Any other file types are invisible to fpkgi.
## Troubleshooting
- **Feed is empty** — no `.pkg` files on the `ps4` / `ps5` platform. Check your library.
- **Downloads fail with 401** — auth config mismatch. See Authentication section above.
- **Downloads succeed but install fails** — `.pkg` is for a different firmware version. Not a RomM problem.
## See also
- [Feeds reference](../reference/feeds.md) — all feed endpoints.
- [pkgj](pkgj.md) — PS Vita / PSP equivalent.
- [fpkgi upstream](https://github.com/CyberYoshi64/fpkgi) — installer homebrew.
+168 -5
View File
@@ -1,10 +1,173 @@
---
status: placeholder
wave: 3
title: Igir Collection Manager
description: Clean up and normalise your ROM collection with Igir before importing into RomM.
---
# Igir Collection Manager
!!! warning "Placeholder — RomM 5.0 docs overhaul"
This page is part of the RomM 5.0 documentation overhaul (Wave 3) and
has not been written yet. See the overhaul plan for status and ownership.
[Igir](https://igir.io/) is a zero-setup ROM collection manager — sorts, filters, extracts, archives, patches, and reports on collections of any size. Not a RomM companion per se; more a pre-processing tool. Useful for cleaning up a library *before* importing into RomM, so RomM's scans have a better-named, better-organised starting point.
**This is not an official RomM app.** Igir is a separate community project. We document integration here because it's a common workflow and produces a RomM-compatible layout directly.
## When you'd use Igir
- You have a messy collection — inconsistent naming, mixed formats, dumps from multiple sources.
- You want to **match against No-Intro / Redump DAT files** to verify authenticity and standardise names.
- You want to **filter** — only retail releases, strip out hacks, keep only one region, etc.
- You want to move / rename files to RomM's expected platform folder layout.
If your library is already clean, skip Igir. RomM's scans handle naming variations gracefully.
## Directory setup
Igir works on a copy of your ROMs — never in place — to let you iterate on its config without risking the originals.
```text
.
├── dats/ # DAT files (No-Intro, Redump)
├── roms/ # Your original ROM collection (untouched)
├── roms-unverified/ # Working copy Igir will process
└── igir-romm-cleanup.sh # the script below
```
### 1. Make a working copy
```sh
cp -r roms/ roms-unverified/
```
### 2. Download DAT files
DAT files are hash-referenced catalogues Igir matches against.
- **Cartridge systems:** [No-Intro daily](https://datomatic.no-intro.org/index.php?page=download&op=daily) — full DAT compilation.
- **Optical systems (PS1, Saturn, etc.):** [Redump](http://redump.org/downloads/) — per-platform DAT files.
Drop the DAT files into `dats/`. You can use a subset if you only care about specific platforms.
## The cleanup script
Save as `igir-romm-cleanup.sh`:
```bash
#!/usr/bin/env bash
set -ou pipefail
cd "$(dirname "${0}")"
INPUT_DIR=roms-unverified
OUTPUT_DIR=roms-verified
# https://igir.io/
# DAT files: https://datomatic.no-intro.org/index.php?page=download&op=daily
time npx -y igir@latest \
move \
extract \
report \
test \
-d dats/ \
-i "${INPUT_DIR}/" \
-o "${OUTPUT_DIR}/{romm}/" \
--input-checksum-quick false \
--input-checksum-min CRC32 \
--input-checksum-max SHA256 \
--only-retail
```
Make it executable:
```sh
chmod +x igir-romm-cleanup.sh
```
### What it does
- `move extract` — extract archives and move the results.
- `test` — verify checksums against DATs.
- `report` — generate a markdown report of matches / misses.
- `-o ${OUTPUT_DIR}/{romm}/` — output in RomM's expected platform layout (`{romm}` is Igir's RomM-layout template).
- `--only-retail` — exclude betas, hacks, unlicensed dumps.
- `--input-checksum-*` — check files thoroughly (slow but authoritative).
## Run
```sh
./igir-romm-cleanup.sh
```
Output:
- `roms-verified/{platform-slug}/{Proper Game Name}.rom` — identified ROMs in RomM layout.
- `roms-unverified/` — whatever Igir didn't identify, still available for manual review.
- `report.csv` (or similar) — what matched, what didn't.
## Manually migrate leftovers
Some ROMs Igir won't identify (homebrew, hacks with `--only-retail`, truly unknown dumps). Move them manually preserving the folder shape:
```sh
npx -y igir@latest \
move \
-i roms-unverified/ \
-o roms-verified/ \
--dir-mirror
```
This keeps the original subfolder structure but normalises extensions.
## Multi-disc reorganisation
Igir outputs multi-disc games as separate folders, which confuses RomM's multi-file game detection. Collapse them:
```sh
cd roms-verified/ps # or psx, or whatever your PSX slug is
ls -d *Disc* | while read file; do
game=$(echo "${file}" | sed -E 's/ ?\(Disc.*//')
mkdir -p "${game}"
mv "${file}" "${game}"
m3u="${game}/${game}.m3u"
touch "${m3u}"
echo "${file}" >> "${m3u}"
done
```
Before:
```text
Final Fantasy VII (Disc 1) (USA)/
Final Fantasy VII (Disc 2) (USA)/
Final Fantasy VII (Disc 3) (USA)/
```
After:
```text
Final Fantasy VII (USA)/
Final Fantasy VII (Disc 1) (USA)/
Final Fantasy VII (Disc 2) (USA)/
Final Fantasy VII (Disc 3) (USA)/
Final Fantasy VII (USA).m3u
```
The `.m3u` is a playlist RomM respects for launching multi-disc games.
## Import into RomM
Once `roms-verified/` looks right, mount it as RomM's library:
```yaml
services:
romm:
volumes:
- /path/to/roms-verified:/romm/library/roms:ro
```
Read-only is safer — if you need Igir to re-clean, you work in the parallel `roms-unverified/` and re-promote to `roms-verified/`.
Run a scan from RomM. Everything should match cleanly against providers.
## See also
- [Igir docs](https://igir.io/) — the upstream reference.
- [Folder Structure](../getting-started/folder-structure.md) — what RomM expects on-disk.
- [Metadata Providers](../administration/metadata-providers.md) — how RomM matches after Igir's done its work.
+56 -5
View File
@@ -1,10 +1,61 @@
---
status: placeholder
wave: 3
title: Kekatsu
description: Nintendo DS multiboot loader — install DS games from RomM via custom feed.
---
# Kekatsu
!!! warning "Placeholder — RomM 5.0 docs overhaul"
This page is part of the RomM 5.0 documentation overhaul (Wave 3) and
has not been written yet. See the overhaul plan for status and ownership.
**Kekatsu** is Nintendo DS homebrew for loading games from a custom URL feed. RomM exposes a Kekatsu-compatible feed for its DS library.
New in RomM 5.0.
## Prerequisites
- A Nintendo DS with Kekatsu installed (requires a flashcart or homebrew launcher).
- **RomM reachable from the DS over Wi-Fi** — the DS's Wi-Fi is WEP / old WPA only, so this typically means a dedicated legacy-SSID on your router or a travel router bridging the DS to your modern network.
- DS games in `.nds` format.
## Feed URL
```text
{romm_url}/api/feeds/kekatsu/{platform_slug}
```
For standard DS content, the platform slug is `nds`:
```text
http://192.168.1.100:3000/api/feeds/kekatsu/nds
```
## Configuring Kekatsu
Exact config steps depend on your Kekatsu build; the shared concept is "point the app at this URL and it fetches the manifest". Consult Kekatsu's own docs for the current config-file location.
## File format
`.nds` only. DSi Ware / iQue / other formats aren't listed in the feed.
## Authentication
Kekatsu can send basic auth. Either configure it on the DS side or enable `DISABLE_DOWNLOAD_ENDPOINT_AUTH=true` on RomM (see the [Tinfoil download-auth caveat](tinfoil.md#prerequisites)).
## Why the legacy-Wi-Fi hassle
The DS's original Wi-Fi hardware supports WEP and an older WPA variant only. Modern home routers usually don't. Workarounds:
- **Dedicated DS-friendly SSID.** Many routers allow per-SSID security — add a WEP one just for the DS.
- **Travel router in bridge mode.** A cheap travel router configured for WEP uplinks to your main (secure) network.
- **Use a DSi, 3DS, or homebrew replacement driver** — these support modern security.
If none of this is appealing, Kekatsu-over-LAN isn't going to work; fall back to sideloading via flashcart or similar.
## Troubleshooting
- **Feed is empty** — no `.nds` files on the `nds` platform.
- **DS can't see the network** — see the legacy-Wi-Fi section above.
- **Downloads fail** — either network timeout (LAN latency over WEP is rough) or disk space. Retry one game at a time.
## See also
- [Feeds reference](../reference/feeds.md) — all feed endpoints.
- Kekatsu upstream — find via the RomM Discord `#kekatsu` or community links (project moves).
+95 -5
View File
@@ -1,10 +1,100 @@
---
status: placeholder
wave: 3
title: muOS App
description: Official RomM app for muOS and EmulationStation handhelds — fetch games wirelessly.
---
<!-- trunk-ignore-all(markdownlint/MD033) -->
# muOS App
!!! warning "Placeholder — RomM 5.0 docs overhaul"
This page is part of the RomM 5.0 documentation overhaul (Wave 3) and
has not been written yet. See the overhaul plan for status and ownership.
<div align="center">
<img src="../../resources/romm/integrations/muos.svg" height="200px" width="200px" alt="RomM muOS logo">
</div>
[muOS](https://muos.dev) is a custom firmware (CFW) for handheld devices — Anbernic, Miyoo, and similar. The **muOS App** connects to your RomM instance and fetches ROMs wirelessly.
- **Repo:** [rommapp/muos-app](https://github.com/rommapp/muos-app)
- **Platforms:** muOS, EmulationStation (via PortMaster)
- **Use case:** fetch games on-demand from RomM without cable-swapping SD cards.
## muOS-specific flavour vs Grout
This page covers the **muOS App** — a lightweight client focused on game fetching. For the fuller push/pull sync experience (saves back to RomM, play-session reporting), use [Grout](grout.md) instead. They're two different clients for the same family of devices.
- **muOS App** — lightweight; pulls ROMs, no save sync.
- **Grout** — full sync; ROMs + saves + states + play sessions.
Pick based on what you need.
## Installing — muOS
Installation uses muOS's [Archive Manager](https://muos.dev/installation/archive):
1. Download the latest `RomM.muOS.x.x.x.muxapp` from [GitHub Releases](https://github.com/rommapp/muos-app/releases/latest).
2. Move the `.muxapp` file to `/mnt/mmc/ARCHIVE/` on the device (USB, SD swap, or SSH).
3. On the device: **Applications → Archive Manager** → select `RomM.muOS.x.x.x.muxapp` → install.
4. Once installed, copy `/mnt/mmc/MUOS/application/RomM/env.template` to `.env` in the same folder.
5. Edit `.env` (SSH works well; so does any method that writes to SD card):
```dotenv
HOST=http://192.168.1.100:3000
USERNAME=yourusername
PASSWORD=yourpassword
```
6. Launch from **Applications → RomM** on the device.
!!! tip "Use a dedicated account or token"
The username/password lives in plaintext on the SD card. Use a dedicated Viewer-role account for the handheld, not your admin credentials.
Once RomM's 5.0 Client API Token flow is wired into the muOS app (planned), prefer pairing via token instead of password.
## Installing — EmulationStation (via PortMaster)
For EmulationStation-based devices:
1. Download the `RomM App.sh` file and the `RomM/` folder.
2. Copy to `roms/ports/` on the device.
3. SSH / shell in: `chmod +x "RomM App.sh"`.
4. Launch EmulationStation → **Ports** → RomM App.
## Network requirements
The handheld has to reach your RomM instance over Wi-Fi.
Simplest setup:
- **Same LAN.** Handheld and RomM server on the same SSID. `HOST` = server IP + port.
- **Plain HTTP works** on a trusted LAN; no reverse proxy needed.
More-involved setups:
- **Reverse proxy with TLS.** `HOST=https://romm.example.com`. HTTPS works but introduces cert-validation risk on handhelds (some fail strict TLS).
- **Remote access via VPN.** Install Tailscale or similar on the handheld (if supported) — lets the handheld reach RomM from outside the LAN.
## Using the app
Launch RomM app → browse platforms → select a game → download.
Downloaded games appear in the device's usual ROM folder for the platform, so muOS / ES picks them up on the next library refresh.
## What it doesn't do (yet)
- **Save sync** — this app is pull-only. For bidirectional sync, use [Grout](grout.md).
- **Play session tracking** — not ingested into RomM.
- **Firmware download** — not in scope.
If you need these, Grout is the app.
## Troubleshooting
- **Can't connect** — wrong `HOST` in `.env`, or the handheld isn't on the same network as RomM. Ping RomM's IP from the handheld's shell to confirm reachability.
- **"Authentication failed"** — password wrong, or `DISABLE_USERPASS_LOGIN=true` on the RomM side. Either re-enable user/pass login or use a token once supported.
- **Downloaded games don't show in the platform** — refresh the library from muOS's UI. If they still don't appear, the platform folder in `HOST_PATH` is wrong — check muOS's expected layout.
## See also
- [Grout](grout.md) — the fuller sync client for the same device family.
- [Client API Tokens](client-api-tokens.md) — safer auth than plaintext credentials in `.env`.
- [Mobile & TV](../using/mobile-and-tv.md) — handheld usage patterns.
- [rommapp/muos-app](https://github.com/rommapp/muos-app) — source, issues, releases.
+71 -5
View File
@@ -1,10 +1,76 @@
---
status: placeholder
wave: 3
title: pkgj
description: Install PS Vita and PSP games from your RomM library via pkgj homebrew.
---
# pkgj
!!! warning "Placeholder — RomM 5.0 docs overhaul"
This page is part of the RomM 5.0 documentation overhaul (Wave 3) and
has not been written yet. See the overhaul plan for status and ownership.
[pkgj](https://github.com/blastrock/pkgj) is PS Vita homebrew for installing `.pkg`-format games and DLC. Default config points at well-known community URLs; point it at RomM's feed endpoints instead and you can install from your library over Wi-Fi.
## Prerequisites
- **PS Vita** with [pkgj](https://github.com/blastrock/pkgj) installed.
- A way to edit files on the Vita — [VitaShell](https://github.com/TheOfficialFloW/VitaShell) works well.
- **RomM reachable from the Vita** — same LAN ideal; HTTP or HTTPS both work.
- Your games stored as `.pkg` files (pkgj requires this format — it won't work with `.iso` or other formats).
## Feed URLs
RomM exposes four pkgi-compatible feeds:
| Content | URL |
| --- | --- |
| PS Vita games | `{romm_url}/api/feeds/pkgi/psvita/game` |
| PS Vita DLCs | `{romm_url}/api/feeds/pkgi/psvita/dlc` |
| PSP games | `{romm_url}/api/feeds/pkgi/psp/game` |
| PSP DLCs | `{romm_url}/api/feeds/pkgi/psp/dlc` |
## Configuring pkgj
1. Connect the Vita to your PC over USB with VitaShell running.
2. Open `/pkgj/config.txt` on the Vita in a text editor.
3. Append lines for each feed you have content for:
```ini
url_games {romm_url}/api/feeds/pkgi/psvita/game
url_dlcs {romm_url}/api/feeds/pkgi/psvita/dlc
url_psp_games {romm_url}/api/feeds/pkgi/psp/game
url_psp_dlcs {romm_url}/api/feeds/pkgi/psp/dlc
```
Replace `{romm_url}` with your actual RomM URL (e.g. `http://192.168.1.100:3000`).
4. Save and disconnect from VitaShell.
5. On the Vita: open pkgj → press `△` to open the menu → **Refresh**.
## Using pkgj
Once configured, pkgj shows your RomM PS Vita / PSP library. Select a title → install. pkgj downloads the `.pkg` from RomM and installs it to the Vita.
## File format requirements
**RomM only lists `.pkg` files in pkgi feeds.** If your Vita or PSP games are in `.iso`, `.chd`, or other formats, they won't appear in pkgj.
Why: pkgj is designed around the Sony installer format. Other formats aren't installable via the same mechanism.
If you have non-`.pkg` files you want on the Vita, you'll need to convert them or use a different workflow (FTP through VitaShell, for example).
## Authentication
The pkgi feeds honour basic auth. If your RomM doesn't have `DISABLE_DOWNLOAD_ENDPOINT_AUTH=true`, pkgj sends basic auth headers.
Unlike [Tinfoil](tinfoil.md), pkgj handles auth natively — you don't have to turn off download auth on RomM to use it. Still, some users prefer disabling auth for a smoother first-time flow; either path works.
## Troubleshooting
- **"can't get list: list is empty"** — you don't have any `.pkg` content for the feeds you configured. Check your library actually contains `.pkg` files on the corresponding platforms.
- **Refresh returns an error** — URL in `config.txt` is wrong. Verify the feed URL in a browser first (returns JSON).
- **Download fails partway** — LAN connectivity or disk space on Vita. pkgj reports both.
- **Game installs but won't boot** — the `.pkg` is for a different firmware / region. Not a RomM issue.
## See also
- [Feeds reference](../reference/feeds.md) — full feeds catalogue.
- [Tinfoil](tinfoil.md) — Switch equivalent.
- [fpkgi](fpkgi.md) — PS4 / PS5 equivalent.
- [pkgj](https://github.com/blastrock/pkgj) — upstream homebrew.
+99 -5
View File
@@ -1,10 +1,104 @@
---
status: placeholder
wave: 3
title: Tinfoil
description: Install Nintendo Switch games from your RomM library over Wi-Fi via Tinfoil's feed mechanism.
---
<!-- trunk-ignore-all(markdownlint/MD033) -->
# Tinfoil
!!! warning "Placeholder — RomM 5.0 docs overhaul"
This page is part of the RomM 5.0 documentation overhaul (Wave 3) and
has not been written yet. See the overhaul plan for status and ownership.
<div align="center">
<img src="../../resources/romm/integrations/tinfoil.svg" height="200px" width="200px" alt="RomM Tinfoil logo">
</div>
[Tinfoil](https://tinfoil.io) is Nintendo Switch homebrew for installing software from custom feed URLs. Point it at RomM's Tinfoil feed endpoint, and your Switch library becomes installable from the Switch itself over Wi-Fi.
## Prerequisites
- **RomM 3.5.0 or newer.** Tinfoil feeds landed in that release. Much better in 5.0.
- **`DISABLE_DOWNLOAD_ENDPOINT_AUTH=true`** on your RomM instance. Tinfoil can't send a bearer token, so the downloads endpoint has to be openable. **Only enable this when RomM isn't directly exposed to the public internet** — see [Authentication → Download-endpoint auth bypass](../administration/authentication.md#download-endpoint-auth-bypass).
- **Tinfoil installed on the Switch.** Setup varies; follow Tinfoil's own docs.
- **A Switch that can reach RomM over Wi-Fi.** Same LAN is easiest; remote reachability requires reverse proxy + cert that the Switch accepts.
## Feed URL
```text
{romm_url}/api/feeds/tinfoil
```
No authentication — the endpoint works as long as `DISABLE_DOWNLOAD_ENDPOINT_AUTH=true`.
## Configuring Tinfoil
1. Launch Tinfoil on the Switch → **File Browser**.
2. Scroll to the file-server list → press `-` (minus) to add a new one.
3. Enter:
- **Protocol:** `http` or `https` (depending on your RomM reverse-proxy setup).
- **Host:** RomM's hostname or IP.
- **Port:** RomM's port (usually 80 or 443).
- **Path:** `/api/feeds/tinfoil`
- **Username:** your RomM username (optional — Tinfoil can send basic auth; RomM tries it).
- **Password:** your RomM password.
- **Title:** anything (e.g. `RomM Switch`).
- **Enabled:** yes.
4. Press `X` to save.
5. Close and reopen Tinfoil. The library is parsed.
On reopen, you should see a custom message of the day: `RomM Switch Library`. If you do, it's working.
![Tinfoil after setup](../resources/tinfoil/tinfoilscreen.jpg)
## Using it
- **New Games** tab in Tinfoil — browseable list of your Switch ROMs.
- **File Browser** — pick a file to install directly.
Tinfoil handles the install flow like any homebrew: downloads the `.nsp` / `.xci`, installs to eMMC or SD, cleans up.
## Filename requirements — TitleIDs
Tinfoil needs **Switch title IDs** in the filenames to parse and categorise games. The format:
```text
Super Mario Odyssey [0100000000010000][v0].nsp
```
The bracketed `[0100000000010000]` is the title ID. Without it, Tinfoil shows the file but doesn't parse it into the New Games tab or match against Switch metadata.
![TitleID example](../resources/tinfoil/titleid.jpg)
!!! info "Improvement coming"
5.0 improves RomM's title-ID handling — it auto-detects title IDs from filenames that have them and feeds Tinfoil regardless of whether your filename format is standard. The guidance above still applies for older RomM releases.
### Finding title IDs
- [No-Intro](https://datomatic.no-intro.org/) lists them per title.
- [tinfoildb.com](https://tinfoildb.com/) and similar databases are searchable.
- Pre-organised ROM sets ship with title IDs in filenames already.
### Renaming files
Once renamed, the next time Tinfoil opens it re-parses.
## Alternative: through a reverse proxy
If you put RomM behind a reverse proxy, the proxy can handle auth separately from RomM. For example:
- Proxy challenges for basic auth before reaching RomM.
- RomM itself has `DISABLE_DOWNLOAD_ENDPOINT_AUTH=true`.
Tinfoil sends basic auth upstream; proxy accepts and forwards; RomM serves.
This gets you authenticated Tinfoil feeds without making RomM itself world-readable.
## Troubleshooting
- **"can't get list: list is empty"** — either your RomM library has no `.nsp`/`.xci` files that Tinfoil recognises, or filenames lack title IDs.
- **Tinfoil connects but nothing in New Games** — title IDs missing from filenames. Rename.
- **Tinfoil can't connect at all** — LAN reachability issue, or wrong port in the feed setup. Try `http://<ip>:<port>/api/feeds/tinfoil` in a browser; you should get JSON.
- **Downloads fail with 401** — `DISABLE_DOWNLOAD_ENDPOINT_AUTH=true` isn't set on RomM, or you forgot to restart the container after setting it.
## See also
- [Authentication → Download-endpoint auth bypass](../administration/authentication.md#download-endpoint-auth-bypass) — the `DISABLE_DOWNLOAD_ENDPOINT_AUTH` caveat.
- [Feeds reference](../reference/feeds.md) — full feeds catalogue.
+58 -5
View File
@@ -1,10 +1,63 @@
---
status: placeholder
wave: 3
title: WebRcade
description: Load your RomM library into WebRcade — an alternative browser-based retro frontend.
---
# WebRcade
!!! warning "Placeholder — RomM 5.0 docs overhaul"
This page is part of the RomM 5.0 documentation overhaul (Wave 3) and
has not been written yet. See the overhaul plan for status and ownership.
[WebRcade](https://www.webrcade.com/) is a browser-based retro console frontend. It plays games in-browser, similar to RomM's built-in EmulatorJS player — the difference is UX: WebRcade has its own aesthetic, a curated preset-app model, and feed-based import.
If you prefer WebRcade's look-and-feel but want to point it at your RomM library, use the feed endpoint below.
## Feed URL
```text
{romm_url}/api/feeds/webrcade
```
WebRcade-compatible JSON listing every ROM in your library with metadata and direct download URLs back to RomM.
## Setting up WebRcade
1. Open [WebRcade.com](https://www.webrcade.com/) in a browser.
2. Create an account (or use it unauthenticated — limited features).
3. Go to **My WebRcade → Add Feed**.
4. Enter RomM's feed URL: `{romm_url}/api/feeds/webrcade`.
5. Save. Your RomM library appears as WebRcade apps.
## Authentication
The `/api/feeds/webrcade` endpoint sends basic auth if WebRcade provides credentials. Either:
- Configure basic auth on WebRcade's feed-add screen (if it offers that), OR
- Set `DISABLE_DOWNLOAD_ENDPOINT_AUTH=true` on RomM.
The same security caveats apply — see [Tinfoil prerequisites](tinfoil.md#prerequisites) for context on turning off download auth.
## RomM vs WebRcade
Why would you use WebRcade over RomM's built-in player?
- **Preset/curated lists.** WebRcade maintains a catalogue of vetted content that's searchable inside the app.
- **Different UI.** More console-like, less library-like.
- **Per-game launch from WebRcade feeds.** You can mix-and-match RomM content with WebRcade's own catalogue in one frontend.
When to stay with RomM's player:
- **You want library management.** WebRcade is frontend-only; RomM owns the metadata and scanning.
- **You want user accounts + collections + per-user progress.** WebRcade is single-user-ish.
- **You want [Netplay](../using/netplay.md)** — RomM has it; WebRcade doesn't.
Totally reasonable to run both — WebRcade as a launcher UI pointed at RomM for the library.
## Troubleshooting
- **Feed shows no games** — WebRcade filters by its own supported-platform set. Games on unsupported platforms won't show.
- **Games don't launch** — the ROM format isn't supported by WebRcade's emulator cores (which differ from EmulatorJS's). Check WebRcade's supported list.
- **Download fails** — same auth / URL issues as other feeds. Check `{romm_url}/api/feeds/webrcade` returns JSON in a browser.
## See also
- [Feeds reference](../reference/feeds.md) — all feed endpoints.
- [In-Browser Play](../using/in-browser-play.md) — RomM's built-in player.
- [WebRcade](https://www.webrcade.com/) — upstream frontend.