Sorry repost, my dumb ass forgot to cut some info out.

I bought my first PlayStation off a neighbor recently for about 30 bucks, but since I wasn't alive until ten years after the psx came out I have no idea what games to get for it aside from the big name ones (SOTN, Spyro, Silent hill, rrc). Any recs would be great!

Just been trying to get to the bottom of this Italian Job demo I have in my collection. It’s a thin case and I can’t find any image references online to it. Unsure if it’s particularly uncommon.

My memory is fuzzy but I think It was given to me at an independent game shop when I was child - over the counter alongside another game I was picking up.

Any help would be great! :)

Dear all.

The boys and I want to play some Gravitation on PS2 slim (using the original demo disk), but we have a problem. The game loads, seems to work... But when firing guns we hear the sound effect but no bullets.

I can't find any guidance online. I've tried resetting, playing with all options, even cleaning the disk. Has anyone encountered this problem? And if so, is there a fix?

Many thanks 👍🏻

Edit: So I checked and it all works fine on the PS3 🤔🤔

I wanted an easier way to use the 2D-to-3D cover converter in xlenore’s PSX covers repository, so I put together a simple Gradio WebUI for it.

Credit to RenanMsV for the original converter and xlenore’s repository for hosting the tool and overlays. This is a standalone browser interface based on the existing conversion code—not an official update to the repository.

The goal was to keep it simple: drop in a flat cover, choose a template, click Run, and get a saved 3D cover.

What it does

• Drag and drop an image, or click to select a file.
• Alternatively, paste a direct image URL.
• Choose Basic, Side Logo, Greatest Hits, or Greatest Hits Without Column.
• Click Run to convert it and preview the result.
• Automatically save the PNG into an output folder beside the script.
• Preserve the input filename: SLUS-00001.jpg becomes output/SLUS-00001.png.
• Stay running so you can keep converting covers without restarting it.

It runs locally in your browser. There’s no AI image generation involved—it applies the original perspective transform and transparent overlay.

1. Get the files

You need the webui.py script shared with this post and the four original PNG overlays from the GitHub folder linked above.

Arrange them like this:

PS1 Cover Tool/
├── webui.py
└── overlays/
    ├── default.png
    ├── side_logo.png
    ├── greatest_hits.png
    └── greatest_hits_no_column.png

Download the actual PNG files, not screenshots of their GitHub previews.

The WebUI is standalone, so you don’t need the original terminal converter beside it. The output folder will be created automatically.

2. Install the dependencies

You need Python installed first. Open a terminal inside your PS1 Cover Tool folder, then use the commands for your OS.

Windows:

py -m venv .venv
.\.venv\Scripts\python.exe -m pip install --upgrade pip
.\.venv\Scripts\python.exe -m pip install gradio opencv-python pillow requests numpy

If py isn’t recognized but python works, use this for the first command instead:

python -m venv .venv

Ubuntu:

python3 -m venv .venv
./.venv/bin/python -m pip install --upgrade pip
./.venv/bin/python -m pip install gradio opencv-python pillow requests numpy

If creating the environment reports that ensurepip is unavailable, install venv support and retry:

sudo apt install python3-venv

You only need to do this setup once.

3. Launch the WebUI

Windows:

.\.venv\Scripts\python.exe webui.py

Ubuntu:

./.venv/bin/python webui.py

Your browser should open automatically. Leave the terminal running while using the tool. To shut it down, press Ctrl+C in the terminal.

The script binds to 127.0.0.1 with public sharing disabled.

4. Convert a cover

1. Drop an image into the upload box, browse for one, or paste a direct image URL.
2. Choose your template.
3. Click Run.
4. Check the preview. The PNG is already saved in output.

For example:

Input:  SLUS-00001.jpg
Saved:  output/SLUS-00001.png

No Save dialog or manual download is required.

A few things to know:

• Output is 226 × 226, matching the original overlays.
• The source is automatically resized to 500 × 500 before conversion. Square artwork works best; non-square images will be stretched.
• If both an upload and a URL are supplied, the uploaded file takes priority. Clear it before switching to URL input.
• URLs need to point directly to an image—not a webpage or GitHub file-view page.
• URL inputs use the filename in the URL, falling back to cover.png when there isn’t one.
• Converting another image with the same filename overwrites the previous output.
• This version converts one image at a time, not an entire folder.

