3sx-portmaster-rocknix: The source port that drags Street Fighter III out of emulation and onto a handheld
A native PortMaster fork built for Rocknix devices, with ROM decryption, SDL3, rollback-ready netcode, and the kind of timing-sensitive architecture fighting games demand.
- This fork treats emulation as the fallback, not the default, and argues that a fighting game can be rebuilt as native software for low-power handhelds.
- Its portability comes from a layered engine design, where rendering, input, and platform behavior can swap underneath a stable game loop.
- ROM loading is part preservation work and part systems engineering, because the project has to reconstruct legacy asset formats and CPS3 security assumptions.
- PortMaster changes the design brief by forcing the port to respect small screens, limited storage, and handheld ergonomics without softening the game itself.
Why port a fighter when emulation already works?
That is the right question to start with, because the obvious answer on a retro handheld is usually emulation. It is simpler, familiar, and broad enough to cover nearly everything in the library. This repo takes a different route: run the game natively, control the frame timing directly, and own the whole stack from asset loading to presentation.
For a fighting game, that matters more than it would for a platformer or a puzzle title. Input latency, frame stability, and replay behavior are not extras. They are the product.
| Approach | What it runs | Strength | Weakness | Why this fork prefers it |
|---|---|---|---|---|
| Native source port | The game’s logic and assets reconstituted for the target platform | Lower-level control over timing, input, and presentation | Requires serious engineering work to rebuild old assumptions | It gives the fork room to optimize for handheld constraints without an emulator between player and game |
| Emulation | The original arcade or console binary inside a compatibility layer | Fastest path to broad compatibility | Adds another abstraction layer and limits fine-grained control | Good fallback, but not the best fit when timing and portability both matter |
| PC competitive setup | Source ports or emulators on a desktop with modern inputs and displays | Easy online play and flexible peripherals | Less portable and not handheld-first | Useful reference point, but not the device class this fork is targeting |
The repo is a bridge across three hardware eras
The interesting part of 3sx-portmaster-rocknix is not just that it runs on Linux. It sits at the junction of CPS3 arcade assets, the source-port lineage of 3SX, and Rocknix or PortMaster handhelds that expect careful treatment of CPU, storage, and display output.
That layering is the point. The project is not trying to preserve a single executable blob. It is translating old assumptions into a runtime that can survive on tiny ARM hardware.
Street Fighter III 3rd Strike 3SX Portmaster Rocknix by @djhardrich Sharpen up your skills on the go while you waiy for that @topapate #MiSTerFPGA core. Grab it here https://t.co/wNBmdS1JPB https://t.co/DpyHAmUZxX
How the engine stays portable
The codebase leans on a driver pattern in the renderer and app layers. The practical effect is simple: the game logic does not have to care whether the output is SDL3 on a handheld, another host API, or a different backend in an upstream build. The same core can move between targets because the platform-specific parts are isolated.
That matters more in a fork like this than in a desktop project. If the rendering or input layer leaks into the game loop, portability stops being a property of the code and becomes a series of one-off patches.
// Conceptual shape of the platform split
if (driver == CRS_VIDEO_DRIVER_SDL) {
Renderer_DrawSprite_SDL(...);
} else if (driver == CRS_VIDEO_DRIVER_PSP) {
Renderer_DrawSprite_PSP(...);
}
// Core game logic stays agnostic
App_RunFrame(&app);
The weirdly important part: timing
Fighting games punish sloppiness. That is why the main loop and task system are more important here than they would be in a typical port. The repo’s task-slot structure, including the loop task that drives frame-by-frame behavior, is built to keep the game’s logic moving in a disciplined sequence instead of letting the host platform decide the rhythm.
In practice, that means input buffering, replay state, and scheduling are first-class concerns. When the game is expected to feel correct on a portable device, the loop itself becomes part of the user experience.
// Simplified view of the task loop
for (int i = 0; i < 11; i++) {
if (tasks[i].condition == TASK_ACTIVE) {
tasks[i].func_adrs();
}
}
njUserMain();
appCopyKeyData();
// frame-by-frame timing and input state stay in lockstep
ROM loading is a preservation problem, not just an I/O problem
This is where the project stops looking like a convenience fork and starts looking like digital archaeology. The loader has to find the right arcade assets, read them from compressed archives, identify the expected SIMM files, and apply CPS3 decryption logic that mirrors what the original security hardware enforced.
That is not ordinary file handling. It is a reconstruction of a historical trust model, where the software needs to understand both the shape of the data and the hardware assumptions that once guarded it.
| Asset path | What it expects | What the code does | Why it matters |
|---|---|---|---|
| Arcade ZIP | SIMM files and CPS3-era assets | Locates the right files and decrypts them before use | Preserves the original arcade data path instead of flattening it |
| PS2 ISO | Disc-based content | Reads assets from image files through the platform layer | Lets the fork use a second legacy source without rewriting the core |
| Plain modern install | Already-unpacked files | Would be easier, but less historically faithful | Reduces the preservation value of the port and hides the original structure |
Why PortMaster changes the design
PortMaster is not just a packaging target. It changes the practical definition of a good port. On a handheld with a modest display and limited storage, integer scaling, fullscreen behavior, and avoiding unnecessary writes are not polish. They are compatibility work.
That is why the fork’s Rocknix-specific choices matter. The code is not chasing desktop convenience. It is trying to feel native on a small device that has to boot fast, render cleanly, and leave the storage alone as much as possible.
| Constraint | Desktop default | PortMaster reality | Design consequence |
|---|---|---|---|
| Scaling | Flexible but often filtered or blurred | Integer scaling is preferred | Keeps pixels crisp on small screens |
| Display | Windowed or mixed display modes | Fullscreen is often the sensible default | Reduces friction and matches handheld expectations |
| Storage writes | Usually not a concern | Flash wear and limited space matter | The port avoids needless copying and churn |
What this fork suggests about the future of retro play
The bigger lesson is not that emulation is obsolete. It is that some genres benefit from a different path. Fighting games care about timing, netcode, and response. If a source port can preserve the original feel while making the runtime portable, it can beat a compatibility layer at its own game.
That makes this repo more than a niche experiment. It is a case study in how old games can be reconstituted for new hardware without turning them into museum pieces.




