ARMSX3: an Android port of RPCS3 for ARM64 phones

What ARMSX3 actually is, and who it is for

ARMSX3 is an Android port of RPCS3, the PlayStation 3 emulator, targeting ARM64 devices. The README states it "Uses the latest RPCS3 upstream code (the recent ARM64 improvements included)," which places it downstream of RPCS3 rather than as an independent emulator core. The repository is a C++ project under GPL-2.0-only, with the Android application living under android/ and the emulator core under rpcs3/.

The audience is narrow. Anyone who wants a PS3 emulator on a phone will find no APK download link, no sideloading instructions, and no setup guide in the README. What the README does provide is a toolchain description: Android SDK with NDK r27 or newer, CMake 3.30 or newer, JDK 17, and the note that Android Studio ships all of these. That is a developer-facing document. The project is for people who can clone a repository with submodules, satisfy a CMake toolchain file, and run Gradle.

There is also a legal boundary the README states plainly: "Running it needs PS3 firmware, which is not included." Nothing in the repository supplies that firmware, and the README does not say where to get it. Whatever a reader does about that is outside the project's scope.

How the core, the shader backend and the Android app fit together

The build has three layers, and the README is explicit that they are not wired together automatically.

The first layer is the emulator core, compiled from rpcs3/ plus android/src/ into a shared library named libarmsx3-core.so. The CMake target is rpcsx-android, and the README warns the unstripped output is around 1.3 GB, which is why the next step is llvm-strip. The second layer is the Android UI, a Gradle project at android/armsx3-ui that consumes the stripped core from app/src/main/jniLibs/arm64-v8a/. The third layer is a set of third-party checkouts that are not git submodules and must be fetched by hand: librashader from SnowflakePowered, which handles the shader pipeline, and libadrenotools from bylaws, which the README places under the app's cpp directory.

The consequence of that split is stated in the README: "the core library has to be rebuilt and copied again whenever anything under rpcs3/ or android/src/ changes. Gradle does not build it for you." That is the single most important operational fact about the project. If you edit core code and run only the Gradle task, you are testing a stale library.

One optional component is proprietary. The Discord Social SDK is not redistributed in the repository; the README says to get it from Discord's developer portal and place it in app/libs/ and app/src/main/cpp/discord_sdk/. The build skips it when it is absent, so it is genuinely optional rather than a hidden requirement.

Building ARMSX3: from clone to a release APK

The README gives a complete build sequence. Start by cloning with submodules, then fetch the two repositories that are not submodules. Both commands are copied from the README.

git clone --recursive https://github.com/ARMSX2/ARMSX3.git
cd ARMSX3
git clone https://github.com/SnowflakePowered/librashader 3rdparty/librashader
git clone https://github.com/bylaws/libadrenotools android/armsx3-ui/app/src/main/cpp/libadrenotools

Next, configure and build the core. This is the long step, and the README sets expectations: the unstripped library is around 1.3 GB. Note that the NDK path contains a placeholder for your installed version.

export ANDROID_HOME=$HOME/Library/Android/sdk
cmake -B build-android -G Ninja \
  -DCMAKE_TOOLCHAIN_FILE=$ANDROID_HOME/ndk/<version>/build/cmake/android.toolchain.cmake \
  -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-31 \
  -DCMAKE_BUILD_TYPE=RelWithDebInfo
cmake --build build-android --target rpcsx-android -j8

After that, strip the library and put it where the app expects it. Skipping the copy is the most likely reason a fresh APK behaves like an older build.

llvm-strip --strip-unneeded build-android/android/libarmsx3-core.so
cp build-android/android/libarmsx3-core.so \
   android/armsx3-ui/app/src/main/jniLibs/arm64-v8a/

Finally, build the app. The README's JAVA_HOME example points at a macOS Android Studio installation; on Linux or Windows the path differs. The APK lands in app/build/outputs/apk/release/.

cd android/armsx3-ui
export JAVA_HOME="/Applications/Android Studio.app/Contents/jbr/Contents/Home"
./gradlew :app:assembleRelease

A first real use means installing that APK on an ARM64 device and supplying PS3 firmware, which the README says is required and not included. The README does not document the in-app firmware import step, so that part of the flow is undocumented.

