# How to Run Factorio on Android Without an Emulator: Pocket Foundry Setup Guide

> AI Release · @ai_release1 · https://ai-release.org/guides/kak-zapustit-factorio-na-android-bez-emulyatora-poshago_en.html

## TL;DR

- **Time:** 30–45 minutes, most of it spent downloading the game archive.
- **Difficulty:** Intermediate — you need `adb` (Android Debug Bridge, the command-line tool that talks to a phone over USB) or a file manager, plus a paid Factorio account.
- **You will need:** an Android 10+ phone with an **Adreno** GPU (Qualcomm Snapdragon), the Pocket Foundry APK from its GitHub Releases page, an official Linux ARM64 Factorio build as a `.tar.xz` file from factorio.com, and free internal storage.

## Requirements and setup
![Illustration: Requirements and setup](https://ai-release.org/guides/img/kak-zapustit-factorio-na-android-bez-emulyatora-poshago-en-1.jpg?v=1793284602)


Pocket Foundry is a wrapper that runs the **official Linux ARM64 build of Factorio** directly on the phone's CPU and through **Mesa** (an open-source graphics driver stack that translates OpenGL calls) on the GPU. There is no emulator and no x86 translation layer in the chain — the post is explicit about that.

Checklist before you start:

- [ ] Android **10 or newer**.
- [ ] **Adreno GPU.** Mali and Xclipse (the GPUs in MediaTek Dimensity and Samsung Exynos chips) are reported as **not working**.
- [ ] A **legitimate Factorio licence** — the game is bought separately on factorio.com; the APK ships no game data.
- [ ] The **Pocket Foundry APK** downloaded from the project's GitHub Releases page.
- [ ] The **Linux ARM64 `.tar.xz`** archive from factorio.com downloaded to the phone or to a PC you can copy from.
- [ ] Free storage for the archive plus the installed game. The exact figure is not published — **check the documentation** for the current download size.
- [ ] `adb` and USB debugging enabled, or a file manager app if you prefer to move files by hand.

GPU support as stated in the source material:

| GPU family | Typical chips | Status |
|---|---|---|
| Adreno | Qualcomm Snapdragon | Works (verified on one phone) |
| Mali | MediaTek, Exynos | Not working |
| Xclipse | Dimensity, Exynos | Not working |

If you have never used `adb` or a Linux-on-Android toolchain, read [How to Run Linux on Android Without Root: Termux, PRoot, and AI Tools](https://ai-release.org/guides/kak-zapustit-linux-na-android-bez-root-termux-proot-i-i.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide) first — it covers the shell basics this guide assumes.

## Step 1. Confirm your phone is supported before downloading anything

**What to do:** Read three system properties from the device and check them against the compatibility rules.

**Why:** Mali and Xclipse devices cannot run this port at all. Verifying first saves you a multi-gigabyte download and an install that ends in a black screen.

**How to check:** Connect the phone with USB debugging on, then run:

```bash
adb devices
adb shell getprop ro.build.version.release
adb shell getprop ro.hardware.egl
adb shell getprop ro.board.platform
```

Example output on a supported device:

```
List of devices attached
R58M1234ABC     device
14
adreno
kalama
```

Read it like this: `14` means Android 14 (must be 10 or higher), `adreno` is the GPU vendor — anything containing `mali`, `xclipse`, or `mt` points to an unsupported GPU. `kalama` is a Snapdragon platform codename; the exact value varies by model and is informational only.

If you have no PC, install a terminal app on the phone and run the same `getprop` commands there; `getprop ro.hardware.egl` alone is usually enough to settle the question.

**Example:** `getprop ro.hardware.egl` returning `adreno` on a Snapdragon 8-series phone means you can continue. Returning `mali` means stop here.

## Step 2. Install the APK and import your Factorio archive
![Illustration: Step 2. Install the APK and import your Factorio archive](https://ai-release.org/guides/img/kak-zapustit-factorio-na-android-bez-emulyatora-poshago-en-2.jpg?v=1793284608)


**What to do:** Install the Pocket Foundry APK, then import the official Linux ARM64 `.tar.xz` into the app.

**Why:** The app is a launcher plus a compatibility layer. The binary it runs is the Linux ARM64 build you download yourself from factorio.com, which is why the game must be purchased separately.

1. Buy Factorio on factorio.com and download the **Linux ARM64** build as a `.tar.xz` archive. Do not use the Windows `.zip` and do not use a build for another architecture — the app expects the Linux ARM64 archive.
2. Download the APK from the **Releases** section of the pocket-foundry GitHub repository. The exact asset filename changes between releases — **check the documentation** on that page.
3. Verify the archive you actually received:

```bash
sha256sum factorio.tar.xz
file factorio.tar.xz
```

**Example output:**

```
XZ compressed data
```

If `file` reports `Zip archive data` instead, you grabbed the wrong platform build — go back and download the Linux ARM64 `.tar.xz`. Compare the SHA-256 value with the one published in the release notes; the post does not quote a hash, so **check the documentation**.

**How to check:** Install and confirm the package is present:

```bash
adb install pocket-foundry.apk
adb shell pm list packages | grep -i foundry
```

Expected: `Success` from the install, then a line such as `package:...foundry...`. The exact package identifier is listed in the project README — **check the documentation**. After importing the archive inside the app, the game entry should appear without an import error banner.

## Step 3. First launch and verification
![Illustration: Step 3. First launch and verification](https://ai-release.org/guides/img/kak-zapustit-factorio-na-android-bez-emulyatora-poshago-en-3.jpg?v=1793284614)


**What to do:** Start Factorio from the app, let it reach the main menu, and capture the log while it runs.

**Why:** A clean log plus a rendered main menu proves the Mesa graphics path is working on your Adreno GPU; a crash at startup is the most common failure and leaves a clear trace in logcat (Android's system log stream).

**How to check:**

```bash
adb logcat -c
adb logcat | grep -iE "foundry|factorio|FATAL|EGL"
```

**Example of a healthy run:** the log streams shader and EGL lines from the graphics stack, and the phone shows the Factorio main menu with the version string in the corner. Success looks like: main menu visible, no `FATAL EXCEPTION` line in the filtered output, and a new game world loading past the "generating map" step.

**Example of a failure:** the app closes back to the home screen within a few seconds and the filtered log ends with a `FATAL EXCEPTION: main` block — see Troubleshooting below.

Expect lower frame rates than on a desktop; the post gives no benchmark numbers, so measure on your own device rather than relying on quoted figures. This is the same "native port, no emulator" pattern used by the NVIDIA SHIELD game ports covered in [How to Run Metal Gear Solid 2 HD and Other NVIDIA SHIELD Ports on Android](https://ai-release.org/guides/kak-zapustit-metal-gear-solid-2-hd-i-drugie-porty-nvidi.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide).

## Troubleshooting

**Problem. The app flashes a black screen and closes immediately on a Dimensity or Exynos phone**

- Error: `` FATAL EXCEPTION: main `` at the end of the logcat output, preceded by native graphics/EGL lines.
- Cause: the device has a Mali or Xclipse GPU. The port targets Adreno via Mesa; those GPU families are reported as unsupported.
- Solution: confirm the GPU and stop here if it is not Adreno:

```bash
adb shell getprop ro.hardware.egl
```

A value of `mali` or an Xclipse value means the hardware is not supported by Pocket Foundry. Use a Snapdragon device instead.

**Problem. The installer refuses the APK**

- Error: `` INSTALL_FAILED_INSUFFICIENT_STORAGE ``
- Cause: the game archive plus the installed payload does not fit in free internal storage.
- Solution: free space, then retry:

```bash
adb shell df -h /data
adb install -r pocket-foundry.apk
```

If instead you see `` INSTALL_FAILED_NO_MATCHING_ABIS ``, the device does not match the APK's supported CPU architecture — the release notes list the supported ABIs, so **check the documentation**.

**Problem. The app opens but the import of the game archive does nothing**

- Error: the import dialog closes with no game entry added, or reports a generic failure for the file.
- Cause: the file is not the Linux ARM64 `.tar.xz` build — usually a Windows `.zip` or another platform's archive downloaded from the same page.
- Solution: re-check the file and re-download the Linux ARM64 archive:

```bash
file factorio.tar.xz
```

Expected: `XZ compressed data`. Anything else must be replaced before importing again.

## Summary and next steps

You verified an Adreno-based Android 10+ device, installed the Pocket Foundry APK from Releases, imported the official Linux ARM64 `.tar.xz`, and confirmed a clean launch through logcat. Next, tune in-game graphics options on your own hardware and re-test after each Pocket Foundry release, since the project was verified on a single phone.

## FAQ

**Does Pocket Foundry work on Samsung Exynos or MediaTek Dimensity phones?**
No. Exynos and Dimensity devices use Mali or Xclipse GPUs, which are reported as not working; an Adreno GPU (Qualcomm Snapdragon) is required.

**Do I need to buy Factorio separately?**
Yes. The APK contains no game data — you purchase Factorio on factorio.com and import the Linux ARM64 `.tar.xz` build into the app.

**Is this an emulator?**
No. Pocket Foundry runs the official Linux ARM64 build of Factorio natively on the phone's CPU and uses Mesa for GPU rendering, with no emulation layer.

**Which Android version do I need?**
Android 10 or newer, plus an Adreno GPU. The project has been verified on one phone, so other configurations may still fail — check the repository README for the current support statement.