# RecompOne: PS1 Static Recompiler That Translates MIPS Executables to C#

> RecompOne takes a PlayStation 1 MIPS executable and translates every instruction into equivalent C# code ahead of time, then runs the result against a runtime layer that simulates PS1 hardware. The project targets developers who want to create portable, native ports of PS1 games without a BIOS, without Sony proprietary components, and without interpreting MIPS instructions at runtime.

**BlackLabelHQ/RecompOne** — PSX Static Recompiler and Runtime, Not Affiliated With Sony or PlayStation

- Repository: https://github.com/BlackLabelHQ/RecompOne
- Stars: 539 · Forks: 34
- Language: C#
- License: MIT
- Published: 2026-09-20 · Updated: 2026-09-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/blacklabelhq-recompone

## Static Recompilation vs. Emulation: What RecompOne Actually Does

An emulator fetches each PS1 MIPS instruction at runtime, decodes it, and executes an equivalent action on the host CPU. This interpretation loop runs for every instruction during gameplay, adding overhead on every frame.

Static recompilation translates the MIPS instructions ahead of time, before the game runs. The MIPS binary is read once, and each instruction is converted to equivalent host language code. At runtime, the host runs the translated code directly, without an interpreter in the loop.

RecompOne applies this to PS1 executables. The tool takes a PlayStation 1 binary, reads its MIPS instructions, and outputs C# code. A MIPS add instruction:

```asm
addiu t0, t0, 0x10
```

becomes:

```csharp
c.T0 = c.T0 + 0x10u;
```

A memory read:

```asm
lw t0, 0x10(sp)
```

becomes:

```csharp
c.T0 = mem.Read32(c.SP + 0x10u);
```

The translated code operates on a CpuContext object that holds the CPU register state. A separate memory interface provides read and write access to simulated PS1 memory regions. The runtime layer above these two abstractions simulates what the game expects from the hardware: BIOS functions, MMIO, GPU commands, and CD-ROM.

The README draws a clear boundary: no BIOS is required. No proprietary Sony files are needed. Only the game files.

## The CpuContext, Memory Interface, and Runtime Layer

The recompiler output is not a standalone executable. It is a C# class that calls methods on a CpuContext and a memory interface. These two objects are the bridge between the translated MIPS code and the runtime simulation.

CpuContext encapsulates what the PS1 CPU would hold in its registers at any moment: T0 through T9, S0 through S7, the stack pointer (SP), the program counter, and the other MIPS general-purpose registers. Every register access in the translated code goes through this context object.

The runtime layer translates PS1 hardware expectations into modern equivalents. The PS1 had a custom GPU that accepted a specific set of commands for drawing primitives. The PS1 had a CD-ROM controller. It had memory-mapped I/O registers for the DMA, timers, and interrupt controller. The runtime simulates each of these without requiring the actual hardware or proprietary firmware.

The README describes this as similar to an emulator in that it recreates the internal state of the hardware, but different in that the MIPS instruction execution path is replaced with pre-translated C#. The runtime is distributed as a library that the recompiled game project includes, not as a standalone application.

## Building RecompOne and Starting a Port

RecompOne is a .NET project. The README specifies .NET SDK 10 as the build requirement. Download the .NET SDK 10 from dotnet.microsoft.com/download, then build and run the recompiler.

The repository structure has two top-level components: RecompOne.Recompiler/ and RecompOne.Runtime/. The recompiler reads the PS1 executable and outputs C# code. The runtime is the library that the output code links against.

Creating a port involves several steps that the README summarises briefly, with detailed instructions in the project wiki at github.com/BlackLabelHQ/RecompOne/wiki. The wiki page is titled "How to recompile a game?" and covers the full porting process. The README does not give a single command that completes a port; it points to the wiki as the canonical reference for that workflow.

The project is a .NET solution (RecompOne.sln), which means it can be opened in Visual Studio, JetBrains Rider, or built from the command line with the .NET SDK. No other build tools are listed as requirements.

## Inspiration from N64Recomp and XenonRecomp

The README names two projects as direct inspiration: N64Recomp (Nintendo 64 static recompilation to C) and XenonRecomp (Xbox 360 static recompilation, from hedge-dev). Both projects have demonstrated that static recompilation can produce high-quality, performant ports of games for which the original source code is not available.

N64Recomp produced the Zelda 64: Recompiled project, which became a well-publicised example of the technique applied to a complete commercial game. XenonRecomp targets the Xenon CPU used in the Xbox 360, a different architecture with different challenges.