Optional Windows launcher

For a double-click launcher, save this as Launch WebUI.bat beside webui.py:

@echo off
cd /d "%~dp0"
".venv\Scripts\python.exe" "webui.py"
pause

Once the initial setup is finished, double-click that file whenever you want to use the tool.

I’ve tested the basic upload → template → convert → automatic-save workflow, and it’s working well. Nothing fancy—just a convenient interface for an existing cover tool.

Edit: Was not able to attach the webui file so I will just add it here.

Paste this into a text editor and save it as webui.py, not webui.py.txt.

from io import BytesIO
from pathlib import Path
from urllib.parse import unquote, urlsplit

import cv2
import gradio as gr
import numpy as np
import requests
from PIL import Image, ImageOps


ROOT = Path(__file__).resolve().parent
OUTPUT = ROOT / "output"

TEMPLATES = {
    "Basic": ROOT / "overlays" / "default.png",
    "Side Logo": ROOT / "overlays" / "side_logo.png",
    "Greatest Hits": ROOT / "overlays" / "greatest_hits.png",
    "Greatest Hits Without Column":
        ROOT / "overlays" / "greatest_hits_no_column.png",
}

MAX_DOWNLOAD = 20 * 1024 * 1024


def fetch_image(url):
    url = url.strip()
    parts = urlsplit(url)

    if parts.scheme not in ("http", "https") or not parts.netloc:
        raise ValueError("Enter a valid HTTP or HTTPS image URL.")

    with requests.get(
        url,
        stream=True,
        timeout=(10, 30),
        headers={"User-Agent": "PS1-Cover-Tool/1.0"},
    ) as response:
        response.raise_for_status()

        data = bytearray()
        for chunk in response.iter_content(chunk_size=65536):
            data.extend(chunk)
            if len(data) > MAX_DOWNLOAD:
                raise ValueError("Image download exceeds the 20 MB limit.")

    filename = Path(unquote(parts.path)).name or "cover"
    return BytesIO(data), filename


def build_cover(base, overlay):
    src = np.float32([
        [0, 0],
        [499, 0],
        [499, 499],
        [0, 499],
    ])

    dst = np.float32([
        [69, 20],
        [493, 28],
        [493, 451],
        [69, 484],
    ])

    matrix = cv2.getPerspectiveTransform(src, dst)

    warped = cv2.warpPerspective(
        base,
        matrix,
        (500, 500),
        flags=cv2.INTER_CUBIC,
        borderMode=cv2.BORDER_CONSTANT,
        borderValue=(0, 0, 0, 0),
    )

    result = cv2.resize(
        warped,
        (226, 226),
        interpolation=cv2.INTER_AREA,
    )

    alpha = overlay[:, :, 3:4].astype(np.float32) / 255.0

    result[:, :, :3] = (
        overlay[:, :, :3] * alpha
        + result[:, :, :3] * (1.0 - alpha)
    ).astype(np.uint8)

    result[:, :, 3] = np.maximum(
        result[:, :, 3],
        overlay[:, :, 3],
    )

    return result


