pcsx-redux.consoledev.net

PCSX-Redux is a PlayStation 1 emulator that ships with a built-in development and debugging toolset. It is aimed at people who want to inspect, debug, reverse engineer, or build PS1 software — not just play games. If you only want to run commercial titles with a simple front-end, a general-purpose emulator will usually be less effort; if you need breakpoints, memory inspection, GPU tracing, or scripting against a running PS1, PCSX-Redux is built for that.

What it actually is

The project describes itself as an emulator plus documentation for development work. Its documentation covers:

• Compiling PCSX-Redux from source
• Command line flags
• Debugging with PCSX-Redux, including a GDB server
• Connecting Ghidra to PCSX-Redux
• Misc features such as a VRAM viewer and GPU logger
• A MIPS API
• A built-in web server
• A Lua API (introduction, loaded libraries, basic API, rendering, file API, webserver API, memory and registers, events, breakpoints, inline assembler)
• Handling of PSX binaries
• Case studies, including Openbios

That list is the clearest signal of intent: the emulator is a host for tooling around a running PS1, and the documentation is organized around tasks rather than around a game-playing guide.

How it differs from a typical PS1 emulator

The distinction is in what the interface exposes. A typical emulator gives you a window, a controller mapping screen, and save states. PCSX-Redux gives you those kinds of basics plus surfaces that a developer or reverse engineer would use:

If your goal is "run this disc image," most of that table is irrelevant to you. If your goal is "find out why this routine writes the wrong value to this register," the table is the reason to pick this emulator.

Where to get it and where to ask questions

The documentation points to the GitHub repository for downloads across platforms:

https://github.com/grumpycoders/pcsx-redux#where

It also lists two Discord communities:

• A Discord server for discussing PCSX-Redux specifically
• The PSX.Dev Discord server for PlayStation 1 development, hacking, and reverse engineering in general

The split is useful: emulator-specific problems belong in the first, and broader PS1 development questions belong in the second.

When to choose it

Choose PCSX-Redux when your task involves inspecting or controlling a running PS1 program — setting breakpoints, scripting memory access through Lua, tracing GPU output, or attaching Ghidra. Choose a simpler emulator when you want to play a game and nothing else. The documentation's own structure makes the trade-off clear: it spends its pages on compiling, debugging, scripting, and binary handling, and treats the emulator as the platform those tools run on.

PCSX-Redux is a PlayStation 1 emulator aimed at development, hacking, and reverse engineering. To get started, download a build for your platform from the official GitHub page linked on the documentation home, then use the documentation sections for compiling, command-line arguments, menus, and debugging as you need them. The docs are organized so you can jump straight to the part you need rather than reading everything in order.

Get the emulator

The documentation home points you to the emulator downloads here:

https://github.com/grumpycoders/pcsx-redux#where

That page is the starting point for obtaining a build for the various supported platforms. If you only want to run the emulator, a prebuilt download is the fastest path. If you want to modify or build it yourself, go to the compiling section instead.

Learn the interface and launch options

Two documentation sections cover day-to-day use:

• Menus — what each menu does inside the emulator.
• Command line arguments — flags you can pass when launching, useful for scripting or setting specific behavior at startup.

Read these before diving into debugging so you understand how the emulator is configured and controlled.

Set up debugging

PCSX-Redux has a dedicated debugging area. The relevant documentation sections are:

• Debugging with PCSX-Redux — the general debugging workflow.
• GDB server — connecting a GDB client to the emulator.
• Connecting Ghidra to PCSX-Redux — using Ghidra alongside the emulator for analysis.

These let you attach external tools to a running session rather than working blind.

Explore the scripting and API features

Beyond debugging, the docs cover features for inspecting and automating the emulator:

• VRAM viewer and GPU Logger for graphics inspection.
• MIPS API for interacting with the emulated CPU.
• Web server and Webserver Lua API for remote control and automation.
• Lua — introduction, loaded libraries, basic API, rendering, file API, building ISO images, PPF patches, memory and registers, events, breakpoints, and an inline assembler.

Work with PSX binaries and OpenBIOS

If you are handling PlayStation 1 software, the docs include:

• Handling of PSX binaries — how the emulator deals with executables.
• Case studies — worked examples.
• OpenBIOS — the open-source BIOS replacement.

Where to ask questions

The documentation lists two Discord communities:

• The PCSX-Redux Discord for emulator-specific questions.
• The PSX.Dev Discord for general PlayStation 1 development, hacking, and reverse engineering.

Suggested order

1. Download a build from the GitHub link.
2. Skim Menus and Command line arguments.
3. If you are developing or reversing, read Debugging with PCSX-Redux, then set up the GDB server or Ghidra connection.
4. Use the Lua and MIPS API sections when you need to script or inspect internals.
5. Join the relevant Discord when you get stuck.

