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.

8 min read • View on GitHub • More from djhardrich

An arcade control panel feeds a stream of circuit traces, ROM chips, and decryption marks into a small handheld console. The old machine feels heavy and archival, while the handheld feels compact and immediate, explaining how a classic fighter can be reconstituted as native portable software.
The project’s core idea is translation, not emulation. Old arcade assumptions are unpacked and rebuilt for a pocket-sized device.
Key Takeaways

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.

ApproachWhat it runsStrengthWeaknessWhy this fork prefers it
Native source portThe game’s logic and assets reconstituted for the target platformLower-level control over timing, input, and presentationRequires serious engineering work to rebuild old assumptionsIt gives the fork room to optimize for handheld constraints without an emulator between player and game
EmulationThe original arcade or console binary inside a compatibility layerFastest path to broad compatibilityAdds another abstraction layer and limits fine-grained controlGood fallback, but not the best fit when timing and portability both matter
PC competitive setupSource ports or emulators on a desktop with modern inputs and displaysEasy online play and flexible peripheralsLess portable and not handheld-firstUseful 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.

The architecture is layered on purpose. Legacy assets enter at the top, the game loop lives in the middle, and platform-specific output changes at the bottom.

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

Pixel Cherry Ninja, PixelCNinja, 10,157 followers · @PixelCNinja on X

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);
A close-up machine shows a raw legacy game asset passing through a decryption gear, then through a narrow handoff gate, and emerging into two output channels labeled by visual symbols rather than text. The image explains how one stable core can feed different platform backends without changing the underlying game logic.
The fork works because the core game loop is insulated from the host platform. The backend changes, but the engine keeps its shape.

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 pathWhat it expectsWhat the code doesWhy it matters
Arcade ZIPSIMM files and CPS3-era assetsLocates the right files and decrypts them before usePreserves the original arcade data path instead of flattening it
PS2 ISODisc-based contentReads assets from image files through the platform layerLets the fork use a second legacy source without rewriting the core
Plain modern installAlready-unpacked filesWould be easier, but less historically faithfulReduces 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.

ConstraintDesktop defaultPortMaster realityDesign consequence
ScalingFlexible but often filtered or blurredInteger scaling is preferredKeeps pixels crisp on small screens
DisplayWindowed or mixed display modesFullscreen is often the sensible defaultReduces friction and matches handheld expectations
Storage writesUsually not a concernFlash wear and limited space matterThe 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.