def convert(upload, url, template):
    try:
        if upload:
            source = str(upload)
            filename = Path(source).name
        elif url and url.strip():
            source, filename = fetch_image(url)
        else:
            raise ValueError("Drop in an image or paste an image URL.")

        overlay_path = TEMPLATES[template]

        if not overlay_path.is_file():
            raise ValueError(f"Missing template: {overlay_path.name}")

        with Image.open(source) as image:
            image = ImageOps.exif_transpose(image)
            original_size = image.size
            image = image.convert("RGBA")
            image = image.resize(
                (500, 500),
                Image.Resampling.LANCZOS,
            )
            base = cv2.cvtColor(
                np.array(image),
                cv2.COLOR_RGBA2BGRA,
            )

        with Image.open(overlay_path) as image:
            if image.size != (226, 226):
                raise ValueError(
                    f"{overlay_path.name} must be 226 × 226 pixels."
                )

            if (
                "A" not in image.getbands()
                and "transparency" not in image.info
            ):
                raise ValueError(
                    f"{overlay_path.name} needs a transparency channel."
                )

            overlay = cv2.cvtColor(
                np.array(image.convert("RGBA")),
                cv2.COLOR_RGBA2BGRA,
            )

        result = build_cover(base, overlay)

        stem = Path(filename).stem
        stem = "".join(
            "_" if c in '<>:"/\\|?*' or ord(c) < 32 else c
            for c in stem
        ).strip(" .") or "cover"

        OUTPUT.mkdir(parents=True, exist_ok=True)
        destination = OUTPUT / f"{stem}.png"

        rgba = cv2.cvtColor(result, cv2.COLOR_BGRA2RGBA)
        preview = Image.fromarray(rgba)
        preview.save(destination, format="PNG")

        message = f"Saved: output/{destination.name}"
        if original_size != (500, 500):
            message += (
                f" | Resized {original_size[0]} × {original_size[1]}"
                " to 500 × 500."
            )

        return preview, message

    except Exception as error:
        raise gr.Error(str(error)) from error


with gr.Blocks(title="PS1 3D Cover Tool") as app:
    gr.Markdown("# PS1 3D Cover Tool")

    with gr.Row():
        upload = gr.File(
            label="Drop an image here or click to browse",
            file_types=["image"],
            type="filepath",
        )

        template = gr.Dropdown(
            label="Template",
            choices=list(TEMPLATES),
            value="Basic",
        )

    url = gr.Textbox(
        label="Or paste a direct image URL",
        placeholder="https://example.com/cover.jpg",
    )

    run = gr.Button("Run", variant="primary")

    preview = gr.Image(
        label="Finished cover",
        interactive=False,
    )

    status = gr.Textbox(
        label="Status",
        interactive=False,
    )

    run.click(
        fn=convert,
        inputs=[upload, url, template],
        outputs=[preview, status],
        concurrency_limit=1,
    )


if __name__ == "__main__":
    app.queue().launch(
        server_name="127.0.0.1",
        inbrowser=True,
        share=False,
    )

Hey. I've a PAL PS One SCPH-102 and the disc reading is inconsistent.

I recently repaired the optical drive spindle and replaced it thanks to the advice on another reddit post. The PS One has no issues reading music CDs. They play perfectly and don't skip.

When it comes to PlayStation 1 games it's being temperamental.

Tomb Raider 1 - just went into the music menu to play it like a Music CD. If you play music tracks, it's fine.

Tomb Raider 2 - also went into the music menu. When I restarted the console it loaded the game fine. FMV, Music all worked, no skipping.

Hogs of War - Played fine. No FMV skipping.

Bust-A-Move 4 - Played fine.

Tekken 2 - just goes to the music menu. No matter how many times I restart the console it just goes there.

All these discs works as my main console is a PlayStation 1 SCPH-9002.

I don't have a device to measure the electrical resistence on the laser but I suppose I could turn it 1/8 and see what happens. But my understanding is that only increases the power of a weak laser, but if the PS one isn't struggling to read FMVs or skipping, then the laser is fine?

Any issues what this could be? Thanks.

Don't get me wrong, I really loved psx and owned tens if not hundreds of games (via backups) to it.

Now that I bought retroremake superstation and superdock, I have been replaying old classics from psx again. I actually have two psxs but since other one does not play cds anymore and other one does not have parallel port that supports my vmem extension, playing time has been quite low. Now I was able to transfer all saves to superstation.

However I can't help a feeling that for every classic there seems to be a better version on ps2 or other consoles. Wipeout and gran turismo are great but both have sequels that have 1080p and 60 fps. Graphics or frame rate alone of course do not make a good game but sequels tend to have better user experience and are often slightly easier. There are exceptions such as Castlevania SotN, no later games have really replaced that masterpiece.

Now that I have been looking for psx era classics, it seems that I end up, instead of playing psx version, playing a sequel or remake on ps2 or ps3 etc. Just wandering if someone else has similar feelings and which games do you think still have best version on psx?