How to Run Factorio on Android Without an Emulator: Pocket Foundry Setup Guide
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.xzfile from factorio.com, and free internal storage.
Requirements and setup
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.xzarchive 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.
- [ ]
adband 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 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:
adb devices
adb shell getprop ro.build.version.release
adb shell getprop ro.hardware.egl
adb shell getprop ro.board.platformExample output on a supported device:
List of devices attached
R58M1234ABC device
14
adreno
kalamaRead 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
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:
sha256sum factorio.tar.xz
file factorio.tar.xzExample output:
XZ compressed dataIf 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:
adb install pocket-foundry.apk
adb shell pm list packages | grep -i foundryExpected: 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
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:
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.
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:
adb shell getprop ro.hardware.eglA 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:
adb shell df -h /data
adb install -r pocket-foundry.apkIf 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.xzbuild — usually a Windows.zipor another platform's archive downloaded from the same page. - Solution: re-check the file and re-download the Linux ARM64 archive:
file factorio.tar.xzExpected: 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.
🤖 AI summary
- Updated: 2026-10-29
- Topics: Factorio на Android, Pocket Foundry, как запустить Factorio на телефоне, Factorio ARM64 Android
- Summary: Пошаговая инструкция по установке официальной Linux ARM64-сборки Factorio на Android через Pocket Foundry: подготовка телефона, запуск без эмулятора, управление и типичные ошибки.
- Key facts:
- 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 Pocket Foundry is a wrapper that runs the official Linux ARM64 build of Factorio directly on the phone& x27;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 .