# psx-covers: a serial-named cover image set DuckStation can fetch > psx-covers is a directory of PlayStation cover images whose file names are disc serials, which DuckStation 0.1-5227 and newer can pull straight from raw URLs. Its own coverage table shows how unevenly it fills regions, and the PlayStation 2 and PCSX2 claims belong to a separate tool the documentation never installs. **xlenore/psx-covers** — PSX/PS1 Covers Collection - Repository: https://github.com/xlenore/psx-covers - Stars: 2,117 · Forks: 98 - Language: Python - License: not declared - Published: 2026-10-14 · Updated: 2026-10-14 · Language: en - Canonical page: https://hysenlabs.com/projects/xlenore-psx-covers ## Blank thumbnails trace back to one missing file This collection has no database, no manifest and no client library. It is a directory of image files under `covers/` on the `main` branch, and the only key is the console serial printed on the disc. Two layouts sit side by side: `covers/default/` holds `.jpg` artwork and `covers/3d/` holds `.png` renders of the box in three dimensions. An emulator that knows a serial builds a file name from it and asks for that file. When the request comes back empty, the library entry keeps whatever placeholder the frontend already picked for that title. That contract explains who this is for. Someone holding a DuckStation library of serial-named discs who wants artwork that survives a database wipe, an emulator switch or a frontend reinstall, without buying a cover pack or scraping one site by hand, title by title. It also explains the failure mode. Because the artwork is served as static files from a repository rather than from an index with a search API, a cover that was never added and a cover that was deleted look identical from the emulator's side. Both are the same empty response, and neither produces an error you would notice while scrolling a grid. ## The cover downloader only exists from 0.1-5227 Nothing needs installing. This is not a Python package you place in a virtualenv; the only implementation language recorded for the repository is Python, and that refers to the scripts sitting under `tools/`, not to anything a DuckStation user runs. Artwork reaches a library from inside the emulator. Open DuckStation, go to `Tools -> Cover Downloader`, and paste the URL for default covers into the field: ```python https://raw.githubusercontent.com/xlenore/psx-covers/main/covers/default/${serial}.jpg ``` That template resolves to flat `.jpg` artwork. A second URL serves the box renders as `.png`: ```python https://raw.githubusercontent.com/xlenore/psx-covers/main/covers/3d/${serial}.png ``` Nobody types the `${serial}` placeholder by hand. DuckStation fills it with the serial of each title it holds, which is why the checkbox `Use Serial Files Name` matters: it is the one step that ties the template to the serials on your discs. Tick it, press Start, and the downloader walks the library one request per game. A full run against a large library takes a while for the same reason: this is one file per title fetched individually, not a single archive you unpack. ## Prefix, not the set as a whole, decides your hit rate The coverage table lists 30 serial prefixes in alphabetical order, which is the least useful order for deciding whether a run will pay off. Four rows carry the collection: SLES covers 2261 of 2318 discs at 97.54%, SLPS covers 3083 of 3662 at 84.19%, SLUS covers 1218 of 1316 at 92.55%, and SCES covers 591 of 616 at 95.94%. SIPS at 18/20 and SLKA at 3/3 are close enough to complete to ignore. Then the numbers stop describing anything usable. SCED stands at 1/354, or 0.28%, and SLED at 1/236 is 0.42%, while HASH and PBPX are listed at 0/25 and 0/11. A library of UK or Korean discs, where those two prefixes dominate, will look nearly untouched after a complete run, while a North American library will look finished. Mid-table rows hide partial results: SLPM reports 1118/1787 at 62.56% and LSP reports 79/195 at 40.51%, so a Japanese library ends up with artwork for most titles and bare placeholders for the rest. Find the rows matching your own region before you paste the URL, because a downloader never warns about a prefix that has no files at all. ## The PS2 claim outruns the table shipped beside it Read the one-line description of PSCoverDL again: a small tool to download PS1/PS2 covers for DuckStation and PCSX2, linked to a separate repository, `xlenore/pscoverdl`. The statistics sitting on the same page do not back that up. All 30 rows are PlayStation serial prefixes, from PAPX at 3/68 to SLUS at 1218/1316, and the two complete prefixes are CPCS at 1/1 and SLKA at 3/3. No PlayStation 2 series appears in the table, and no URL template for PCSX2 is given anywhere. For a PS2 library this repository has nothing documented to aim a frontend at. A second detail rewards a slower read. Both URL blocks are fenced as `python` while containing nothing but a raw address string. There is no Python entry point here, no client class and no function to import. The Python recorded for the repository belongs to the tooling that fills `covers/`, and the documentation never shows what that code looks like or how anyone runs it. ## missing_covers.txt and tools/ have no documented workflow Five entries sit at the top level: `.gitignore`, `README.md`, `covers/`, `missing_covers.txt` and `tools/`. Three of them carry the actual work, and none of the three is explained. Nothing states how an image is chosen, resized or named. Nothing says whether the serial inside a file name matches the uppercase form printed in the coverage table or a lowercased one; the two URL templates are the only place where the examples and the two directories meet. `missing_covers.txt` reads like a backlog of serials with no artwork, yet nothing says who regenerates it or when. `tools/` holds the scripts in a repository whose recorded primary language is Python, and again no entry point appears. This matters only if you plan to add a cover of your own. The convention is recoverable, since an image dropped into `covers/default/` under the right name would be served on the next run, but the documentation never confirms the case rules and a wrong guess costs you a download run rather than an error message. ## Seven frontend topics, one documented integration path The topic list advertises duckstation, epsxe, mednafen, pcsx, retroarch, psxeven and ssspsx, yet the only integration written down anywhere is the DuckStation path. That gap matters more than a topic list usually does. A cover downloader inside any of those frontends needs its own URL template, and this repository publishes exactly two paths, `covers/default/` with `.jpg` and `covers/3d/` with `.png`. Frontends that keep artwork elsewhere, or that expect a different file name, get nothing from either URL. The alternative path inside this project is PSCoverDL, and the difference in approach is structural rather than cosmetic. DuckStation's built-in downloader pulls from a template pasted into a dialog; PSCoverDL is a separate application that, by its own one-line description, targets DuckStation and PCSX2 as well. What you get for that choice in writing is thin. No install step, no output directory, no configuration key, just a link out to another repository. ## Copyright terms are unstated and the artwork is credited elsewhere No licence is declared anywhere in the repository, so the default copyright rules apply to every file under `covers/`, and the credit list names two outside sources, `psxdatacenter.com` and `duckstation.org`, rather than the scans themselves. Whether that is enough to copy the tree into a private collection is a question for whoever holds the rights, not something this project settles. The last push landed on 2026-10-05, and nothing here is published as a tagged release, so there is no version to pin and no upgrade step to plan: an update is whatever `main` holds at the moment the downloader runs. The practical consequence is that you consume a live branch over the network, and the set you see today can differ from the set you see next month with nothing announcing the difference. If you need a fixed set of artwork, copy the files you want into your own storage and stop depending on the remote tree. ## Conclusion Adopt psx-covers when your library runs on serial-named discs and your serials start with SLES, SLPS or SLUS, where coverage sits between 84.19% and 97.54%. Leave it alone if your discs are mostly SCED or SLED, since those rows list 1/354 and 1/236, or if you need PlayStation 2 artwork, because no URL template for PCSX2 is written down anywhere here. Before pasting either URL into the cover downloader, confirm your DuckStation build is 0.1-5227 or newer, then read the prefix row for your own region. ## FAQ ### How do I point DuckStation at the psx-covers collection? Open DuckStation, go to `Tools -> Cover Downloader`, paste the default-covers URL into the field, tick `Use Serial Files Name` and press Start. The downloader only exists in DuckStation 0.1-5227 or newer, and there is no package to install. ### Why is the cover still missing for one of my games after the download? Artwork is keyed by disc serial and region prefix, and several prefixes are nearly empty: SCED lists 1/354 and SLED lists 1/236. A title whose serial begins with one of those prefixes resolves to an image that does not exist, however many times the downloader runs. ### Does psx-covers include PlayStation 2 covers for PCSX2? PSCoverDL is described as a small tool to download PS1/PS2 covers for DuckStation and PCSX2, and it lives in its own repository. Only the DuckStation path is written down here, and the coverage table lists PlayStation serials only, with no PCSX2 URL template. ### Can EPSXe, RetroArch or Mednafen use the psx-covers collection? Those emulators appear among the repository topics, but the only documented integration is DuckStation's built-in cover downloader. Two paths are published, `covers/default/` with `.jpg` and `covers/3d/` with `.png`, and nothing states what any other frontend expects. ### How do I add a missing cover to psx-covers? No submission workflow is described. `missing_covers.txt` and `tools/` are listed among the top-level entries with no instructions for either, and the case rules for a serial inside a file name are never stated. ## Sources - [Issues](https://github.com/xlenore/psx-covers/issues) - [README](https://github.com/xlenore/psx-covers/blob/main/README.md) - [xlenore/psx-covers on GitHub](https://github.com/xlenore/psx-covers) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/xlenore-psx-covers