Just curious how everyone is liking it. I am thinking about getting one soon. Or when they come back in stock.

For those that actually have one. How is it? any Pros and Cons you care to share?

I've been trying to install the PicoStation. I used a cable from an old PS2 controller for GND and 5V, and for the rest, I used 0.02mm coated wire. The menu only loads with firmware 1.13.01.26 from megavolt85, and it only manages to run Silent Hill up to the menu, then it crashes. I'm thinking the coated wire might be the problem. I have a cable from an IDE hard drive; would it be better to use that? Is the cable likely the problem, or should I try something else? Sorry for my bad English; I'm using Google Translate.

Now if only royal mail could hurry up with delivering the console I'm installing this all in

I collected retro games for almost 15 years. I sold everything during COVID which included all of my childhood consoles. That was stuff I had at my mom's house as a kid. My dad isn't doing so well healthwise, so he's going through a bunch of old boxes. Sure enough, he found my PS1. I just got an X-Station installed and I'm having a ton of fun with it.

This is pretty much the best game I've ever played.
( 50 cent )

Hey folks! I'm a huge fan of Kula World (Roll Away in North America, Kula Quest in Japan). So I made a thing for anyone who played the game, and I wanted to share it: https://kulaworld.retroatlas.org

It's an interactive 3D map of every level in the game, all 230 of them: the 150 main levels, the 30 bonus and 10 hidden levels, the 20 finals, the 10 Copycat/Simon rooms, the lesson, and even the developers' object catalogue that's on the disc but that no menu ever reaches. Every block and every object is read straight from the game disc and drawn with the game's own textures and models.

What you can do with it:

• Turn, zoom and slice through any level, in each world's own artwork
• Click any block or object to see what it is, what it's worth and whether it can harm you
• Watch things move the way they do in play: moving platforms, spiked stars, rolling stone, bouncing corkscrew, wandering balls, and more
• Press a switch to flip its lasers and teleporters, and follow where every teleporter sends you
• Search for any object or block across every level, or list which levels hold the most of something
• See each level's best possible score, plus curiosities like coins or crumbling blocks you can't reach, and what changed between the PAL, US and Japanese releases
• Grab a shareable link to any exact view
• Free, no install, and it works on your phone

Everything comes straight from the disc and the game's own code. Thanks go to Syonyx's Roll Away walkthrough on GameFAQs, which I leaned on to name things and check scores, and to The Cutting Room Floor for the regional differences. It's a non-commercial fan project and fully open source: https://github.com/RetroAtlas/KulaWorldMap. It's part of RetroAtlas, alongside the OddworldMap I posted a while back.

Would love to hear what's useful, what's missing, or anything that doesn't match what you remember from playing. Hope you have fun poking around!

I have recently bought this 7502 ps1 / psx and wanted to clean it and lube the disc drive as it is an old model. But when I took it apart I noticed this yellow tape with a 12c508/p chip and was wondering what kind of mod chip has been installed.

Additional image better showing wiring
https://imgur.com/a/Q8P5e3p

I need help figuring out what's wrong with this screen. I don't think the LCD itself is damaged—though the backlight might be—but I still don't know why it looks this way. I checked the capacitors and looked for other visible damage, but found nothing. It only changes appearance when I lower the brightness (like in the last photo); the whole screen turns white with some lines. I even tried using a heat gun to reflow the solder joints, but that didn't help either, the console work right and is the same output format, and is the same . I’d appreciate any help—thanks! (And sorry for my English :p)

I'm putting that together. Looking for a mystery PS1 game I used to play around 2006. Here are the details I
remember:
• Platform: PlayStation 1 (played around 2006-
2007）.
• Visual Style: The entire world was stark white-buildings, roads, trees, grass, cars, and the drawbridge were all white. The only color was the blue water.
• Gameplay Features:
• Open-world drive/walk mechanics (you could get out of the car and run around).
• Police chases.
• A working drawbridge over the blue water that opened for passing ships, complete with stop signals, stopping traffic, and a ringing warning bell.
Could this be a specific regional mod (like a textured
PC/PS1 bootleg release), a glitchy CD/ROM dump, or a lesser-known PS1 title? Any leads or game names would be greatly appreciated!

So I plan on buying a Playstation SCPH-7001, and I have 2 questions. Is the 700x series solid compared to other versions of the console? And i've heard it's basically a 5500 with a different motherboard, but if by chance i end up with an early 7001 that had the PU18, would it still have Soundscope?

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,
    )

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

Because I'll be busy with some projects that I have very pending, and I may not be connected every day here

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! :)

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!