Linux games and native ports, running on your own phone's GPU
No streaming, no middleman, no root — rendering and input all happen on the phone itself.
Status: the project is still being prepared. The source code is not public yet — it will be open-sourced here once the release is ready. Until then this repository holds the documentation and the test APK: download it from Releases.
Nixport is a launcher for Linux programs on Android phones. It runs ported Linux games — called Ports — directly on the phone's GPU, and translates your touches, keys and gamepads into input the game understands. Everything happens locally; no server is involved.
The scope, up front: Nixport runs Linux programs (ELF binaries) only. Windows programs (.exe) are out of scope — that is the territory of Wine-based tools like Winlator. The native residents here are Linux builds of PS4 / Switch / PC game ports.
- Store — browse the community catalogue (the first entries are about to land), tap a cover card to jump to the author's own repository and download. The "verified" badge means a maintainer ran that exact build on a real device.
- Library — an imported package becomes a cover card with one or more launch entries ("Open launcher" / "Play now").
- Session — the game runs in its own full-screen window; a drawer on the left edge holds three tabs — Display / Input / Session — with the performance HUD, frame generation, logs and the stop button.
- Input — touch, USB/Bluetooth mouse and keyboard, physical gamepads, on-screen virtual buttons. Gamepads are registered on the guest side as standard devices, so games recognise them without special support.
- Frame generation — intermediate frames are rendered at an integer multiple of the source frame rate, so a high-refresh panel shows smoother motion (the game must run with "direct picture output"; devices that fall short are refused with the reason).
- Display drivers — two independent slots: the runtime driver (guest rendering) and the display driver (presentation and frame generation). Download them from community sources and switch at any time.
- Saves — reinstall the same package and your saves come with it.
- Interface language — English / 简体中文 / Română, switchable in the settings.
You don't need: a PC, root, a streaming setup, or an extra gamepad.
nix carries three meanings: the *-nix naming tradition of Linux; the slang for "nothing" — zero proot tax; and the execution model that talks to the kernel directly, without syscall traps. port is "porting".
Nixport has nothing to do with the Nix package manager. It is only a name collision.
- Install the APK — download the build from Releases and install it; it ships the Linux environment inside the APK and unpacks it on first run.
- First-run wizard — grant shared-storage access (you can skip it), then unpack the Linux environment (~5 GB, once, keep the app in the foreground).
- Environment check — the top of the launcher shows whether the environment is ready, and why not if it isn't; the full report is under Settings › Environment.
- Get a game —
- open the Store tab and browse the community catalogue (first entries coming soon), tap a cover card to jump to the author's GitHub Releases;
- until the store opens, ports are distributed through the authors' own channels (GitHub Releases, community posts): import the
.zippackage /.AppImageinto the Library — that works right now, no need to wait for the store.
- Tap an entry on the cover card — "Play now" goes straight into the game; "Open launcher" opens the port author's own launcher screen, where patches, cheat codes and graphics options live.
Running x86 Linux programs additionally needs the x86 guest environment. The app detects this and offers the download (32-bit libraries included); native ARM64 ports do not need it.
| Requirement | Notes | |
|---|---|---|
| Chip | ARM64 (x86 programs also need ARMv8.2 — Snapdragon 845 or newer) | native ARM64 ports need only ARM64; FEX translation needs ARMv8.2 |
| GPU | Adreno 6xx / 7xx / 8xx | Turnip supports only these. Other GPUs fall back to CPU rendering: 2D and light programs are fine, big 3D games are not |
| Driver | the system driver is enough to start | no driver ships in the APK; newer GPUs (Adreno 8xx, for instance) usually need one fetched from a community source on the driver download page |
| OS | Android 12+ (tested on 14 and 16), 64-bit | |
| Page size | 4 KB | the Linux environment is built for 4 KB pages; 16 KB-page devices (some newer models) are not compatible — the app checks and stops you before that |
| RAM | 12 GB+ for big 3D games | the game takes 5–6 GB plus 3–4 GB of video memory — on a phone that is the same memory |
| Storage | ~5 GB for the Linux environment, plus the game itself | tens of GB more for a big 3D game |
| Developer options | turn on "Disable child process restrictions" | Android 12+ caps child processes (limit 32) and the system may kill the guest; on Android 14+ flip the toggle in Developer options, on earlier versions use the in-app one-tap fix |
In the PS4 / Switch / PC porting community, every port ships with its own PC launcher — patches, cheat codes, graphics options, game-directory picking. Porting to Android usually means writing another launcher on top: how to present the picture, how to get audio out, how to wire a gamepad, where saves live.
So it goes: port a game, write a launcher; port ten games, write ten launchers. And presentation, audio, input and gamepads — the same four problems — are re-solved by every project.
That is not a guess, it is evidence. The ancestor of this project and the Android launcher of gow_android_glibc (the Monster Hunter, Bloodborne lines) are the same code: the same package name ro.cobrabm.fexdroid, the same Xvfb shared-memory layout, the same fxpresent audio FIFO socket path, the same XTEST input injection. Two rivers each built the other one's half.
So Nixport does the opposite:
before after
┌──────────────────────┐ ┌──────────────────────────────┐
│ port a game │ │ port a game │
│ ↓ │ │ ↓ │
│ write an Android app │ → │ build a package (a Port) │
│ ↓ │ │ ↓ │
│ solve display, audio,│ │ launch, display, audio, │
│ input and gamepads │ │ input are handled for you │
│ ↓ │ │ ↓ │
│ every version drifts │ │ the platform owns it; drift │
│ │ │ is managed in one place │
└──────────────────────┘ └──────────────────────────────┘
The porting community's work collapses into "packaging", not "writing an app". A platform fix reaches every game at once; a game-specific problem gets fixed inside that game's own launcher.
x86 programs have FEX-Emu to translate them, but ARM64 Linux programs need no translation at all — they exec nativ 8000 ely, glibc goes straight to the kernel, Vulkan calls go straight to the GPU. One layer less means one layer less of performance loss and compatibility trouble.
Phones already have desktop-class GPUs (Snapdragon 8-series with Adreno 7xx/8xx), 12–16 GB of memory, and an open, patchable Vulkan driver (Mesa Turnip). For the first time, the hardware and the software are both there.
And "it doesn't run" should never be a black screen with no information. Failing clearly is a product goal: when something won't run, Nixport tells you why.
Built a port of your own, or want to package one for Nixport? Start here — the full contract lives in
docs/ports.md(field tables, launch semantics, environment variables, the bus protocol, lifecycle).
A Port = one label + one self-contained executable, shipped as a .zip:
port.zip
├── port.json ← the label: schema / id / name / entries / storage / logs
└── <name>.AppImage ← exactly one: AppImage type 2 (ELF runtime + squashfs)
└── unpacked → squashfs-root/ (the AppDir; AppRun is the entry point)
{
"schema": "nixport.port.v1",
"id": "example-port",
"name": "Example port",
"version": "1.0.0",
"entries": [
{ "id": "launcher", "name": "Launcher", "kind": "launcher", "command": "AppRun launcher", "display": "x11" },
{ "id": "game", "name": "Play now", "kind": "direct", "command": "AppRun game", "display": "direct" }
],
"storage": { "home": "home" },
"logs": ["logs/last_run.log"]
}Three rules:
- The subject of the package is a Linux program, not a game — the format carries no game semantics at all.
- Configuration lives inside your launcher — patches, cheat codes, graphics options and directory picking are all in your launcher's own screen. The platform reads the shape of the JSON and never renders a configuration form.
- Game files do not go into the image — the user picks the game directory inside your launcher (via
nxp-port pick-dir) and the path is stored in your own writable directory (storage.home, the session$HOME). That directory is also the backup unit: reinstalling the sameidcarries the saves over.
What the host takes care of: launching (sh -c "cd squashfs-root && exec …", with first-word anchoring and the exec bit repaired), X11 and PulseAudio, the virtual gamepad, fonts, the host service bus (toast / dialog / pick-dir), save migration on upgrade, and failure diagnostic snapshots. Boundaries you should know: the native gamepad shim only reaches games that link SDL dynamically; your launcher UI must be touch-friendly by itself (the platform ships no UI toolkit); game data on shared storage (/sdcard, FUSE) has mediocre random-read performance, so guide big files into storage.home inside your launcher.
| Capability | How to use it |
|---|---|
| Host service bus | nxp-port toast "Save written", nxp-port dialog --title Notice --text Body, nxp-port pick-dir --initial /sdcard/games |
| Shared storage | /sdcard is visible to the guest — put the game dump on the phone's shared storage |
| Display | X11 (DISPLAY=:0) + Vulkan, with the ICD locked to Turnip; an entry declaring "display": "direct" takes the frame-straight-to-host path, the only one frame generation works on (presentation paths) |
| Audio | PulseAudio (PULSE_SERVER) |
| Gamepads | ARM64: a virtual Xbox 360 pad registered inside the game's own SDL3 via the libfexpad.so shim (dynamic SDL linking required); x86: through FEX's virtual input devices |
| Fonts | the runtime ships CJK fonts; native ports point FONTCONFIG_FILE at them so Chinese never renders as boxes |
The environment-variable table, the bus protocol and the lifecycle rules live in docs/ports.md; reference implementations for packaging live in scripts/build-port-appimage.sh and scripts/nxp-port.
The catalogue repository NixPort/nixport-store holds links and metadata only — never a .zip or an .AppImage. Each entry points at the author's own GitHub repository and releases; downloads happen in the user's browser, and installation goes through the app's import channel. The "verified" badge is set by a maintainer after a real-device check, never by the author. The catalogue schema and a local CI check live in this repository under store/.
flowchart LR
P["port package (.zip)<br/>port.json + AppImage"] --> I["import: unpack once<br/>derive arch · derive cover"]
I --> L["Library: cover card + entries"]
L --> S["Session: AppRun"]
S --> R["rendering<br/>Mesa Turnip → Adreno"]
R -->|"direct: frames straight to host"| D["display bridge<br/>composite · frame-gen · present"]
R -->|"x11: through Xvfb"| D
D --> O["phone screen"]
S --> A["audio<br/>PulseAudio → AAudio"]
S --> G["input<br/>XTEST · virtual pad → guest"]
X["x86 Linux program<br/>FEX JIT"] --> S
- Execution — ARM64 programs exec natively; x86/x86_64 programs are JIT-translated to ARM64 by FEX-Emu, with glibc going straight to the kernel (no proot-style ptrace tax).
- Graphics — rendering always happens on the GPU: Mesa Turnip is the open-source Vulkan driver for Adreno, talking to
/dev/kgsl-3d0directly. Presentation has two paths: the compatibility path through Xvfb (software present, one CPU copy, capped by Xvfb's 60 Hz clock) and the performance path, where a patched Mesa hands frames straight to the display bridge over shared memory — the only path frame generation works on. The full trade-offs are indocs/graphics.md. - Common ground — the app carries a small Debian userland tailored to Android's restrictions (a patched glibc — including SysV shm rebuilt over memfd, so Xvfb's shared framebuffer works without root — plus FEX and Mesa); every deviation lives in
patches/and is built byscripts/. Drift is managed in that one place; upstream components are built as-is. - Gamepads — the x86 track appears as standard
/dev/inputevents through FEX's virtual input devices; the native track registers the same virtual pad inside the game's own SDL3 through anLD_PRELOADshim (dynamic SDL linking required).
- The compatibility window is deliberately narrow. Adreno 6xx/7xx/8xx, 4 KB pages, Android 12+. Narrow is not a flaw, it is the positioning: we would rather say plainly "this phone will not do" than try to run everything.
- Heat decides the frame rate. Phones throttle when hot — a Snapdragon 888 drops to about 40%. Take the case off, don't cover the phone, and avoid running flat out while charging.
- Memory runs out first. On a 12 GB phone, a few sessions in a row can get the game killed by Android. The app warns you in advance; restart it between sessions.
- Performance numbers come from real devices, not estimates; the measurement method and data will ship with the public docs in
docs/.
This section is a set of hard rules, not a disclaimer template.
The platform provides and distributes no game content.
- This repository and the app contain no third-party game binaries, assets or saves. Game content is obtained by you, from lawful sources.
- Ports are built and distributed by the porter. The copyright and compliance of what is inside a package is that porter's responsibility; the platform provides the ability to load and run it, and endorses none of it.
- The store holds links and metadata only; it hosts no distribution packages. Downloads happen in the user's own browser.
- Community GPU drivers are imported by the user or downloaded from their original repositories; the platform is a download proxy and redistributes nothing.
- We do architecture-level reference only and copy nobody's code: Winlator, GameNative and DroidDeck are behavioural references, nothing more.
Trademarks and affiliation.
- Tux the penguin is a trademark of the Linux Foundation; the Android robot is used per Google's brand guidelines. This project does not imply any official endorsement.
- FEX-Emu, Mesa, AppImage and the rest belong to their authors; this project only depends on them.
- This project is not affiliated with, sponsored by, or endorsed by any game publisher or porting project.
When you use it, obey the laws where you live, the terms of the game's publisher, and the legality of every package you import. This project does not vouch for the legality of any game content.
The full component ledger is in LICENSES.md.
You need a Linux host, the Android SDK and NDK, and Docker.
scripts/check-host.sh # check the host is ready first
scripts/build-payload.sh # build the payload (rootfs / glibc / FEX / Mesa; hours)
./gradlew :app:assembleDebug- The app targets targetSdk 28: from SDK 29 on the platform enforces W^X for app data, so the guest programs under
files/rootfscould not be exec'd. There is a single build — the store-distribution variant was dropped, because the rootfs bakes its absolute path (/data/data/ro.cobrabm.fexdroid/files/rootfs) into every ELF and a differentapplicationIdmovedfilesDiraway from it. - Upstream components are built as-is; every deviation is collected in
patches/and stays replayable. - The session stack is currently X11-only; the Wayland variant is being validated on its own branch and is not merged yet.
- Debugging and measurement:
scripts/adb-run.sh(run guest commands over adb),scripts/fex-bench-phone.sh(FEX benchmarks),scripts/fex-tso-check.py,scripts/perf-by-block.py. The failure scene lands infiles/last-run.log(adb shell run-as ro.cobrabm.fexdroid cat files/last-run.log).
| File | Contents |
|---|---|
docs/ports.md |
the Port packaging contract: full port.json fields, launch semantics, environment variables, bus protocol, lifecycle, store listing |
docs/graphics.md |
presentation paths: compatibility vs direct, the display bridge and frame generation, design trade-offs |
docs/ |
more topics grouped by directory; the index is docs/README.md |
- Nixport's own code is distributed under GPL-3.0-only; the portions inherited from upstream fexdroid remain available under their MIT licence. See
LICENSE. - The component ledger — who is used for what, which obligations come with it, where the conflicts are — is in
LICENSES.md. - Credits: FEX-Emu, Mesa, AppImage, X.Org, PulseAudio, plus Marius upstream and the whole porting community.
In the app: Settings › Send report, or the Send log button after a program exits. It bundles device information, the app log and a few self-tests (no passwords, but read it before posting it in public), then open an issue.
Want to help? More material lives in docs/.
The phone is ARM64, the screen is Adreno, the graphics are open source — the rest is up to the community.