RecompOne: Static PS1 Recompilation to C# Without Sony Components
PSX Static Recompiler and Runtime, Not Affiliated With Sony or PlayStation
At a glance
- What is it?
- RecompOne translates PlayStation 1 MIPS executables into C# ahead of time and ships a runtime that models the PS1 hardware. It is a build-time toolchain for people porting specific games, not a drop-in emulator.
- Who is it for?
- RecompOne is for developers who want to port one specific PS1 title into C# and are willing to follow the wiki and write the glue code themselves; it is not for players who want to double-click an emulator and load a ROM, and it is not for anyone planning to submit AI-generated code, since the maintainer states those PRs are rejected.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly C#, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- BlackLabelHQ/RecompOne622 ★ · +97
| Repository | 2026-09-21 | 2026-11-15 |
|---|---|---|
| BlackLabelHQ/RecompOne | 525 | 622 |
97 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
What RecompOne Solves, and Who It Is Actually For
An emulator keeps the original MIPS machine code and interprets or JIT-compiles it while the game runs. RecompOne moves that work to build time. The README describes it as "a tool to statically recompile PlayStation 1 executables into C# code" plus "a runtime layer that translates the PS1 hardware environment into something modern PCs can run natively." The output is a native C# program, not a ROM loader.
The audience is narrow and the README is honest about it. Creating a port is "an involved process," and the project points to its wiki page How to recompile a game? for the steps. This is a toolchain for someone who intends to ship a port of a specific title, not a general-purpose way to play a library. If your goal is to insert a disc image and press start, static recompilation is the wrong shape of tool: it targets one executable at a time and expects you to own the resulting project.
The project is inspired by N64Recomp and XenonRecomp, which do the same job for N64 and Xbox 360. That lineage matters because it tells you what the workflow looks like: you run a recompiler over a binary, get generated source, and then build a runtime around it.
How the MIPS-to-C# Translation Works
The recompiler walks the MIPS R3000A instructions in the executable and emits equivalent C# operations. The README shows the pattern with two examples. An add-immediate instruction becomes a plain C# assignment on a register field, and a load-word becomes a call into a memory interface:
addiu t0, t0, 0x10
lw t0, 0x10(sp)c.T0 = c.T0 + 0x10u;
c.T0 = mem.Read32(c.SP + 0x10u);Generated code operates on a CpuContext, which "encapsulates the state the CPU would be in," and on a memory interface. That is the whole design in one sentence: registers and memory are explicit objects you can inspect, and the runtime supplies the rest. The runtime simulates "BIOS functions, MMIO, GPU commands, CD-ROM, and so on."
This is worth contrasting with emulation directly. A static recompiler has no instruction dispatch loop at runtime, so the CPU work is ordinary compiled C#. The trade-off is that anything the recompiler cannot resolve statically, such as code reached only through a computed jump, has to be handled by the runtime or by hand. The README does not describe how the recompiler discovers indirect branch targets, and that is the detail most likely to decide whether a given game ports cleanly.
The claim that separates RecompOne from a conventional emulator is that "no BIOS or other proprietary files are required. only the game files are needed to run it." The runtime reimplements the BIOS surface instead of asking you to supply a dump. Whether a specific title works then depends on whether the functions it calls are among those the runtime models.
Building the Recompiler with .NET SDK 10
RecompOne is a .NET solution. The repository root holds RecompOne.sln with two projects, RecompOne.Recompiler and RecompOne.Runtime, and the README states you need .NET SDK 10 installed. Install the SDK from the link the README gives, then build the recompiler:
dotnet build RecompOne.RecompilerA successful build produces the recompiler binary. One point the README makes explicitly: "the runtime is not supposed to be ran, its a library that you have to include in your recompiled game." So do not expect to launch RecompOne.Runtime as a program. It is a dependency of the port you generate, not a standalone player.
Running the recompiler against a game executable is the next step, and here the README stops short. It does not document the command-line arguments, the input format, or the output layout. Instead it says: "Creating a port for a game is an involved process, but you can find instructions on how to get started on our wiki," linking to How to recompile a game?. That page, not this article, is where the actual invocation belongs. Treat the build above as the only step you can complete from the repository README alone.
Where Static Recompilation Breaks Down
The most consequential limitation is not stated as a limitation. The README says the runtime simulates BIOS functions, MMIO, GPU commands and CD-ROM, but it never claims complete coverage of those surfaces. A game that leans on a BIOS call the runtime has not implemented, or on a CD-ROM access pattern it does not expect, will not simply work. The README also does not document what happens when the recompiler encounters code it cannot translate. There is no described error path, no list of unsupported instructions, and no rollback mechanism for a partially recompiled binary.
Indirect control flow is the classic failure mode for this technique, and the README is silent on it. Any game that computes jump targets at runtime, which is common in PS1 titles, puts pressure on whatever mechanism the recompiler uses to find code. The documentation does not name that mechanism, so you cannot evaluate it before starting.
There is also a human constraint. The maintainer writes: "Currently i'm the only maintainer, so my available time is limited." Support for a porting question depends on one person's schedule. And the project's AI stance is a hard filter on contribution: "any form of AI-generated PRs will not be accepted," with "no exceptions." If your workflow involves generating code you do not fully understand, this project will not accept it, and the README says help will not be provided for ports produced that way.
RecompOne Compared with Emulators and Other Recompilers
The obvious alternative is a PlayStation emulator. The difference in approach is where the translation happens. An emulator fetches and decodes each instruction at runtime and needs a BIOS image; RecompOne translates ahead of time and, per the README, requires no BIOS or other proprietary files, only the game files. The result is a native C# build of one title rather than a general player for many. An emulator gives you a library; RecompOne gives you one port you have to build and maintain.
The closer comparison is N64Recomp and XenonRecomp, which the README names as the inspiration. They apply the same static recompilation idea to different hardware. The practical difference is maturity and platform surface, not method: those tools target their own consoles, and RecompOne targets the MIPS R3000A and the PS1 hardware set. Choosing between them follows from which console your game runs on, not from a feature comparison.
A related search term, Gen1Recomp, appears in the search data alongside RecompOne. The repository material does not mention it, so there is nothing here to compare. If you arrived looking for it, this project's README will not answer that question.
Licence and Maintenance Cost
RecompOne is MIT licensed, and the LICENSE file sits at the repository root. MIT is permissive: it allows use, modification and redistribution with the licence and copyright notice retained. That matters for a porting project because generated C# code and the runtime library ship together in your build. This is not legal advice, and the interaction between the MIT licence on the runtime and whatever rights you hold in a commercial game is a question for a lawyer, not for the README.
Maintenance is a real cost here. The last push to the repository was on 2026-09-12, and the maintainer states they are the only one, with limited time. The repository has no published GitHub releases, so you cannot pin to a tagged version; you build from the master branch. That means upgrades are a matter of pulling new commits and rebuilding both the recompiler and your port, and any change to CpuContext or the memory interface can ripple into generated code. Budget for re-running the recompiler after an update rather than assuming the output stays stable.
Editorial conclusion
RecompOne is for developers who want to port one specific PS1 title into C# and are willing to follow the wiki and write the glue code themselves; it is not for players who want to double-click an emulator and load a ROM, and it is not for anyone planning to submit AI-generated code, since the maintainer states those PRs are rejected. Before committing, verify that .NET SDK 10 installs cleanly on your machine, read the How to recompile a game? wiki page to see the actual porting steps, and confirm that your game is one whose BIOS calls and CD-ROM access pattern the runtime already models, because the README does not promise coverage for every title.
Frequently asked questions
What does recompilation mean in the context of RecompOne?
RecompOne translates all MIPS operations into C# ahead of time instead of fetching, decoding and executing each instruction at runtime, which is how the README describes static recompilation. The generated code runs on a CpuContext and a memory interface supplied by the runtime.
What is RecompOne?
RecompOne is a tool that statically recompiles PlayStation 1 executables into C# code, plus a runtime layer that translates the PS1 hardware environment for modern PCs. It is inspired by N64Recomp and XenonRecomp and is not affiliated with Sony or PlayStation.
Does RecompOne need a PS1 BIOS file to run a game?
No. The README states that no BIOS or other proprietary files are required and that only the game files are needed, because the runtime simulates BIOS functions itself. The runtime is a library you include in your recompiled game rather than a program you launch.
What do I need installed to build the RecompOne recompiler?
The README says RecompOne is a .NET project and that you need the .NET SDK 10 installed, after which you compile and run the recompiler. The runtime project is not meant to be run on its own.
Can I submit an AI-generated pull request to RecompOne?
No. The README states that any form of AI-generated PRs will not be accepted, with no exceptions, and that help will not be provided for ports produced that way. The maintainer also notes they are currently the only maintainer.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/blacklabelhq-recompone)Star history chart for your README
[](https://hysenlabs.com/projects/blacklabelhq-recompone)Was this useful?