The build pipeline is the limitation, not the emulation

The README is silent on several things a prospective user would want to know. There is no statement about which Android versions beyond android-31 are supported, no list of tested devices, no performance guidance, and no compatibility list. The repository has an assets/ directory and a bin/ directory, but the README does not explain what either contains for the Android target.

The manual core copy is a real failure mode, not a stylistic complaint. Because Gradle does not build the core, a developer who changes anything under rpcs3/ and runs only assembleRelease gets an APK containing the previous libarmsx3-core.so. Nothing in the build output flags this. The README's note is the only warning.

The 1.3 GB intermediate is another practical constraint. RelWithDebInfo keeps debug information, which is useful for diagnosing emulator crashes and expensive in disk and link time. The README does not describe a release-only configuration for the core, so the strip step is doing the work that a different CMAKE_BUILD_TYPE might otherwise do.

Where ARMSX3 is the wrong tool: if you want to run PS3 games on a phone without touching a compiler, this repository does not offer that path. If you need a supported, documented product with a compatibility database, the README points you at nothing of the sort. And if your device is not arm64-v8a or armv8.2, the README's stated support does not include you.

ARMSX3 versus RPCS3 and versus aps3e

The most direct comparison is with RPCS3 itself, the upstream project ARMSX3 is built from. RPCS3 is a desktop emulator; its codebase is the one ARMSX3 compiles, and the README credits the ARM64 improvements in upstream as the reason the port is viable. The difference in approach is packaging and platform: RPCS3 ships desktop builds for Windows, Linux and macOS, while ARMSX3 wraps the same core in an Android UI, adds libadrenotools for Adreno driver handling, and routes the shader pipeline through librashader. Choosing RPCS3 means choosing a desktop target and its own release process; choosing ARMSX3 means accepting a manual CMake and Gradle build and a core library you must copy by hand.

The other comparison that surfaces in search is aps3e, another Android PS3 emulator effort. The README says nothing about aps3e, so any difference in architecture, compatibility or performance cannot be established from this repository. The only defensible statement is that ARMSX3 documents its origin as RPCS3 upstream code, whereas nothing here describes aps3e's lineage. A reader comparing the two should look at each project's own documentation rather than treat the names as interchangeable.

Licence, maintenance and the cost of staying current

ARMSX3 is GPL-2.0-only, the same licence as RPCS3, and the README adds a caveat: "Some files may be licensed differently, check the file headers." That matters for anyone redistributing a modified build, because the per-file headers, not the top-level LICENSE, govern those files. This is a description of what the repository says, not legal advice; a distributor should read the headers and the GPL text itself.

The proprietary Discord Social SDK introduces a second licensing surface. It is not redistributed in the repository, and the README directs users to Discord's developer portal. A build that includes it mixes GPL-2.0-only code with a proprietary component, and the README does not discuss how those interact. That is a question for the distributor, not something the documentation resolves.

Maintenance looks active on the evidence available: the repository is not archived, and the last push was on 2026-09-15, the same date as the 0.9.9r release. Releases 0.9.8.1 and 0.9.8.2 both landed on 2026-09-13, which suggests a fast patch cadence around a 0.9.9 line. The upgrade cost is the build cost. Because the core is not built by Gradle, every upstream RPCS3 change you pull in requires a fresh CMake build, a strip, and a copy into jniLibs before the APK reflects it. There is no documented incremental path and no prebuilt core artifact mentioned in the README.

Editorial conclusion

ARMSX3 is for developers and testers with an ARM64 Android device, the Android SDK with NDK r27 or newer, and a willingness to rebuild the core library whenever rpcs3/ or android/src/ changes, since Gradle will not do it. It is not for anyone expecting an app-store install: the README gives no user-facing setup, and PS3 firmware is required but not included. Before adopting it, verify the licence headers on the files you plan to ship, confirm where you obtain PS3 firmware legally in your jurisdiction, and check the 0.9.9r release notes for what changed since 0.9.8.2.

Frequently asked questions

Official sources

1. ARMSX2/ARMSX3 on GitHub
2. Issues
3. License: GPL-2.0
4. README
5. Releases