# RomM Feed Generation Formats: Tinfoil, WebRcade, PKGi, and Variant Feeds Explained

> Explore RomM feed generation formats including Tinfoil, WebRcade, and PKGi. Learn how RomM supports these popular formats for easy content management.

- Repository: [The RomM Project/romm](https://github.com/rommapp/romm)
- Tags: deep-dive
- Published: 2026-07-06

---

**RomM supports Tinfoil, WebRcade, PKGi, and derivative formats including fPKGi, Kekatsu, and pkgj via RESTful endpoints defined in [`backend/endpoints/feeds.py`](https://github.com/rommapp/romm/blob/main/backend/endpoints/feeds.py).**

The RomM game library manager (rommapp/romm) automatically generates compatible feeds for popular homebrew launchers and emulator frontends. These feed generation formats enable direct integration with Nintendo Switch, PlayStation, and other console ecosystems, allowing browsers to fetch ROM metadata and download links directly from your self-hosted instance.

## Core Feed Generation Formats

RomM implements three primary feed formats in its backend architecture, each targeting specific console platforms and launcher applications.

### Tinfoil JSON Feeds for Nintendo Switch

The **Tinfoil** format provides a JSON feed compatible with the Tinfoil Nintendo Switch launcher. This endpoint returns game metadata and download URLs formatted for the Switch homebrew scene.

Access the feed via:

```bash
GET /api/feeds/tinfoil?slug=<platform-slug>

```

The route handler resides in [`backend/endpoints/feeds.py`](https://github.com/rommapp/romm/blob/main/backend/endpoints/feeds.py), with response schemas defined in [`backend/endpoints/responses/feeds.py`](https://github.com/rommapp/romm/blob/main/backend/endpoints/responses/feeds.py).

### WebRcade XML Feeds

**WebRcade** feeds follow the XML specification defined by the WebRcade project, enabling browser-based arcade and console emulation. Unlike the JSON-based formats, WebRcade requires XML serialization for compatibility with the frontend parser.

The endpoint is available at:

```bash
GET /api/feeds/webrcade

```

Response models in [`backend/endpoints/responses/feeds.py`](https://github.com/rommapp/romm/blob/main/backend/endpoints/responses/feeds.py) handle the XML structure generation, ensuring proper namespacing and element ordering required by WebRcade clients.

### PKGi Feeds for PlayStation Consoles

The **PKGi** format delivers a simple JSON feed used by PKGi-style launchers across PlayStation 3, PlayStation Vita, and PSP systems. This format requires SHA-1 hash verification for game integrity.

The endpoint structure follows:

```bash
GET /api/feeds/pkgi/<system>/game?sha1=<hash>

```

RomM extracts SHA-1 hashes using utilities in [`backend/utils/filesystem.py`](https://github.com/rommapp/romm/blob/main/backend/utils/filesystem.py), specifically referencing the comment "feeds for PKGi passthrough" in the implementation.

## Variant Feed Formats and Platform-Specific Endpoints

Beyond the three core formats, RomM provides derivative endpoints that reuse the PKGi payload structure for additional platforms and content types.

### fPKGi for PlayStation 4

The **fPKGi** variant targets PS4 homebrew launchers, exposing fake PKG content through a compatible interface.

```bash
GET /api/feeds/fpkgi/ps4

```

### Kekatsu for Nintendo DS

**Kekatsu** feeds support Nintendo DS content through a dedicated endpoint:

```bash
GET /api/feeds/kekatsu/nds

```

### pkgj for PSP, PS Vita, and PSX

The **pkgj** format provides separate endpoints for games and DLC across multiple PlayStation legacy systems:

**Game feeds:**
- `GET /api/feeds/pkgj/psp/games`
- `GET /api/feeds/pkgj/psvita/games`
- `GET /api/feeds/pkgj/psx/games`

**DLC feeds:**
- `GET /api/feeds/pkgj/psp/dlc`
- `GET /api/feeds/pkgj/psvita/dlc`

These variants maintain the same JSON schema as the base PKGi feed but filter content by platform and type.

## Implementation Architecture

The feed generation system is modularized across several backend components:

- **[`backend/endpoints/feeds.py`](https://github.com/rommapp/romm/blob/main/backend/endpoints/feeds.py)** — FastAPI router registering all feed endpoints and handling HTTP requests
- **[`backend/endpoints/responses/feeds.py`](https://github.com/rommapp/romm/blob/main/backend/endpoints/responses/feeds.py)** — OpenAPI response models defining the structure for Tinfoil, WebRcade, and PKGi formats
- **[`backend/utils/filesystem.py`](https://github.com/rommapp/romm/blob/main/backend/utils/filesystem.py)** — Helper utilities extracting SHA-1 hashes required for PKGi-style feeds
- **[`docs/BACKEND_ARCHITECTURE.md`](https://github.com/rommapp/romm/blob/main/docs/BACKEND_ARCHITECTURE.md)** — Architecture documentation referencing the feed generators at lines 185 and 956
- **[`backend/tests/endpoints/feeds.py`](https://github.com/rommapp/romm/blob/main/backend/tests/endpoints/feeds.py)** — Test suite validating each endpoint returns the correct format and content type

## API Usage Examples

Fetch a Tinfoil feed for Switch games:

```bash
curl -s "http://localhost:8000/api/feeds/tinfoil?slug=switch" | jq .

```

Retrieve the WebRcade XML feed:

```bash
curl -s "http://localhost:8000/api/feeds/webrcade" | xmllint --format -

```

Access a specific PKGi feed for a PS Vita game using its SHA-1 hash:

```bash
curl -s "http://localhost:8000/api/feeds/pkgi/psvita/game?sha1=beadfeed"

```

## Summary

- RomM generates **Tinfoil**, **WebRcade**, and **PKGi** feeds through dedicated `/api/feeds/` endpoints
- **Tinfoil** uses JSON for Nintendo Switch launchers via `/api/feeds/tinfoil?slug=<platform>`
- **WebRcade** serves XML via `/api/feeds/webrcade` for browser-based emulation
- **PKGi** feeds require SHA-1 hashes and support PS3, PS Vita, and PSP via `/api/feeds/pkgi/<system>/game`
- Derivative formats include **fPKGi** (PS4), **Kekatsu** (NDS), and **pkgj** (PSP/PSVita/PSX games and DLC)
- Implementation resides in [`backend/endpoints/feeds.py`](https://github.com/rommapp/romm/blob/main/backend/endpoints/feeds.py) with response schemas in [`backend/endpoints/responses/feeds.py`](https://github.com/rommapp/romm/blob/main/backend/endpoints/responses/feeds.py)

## Frequently Asked Questions

### What feed formats does RomM support?

RomM supports Tinfoil (JSON for Nintendo Switch), WebRcade (XML for browser emulation), and PKGi (JSON for PlayStation consoles). Additionally, it provides variant feeds including fPKGi for PS4, Kekatsu for Nintendo DS, and pkgj for PSP, PS Vita, and PSX content.

### How do I access the Tinfoil feed for my Switch ROMs?

Make a GET request to `/api/feeds/tinfoil?slug=switch` where the `slug` parameter specifies your platform identifier. The endpoint returns a JSON array compatible with the Tinfoil Switch homebrew launcher, containing game titles, sizes, and download URLs.

### What is the difference between PKGi and pkgj feeds in RomM?

PKGi feeds represent the base format for PS3, PS Vita, and PSP content accessible via `/api/feeds/pkgi/<system>/game`. The pkgj feeds are derivative endpoints that use the same JSON schema but provide platform-specific filtering for PSP, PS Vita, and PSX games and DLC through paths like `/api/feeds/pkgj/psvita/games`.

### Where does RomM store the SHA-1 hashes required for PKGi feeds?

RomM extracts and stores SHA-1 hashes using filesystem utilities in [`backend/utils/filesystem.py`](https://github.com/rommapp/romm/blob/main/backend/utils/filesystem.py). The implementation includes a specific comment referencing "feeds for PKGi passthrough", indicating the hash generation logic supports the integrity verification required by PKGi-style PlayStation launchers.