PS1 games run on the MIPS R3000 CPU. MIPS is a RISC architecture with a relatively small and regular instruction set, which makes it more amenable to ahead-of-time translation than CISC architectures. RecompOne benefits from this regularity: the mapping from MIPS instructions to C# expressions is straightforward for the arithmetic and memory access cases shown in the README, though control flow, delay slots, and MIPS-specific corner cases add complexity that the wiki likely documents.

N64Recomp and XenonRecomp produce C, which targets a lower level and has different deployment characteristics than C#. RecompOne's choice of C# as the output language is a deliberate design decision that trades some performance ceiling for integration with the .NET ecosystem and potentially simpler tooling for Windows developers.

## Contributor Policy and the AI Code Stance

The README includes a section titled "Stance on AI" that states directly: "This project is proudly made by humans. AI was not involved in writing the code, and it never will be. AI PRs will be rejected, no exceptions."

The README also states that AI-assisted or AI-generated ports will not receive help or promotion from the project. The specific phrasing is: "AI can be a useful research tool, but it does not replace the human judgment needed to understand and correctly implement what you are building. Code you don't understand is not code you wrote."

This is a concrete contributor policy, not a vague preference. Pull requests identified as AI-generated will be closed. The README reinforces this by noting that the maintainer is currently the only contributor with limited available time, and that solid, defensible code is the bar for merged contributions.

For potential contributors, this policy means that code review will probe understanding. Submitting code requires being able to explain the implementation choices.

## Limitations and Cases Where RecompOne Is Not the Right Tool

RecompOne is for creating game ports, not for casual game playing. If you want to play PS1 games today, a conventional emulator like DuckStation is faster to set up and has broad hardware compatibility. RecompOne requires understanding the port creation process, which the wiki describes as "an involved process".

The project has a single maintainer who explicitly notes limited available time. This means bug reports and questions may take time to receive responses, and feature requests may not be addressed quickly. There is no paid support tier or commercial backing.

The .NET SDK 10 requirement is current as of the last push (2026-09-12). .NET major versions follow a supported lifecycle, and SDK 10 may eventually reach end-of-life. Ports created with RecompOne will need to be rebuilt with a newer SDK when that happens, or the .NET target version in the project files will need to be updated.

Static recompilation has a known limitation with self-modifying code. Games that write executable instructions into memory at runtime and then jump to them cannot be handled by ahead-of-time translation, because those instructions do not exist in the original binary. The README does not document how RecompOne handles this edge case.

## Maintenance and Licence

The last push to the repository was on 2026-09-12. The project carries no GitHub releases. The Discord server linked from the README is the primary community channel.

RecompOne is licensed under MIT. The licence permits unrestricted use and distribution, including commercial use, without requiring source disclosure. There is no patent grant in MIT, which is a standard characteristic of the licence.

The RecompOne.Runtime/ directory is described as a library to include in a recompiled game. The licence covers both the recompiler tool and the runtime library. Porting a commercial game and distributing the result involves copyright questions about the game's assets and code that MIT does not address; those are legal questions that require separate counsel.

## Conclusion

RecompOne is the right tool for developers who want to create a native PC port of a PS1 game by translating its MIPS code to C# rather than emulating the hardware at runtime. It is not an emulator and does not accept BIOS files or proprietary Sony components. Creating a port is an involved process; the wiki documents the steps, and the single maintainer's limited availability means that non-trivial issues may take time to resolve. The .NET SDK 10 requirement is a concrete build dependency to verify before starting.

## FAQ

### What does recompilation mean?

Static recompilation translates a binary program's instructions into equivalent code in a target language ahead of time. RecompOne reads PS1 MIPS instructions and outputs C# code, so the game runs the translated C# rather than having each MIPS instruction interpreted at runtime as an emulator would do.

### what is recompone

RecompOne is a tool that statically recompiles PlayStation 1 MIPS executables into C# code. It includes a runtime library that simulates PS1 hardware so the translated code can run on modern PCs without requiring a BIOS or proprietary Sony files.

### Does RecompOne require a PS1 BIOS to run a recompiled game?

No. The README explicitly states that no BIOS and no other proprietary files are required. The runtime layer simulates the BIOS functions the game expects, using only the game files.

## Sources

- [BlackLabelHQ/RecompOne on GitHub](https://github.com/BlackLabelHQ/RecompOne)
- [Issues](https://github.com/BlackLabelHQ/RecompOne/issues)
- [License: MIT](https://github.com/BlackLabelHQ/RecompOne/blob/master/LICENSE)
- [README](https://github.com/BlackLabelHQ/RecompOne/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/blacklabelhq-recompone