8000 GitHub - zFitness/nixport: Nixport is a launcher for Linux programs on Android phones. No Root, No Proot · GitHub
[go: up one dir, main page]

Skip to content
zFitnessPublic

About

Nixport is a launcher for Linux programs on Android phones. No Root, No Proot

Resources

Stars

23 stars

Watchers

1 watching

Forks

Latest commit

 

History

2 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 

Repository files navigation

nixport

NATIVE PORT · NO ROOT · NO PROOT

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.

Android APK CI Full APK CI License Stars Forks Issues Platform No root No proot

简体中文 · Română

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.


What this is

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.

Where the name comes from

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.


Getting started

  1. 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.
  2. 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).
  3. 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.
  4. 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 .zip package / .AppImage into the Library — that works right now, no need to wait for the store.
  5. 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.

What your phone needs

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

Why this exists

1. Stop writing an Android launcher for every port

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.

2. ARM Linux programs deserve a native way in

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.

3. Running Linux programs on a phone is worth doing on its own

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.


Port: for porters

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:

  1. The subject of the package is a Linux program, not a game — the format carries no game semantics at all.
  2. 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.
  3. 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 same id carries 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.

What the guest gets (quick reference)

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.

Listing in the store

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/.


How it runs

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
Loading
  • 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-3d0 directly. 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 in docs/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 by scripts/. Drift is managed in that one place; upstream components are built as-is.
  • Gamepads — the x86 track appears as standard /dev/input events through FEX's virtual input devices; the native track registers the same virtual pad inside the game's own SDL3 through an LD_PRELOAD shim (dynamic SDL linking required).

Known limits

  • 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/.

Compliance and legal boundaries

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.


Development

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/rootfs could 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 different applicationId moved filesDir away 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 in files/last-run.log (adb shell run-as ro.cobrabm.fexdroid cat files/last-run.log).

Documentation

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

Licence and credits

  • 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.

Reporting problems

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.

About

Nixport is a launcher for Linux programs on Android phones. No Root, No Proot

Resources

Stars

23 stars

Watchers

1 watching

Forks

Releases

Packages

Contributors

0