PCSX-Redux handles PSX binaries through a documented "Handling of PSX binaries" section in its official documentation, and it treats OpenBIOS as a dedicated topic with its own "Openbios" page. Both sit alongside the emulator's debugging, reverse-engineering, and scripting features, so they are best understood as part of a workflow: you load or build a PSX binary, then use the emulator's inspection tools (debugger, GDB server, Ghidra connection, MIPS API, Lua) to study or modify it. This answer describes what the documentation covers and how the pieces relate; it does not claim behavior the docs do not state.

What the documentation covers for PSX binaries

The PCSX-Redux documentation includes a "Handling of PSX binaries" entry in its navigation. That places binary handling in the same documentation set as:

• Debugging — including "Debugging with PCSX-Redux" and a GDB server for connecting external debuggers.
• Connecting Ghidra to PCSX-Redux — for disassembly and reverse engineering in Ghidra.
• Misc Features — a VRAM viewer and GPU Logger for inspecting graphics state.
• MIPS API — an internal API for interacting with the emulated MIPS CPU.
• Lua — scripting with a "Redux basic API," rendering, file API, and a Webserver Lua API.
• Building ISO images and PPF patches — for packaging and patching disc images.
• Case studies — worked examples in the documentation.

The practical implication: if your goal is to load a PSX executable or disc image and then inspect it, the binary-handling page is the entry point, and the debugging/reverse-engineering pages are the follow-on tools. The docs do not, in the excerpt provided, specify supported binary formats or exact load steps, so consult the "Handling of PSX binaries" page directly for the concrete procedure.

Where OpenBIOS fits

OpenBIOS has its own page in the documentation ("Openbios" under Case studies). It appears as a case study rather than a core emulator feature, which suggests it is used to illustrate a real workflow — typically replacing or studying the PlayStation BIOS with an open implementation during development or research.

Because the documentation lists it under Case studies, treat it as an example you can follow and adapt, not as a guaranteed drop-in for every setup. Check the OpenBIOS page for the specific files and steps it describes.

How binaries, OpenBIOS, and the tooling connect

A typical research or homebrew workflow implied by the documentation:

1. Get the emulator — the docs point to the GitHub repository for platform downloads.
2. Handle your PSX binary — follow the "Handling of PSX binaries" page.
3. Run and inspect — use the debugger, GDB server, or Ghidra connection to examine execution.
4. Automate or extend — use the Lua API and web server for scripted control and remote interaction.
5. Study a real case — follow the OpenBIOS case study to see the tools applied end to end.

For community help, the docs list two Discord servers: one for PCSX-Redux specifically, and PSX.Dev for PlayStation 1 development, hacking, and reverse engineering in general.

What to check before you start

• The documentation excerpt does not state pricing or login requirements, so do not assume the emulator or its services are free or require no account — verify on the GitHub page.
• Exact binary formats, load commands, and OpenBIOS setup steps are not detailed in the provided excerpt; read the dedicated pages ("Handling of PSX binaries" and "Openbios") for authoritative instructions.
• If you need scripting or remote control, start with the Lua and Web server sections, since they are documented as first-class features.

PCSX-Redux exposes a Lua scripting layer and a built-in web server so you can automate emulator tasks, inspect memory and registers, hook events, and drive the emulator from outside the GUI. According to the official documentation, the Lua API covers loaded libraries, a basic Redux API, rendering, a file API, building ISO images, PPF patches, and a web server Lua API, while the web server itself is listed as a core feature alongside the VRAM viewer, GPU logger, and MIPS API. If you want to script emulator behavior or control it remotely, these are the entry points to look at.

What the Lua scripting layer covers

The documentation's Lua section is organized into these topics:

• Lua Introduction — the starting point for the scripting layer.
• Loaded libraries — which Lua libraries are available to your scripts.
• Redux basic API — the core emulator-facing functions.
• Rendering — drawing/output-related calls.
• File API — file access from scripts.
• Building ISO images — assembling disc images via script.
• PPF patches — applying PPF patches.
• Webserver Lua API — the Lua side of the web server.
• Memory and registers — reading and writing emulator state.
• Events — reacting to emulator events.
• Breakpoints — scripted breakpoint handling.
• Inline assembler — assembling MIPS code from within Lua.
• Handling of PSX binaries — working with PlayStation executables.
• Case studies — worked examples, including an Openbios case study.

So the practical scope is broad: you can read/write memory and registers, set breakpoints, assemble instructions inline, process PSX binaries, build ISOs, and patch with PPF — all from Lua.

What the web server gives you

The web server is documented as its own feature and also has a Webserver Lua API. That means two complementary paths:

1. A server you can reach from a browser or another tool, useful for remote inspection or integration with external scripts.
2. Lua bindings for the web server, so your scripts can serve or respond to requests as part of an automation workflow.

The documentation lists the web server next to the VRAM viewer, GPU logger, and MIPS API, so treat it as a first-class debugging/automation surface rather than an add-on.

How the pieces fit together for automation

A typical scripted workflow combines several documented areas:

1. Load your script and confirm the loaded libraries match what you need.
2. Use the Redux basic API to interact with the emulator.
3. Read memory and registers or set breakpoints to observe execution.
4. Hook events to trigger logic when the emulator reaches a state you care about.
5. Use the file API to read inputs or write outputs.
6. Build an ISO image or apply a PPF patch as the end product.
7. Expose results through the web server (directly or via the Webserver Lua API) if another process needs them.

The inline assembler and PSX binary handling are what let you go beyond observation into patching and code injection.

Where to start

The documentation's own navigation suggests this order: Lua Introduction → Loaded libraries → Redux basic API → Rendering → File API → Building ISO images → PPF patches → Webserver Lua API → Memory and registers → Events → Breakpoints → Inline assembler → Handling of PSX binaries → Case studies. The Openbios case study is the closest thing to a full worked example, so read it after the API references.

For the emulator itself, the documentation points to the download page at https://github.com/grumpycoders/pcsx-redux#where. For emulator-specific questions it lists a Discord server, and for general PS1 development, hacking, and reverse engineering it lists the PSX.Dev Discord server.

Practical notes

• The documentation does not state pricing or login requirements for these features, so don't assume the scripting or web server is gated — check the current docs and repository.
• The web server and Lua API are described as features of the emulator, so version differences are likely; verify against the docs matching your build.
• If you're new to the emulator overall, the Compiling PCSX-Redux, Menus, and Command line arguments pages are the natural prerequisites before scripting.

PCSX-Redux is a PlayStation 1 emulator whose documentation is organized around development and reverse engineering work, not just gameplay. If you are doing PS1 homebrew, ROM hacking, or reverse engineering, it provides an integrated debugger, a GDB server for external tools, a Ghidra connection path, memory and register inspection, breakpoints, an inline assembler, and supporting viewers such as a VRAM viewer and GPU logger. The sections below describe what each capability is for so you can decide whether it fits your workflow.

Built-in debugger and GDB server

The documentation lists a dedicated "Debugging with PCSX-Redux" section alongside a "GDB server" topic. This means two complementary paths:

• In-emulator debugging: inspect and control execution from within PCSX-Redux itself.
• GDB server: expose the emulated target to an external GDB client, so you can use familiar GDB commands and scripting against the running PS1 program.

The GDB server is the bridge that makes external tooling possible. If your existing workflow is built around GDB, this is the entry point to check first.

Connecting Ghidra to PCSX-Redux

The documentation includes a specific page for "Connecting Ghidra to PCSX-Redux." Ghidra is a disassembler and reverse engineering suite; connecting it to the emulator lets you correlate static analysis of PS1 binaries with live execution state. This is the feature to evaluate if your goal is understanding compiled game code rather than only writing new code.

Memory, registers, events, and breakpoints

Under the MIPS API and debugging documentation, the following capabilities are listed:

• Memory and registers: read and inspect CPU state and memory contents.
• Events: hook into emulator events.
• Breakpoints: stop execution at chosen points.
• Inline assembler: assemble and inject MIPS instructions directly, useful for patching or testing hypotheses without a full rebuild.

Together these cover the core loop of reverse engineering: locate code, set a breakpoint, inspect state, modify behavior, and observe the result.

Auxiliary analysis tools

Beyond the debugger, the documentation lists:

• VRAM viewer: inspect the PlayStation's video memory, relevant for graphics and texture work.
• GPU Logger: capture GPU activity for rendering-related analysis.
• Web server: exposes functionality over HTTP, which can support scripted or remote interaction.
• Lua API: scripting access covering the basic API, rendering, file API, building ISO images, PPF patches, and a webserver Lua API.

The Lua layer is what turns one-off manual debugging into repeatable automation, for example scripted memory scans or automated patch application.

Practical starting points

If you want to move from reading about these features to using them, the documentation points to:

• The emulator downloads page: https://github.com/grumpycoders/pcsx-redux#where
• The PCSX-Redux Discord for emulator-specific questions
• The PSX.Dev Discord for general PS1 development, hacking, and reverse engineering discussion

The documentation also includes a "Case studies" section and an "Openbios" page, which are useful for seeing how these tools apply to real analysis tasks rather than isolated feature descriptions.