# How to Run the Gemini App on Low-Memory Android Devices: Requirements and Setup

> AI Release · @ai_releaseorg · https://ai-release.org/guides/kak-zapustit-gemini-na-android-s-malym-obemom-pamyati-t_en.html

## TL;DR

- **Time to complete:** about 25 minutes.
- **Difficulty:** Basic.
- **You will need:** an Android phone or tablet with Google Play, a Google account on the device, a USB cable, a computer with Android platform-tools (`adb`) installed, and free internal storage of at least twice the download size shown on the Gemini listing in Google Play.
- **Result:** Gemini installed and launching on a low-memory phone, plus exact commands that prove the app stays in memory and does not get killed.

## Requirements and setup
![Illustration: Requirements and setup](https://ai-release.org/guides/img/kak-zapustit-gemini-na-android-s-malym-obemom-pamyati-t-en-1.jpg?v=1795078258)


- **Android device with a Google-certified build.** The Gemini app is distributed through Google Play, so a certified build is what lets the installer work at all. If your build is not certified, the store page may open but the install button will fail — check the Play listing on the device itself before you start.
- **Android version and RAM.** Open the Gemini listing in Google Play on the phone and read the compatibility block at the bottom of the page. Whatever Android version it names is your minimum. If the listing does not name a RAM figure, check the documentation for the current requirement rather than guessing.
- **Computer with Android platform-tools.** `adb` (Android Debug Bridge) is a command-line tool that talks to your phone over USB and lets you read hardware data and install packages without the store.
- **USB cable that carries data**, not a charge-only cable.
- **Free space in `/data`.** The installer needs room for the APK *and* the extracted native libraries, so a few hundred megabytes of headroom is the practical floor. Read the real download size from the Play listing.
- **A Google account already signed in** to the device, because the app checks account state on first launch.

Pre-flight checklist — run through it before touching the phone:

- [ ] Developer options enabled (Settings → About phone → tap **Build number** seven times).
- [ ] USB debugging enabled (Settings → System → Developer options → **USB debugging**).
- [ ] `adb devices` shows your phone as `device`, not `unauthorized`.
- [ ] Play listing opened on the device and not marked "not compatible".
- [ ] At least 2× the listed download size free in `/data`.

**Example:** on a Pixel-style device the menu path is `Settings → System → Developer options → USB debugging`; on Samsung firmware it is `Settings → Developer options → USB debugging`. The toggle name is identical.

## Step 1. Read the device profile over ADB

**What to do:** connect the phone, authorise the debugging key, and dump the four values that decide whether Gemini can install and stay running: Android release, API level, total RAM, free space.

```bash
adb devices
```

**Example output:**

```
List of devices attached
R58M12ABCDE	device
```

If the word is `unauthorized`, unlock the phone and tap **Allow** on the "Allow USB debugging?" dialog, then run the command again. If the list is empty, the cable is charge-only or the driver is missing.

Now read the profile:

```bash
adb shell getprop ro.build.version.release
adb shell getprop ro.build.version.sdk
adb shell getprop ro.product.cpu.abi
adb shell cat /proc/meminfo
adb shell df -h /data
```

**Why:** the installer rejects packages that do not match the API level or the CPU ABI (`arm64-v8a` vs `armeabi-v7a`), and the launcher gets killed by the low-memory killer when free RAM is thin. Reading the values first turns a vague "it won't install" into a specific mismatch.

**How to check:** the first three commands each print one line — an Android version such as `14`, an integer API level, and an ABI string such as `arm64-v8a`. `/proc/meminfo` starts with a line of the form `MemTotal:        <value> kB`. `df -h /data` prints a row where the `Avail` column is the usable free space.

| What you check | Command | Healthy result |
|---|---|---|
| Android version | `adb shell getprop ro.build.version.release` | Version is at or above the one named in the Play listing |
| CPU ABI | `adb shell getprop ro.product.cpu.abi` | Matches the APK variant you plan to install |
| Free space | `adb shell df -h /data` | At least 2× the download size |
| Live memory | `adb shell dumpsys meminfo` | `Free RAM:` line shows real headroom, not `0K` |

## Step 2. Install Gemini in the way your firmware allows
![Illustration: Step 2. Install Gemini in the way your firmware allows](https://ai-release.org/guides/img/kak-zapustit-gemini-na-android-s-malym-obemom-pamyati-t-en-2.jpg?v=1795078267)


**What to do:** free memory first, then install from Play Store if the listing is compatible, or sideload the matching APK over ADB if it is not.

Close background apps and check what is actually free:

```bash
adb shell dumpsys meminfo
```

Look for the `Total RAM:`, `Free RAM:` and `Used RAM:` lines. On a small-RAM phone this is the number that decides whether the app survives its own first launch.

Install route A — Play Store. Open the Gemini listing and tap **Install**. Route B — ADB, when the store refuses:

```bash
adb install -r /path/to/<gemini-build>.apk
```

**Example output:**

```
Performing Streamed Install
Success
```

Then reduce the chance the system kills the app while you are using it:

- Settings → System → Developer options → **Background process limit** → **At most 2 processes**. The setting is applied immediately; leave Developer options open so you can revert it later.
- Or set it over ADB:

```bash
adb shell settings put global always_finish_activities 1
```

**Why:** the low-memory killer (`lmkd`) terminates background processes when free RAM drops. Restricting the background process count gives the foreground app a larger share of the same physical RAM, which is the only lever you have on a device you cannot upgrade.

**How to check:** `adb shell pm list packages | grep -i -E "bard|gemini"` prints one line ending with your package name. If nothing prints, the install did not land. Revert the developer setting with `adb shell settings put global always_finish_activities 0` when you are done testing.

The install flow looks like this end to end:

```
Phone ──USB──> Computer (adb)
                 ├─ getprop   → Android version, API level, ABI
                 ├─ df /data  → free space before download
                 ├─ install   → Play Store, or "adb install -r file.apk"
                 └─ settings  → background process limit / always_finish_activities
```

If the store blocks you entirely, the same sideload route used for internally distributed builds applies — see [How to Publish a Private App on Google Play and Install It on Android](https://ai-release.org/guides/poshagovoe-rukovodstvo-kak-opublikovat-chastnoe-prilozh.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide).

## Step 3. Prove the app launches and stays in memory
![Illustration: Step 3. Prove the app launches and stays in memory](https://ai-release.org/guides/img/kak-zapustit-gemini-na-android-s-malym-obemom-pamyati-t-en-3.jpg?v=1795078272)


**What to do:** launch Gemini from the shell, then watch memory and the crash log while it runs.

Find the exact package name first:

```bash
adb shell pm list packages | grep -i -E "bard|gemini"
```

Launch it without knowing the activity name:

```bash
adb shell monkey -p <package> -c android.intent.category.LAUNCHER 1
```

**Example output (last line):**

```
Events injected: 1
```

Now attach to the log and take a memory reading while the app is in the foreground:

```bash
adb logcat -c
adb logcat | grep -i -E "FATAL|ANR|OutOfMemory"
adb shell dumpsys meminfo <package> | head -n 20
```

**Why:** a text prompt that gets an answer proves the app is alive, and the `TOTAL PSS` figure from `dumpsys meminfo` proves how much physical memory it actually holds. If PSS approaches the `Free RAM` figure from Step 2, the next backgrounding will kill it.

**How to check:** the app window appears, you can send one prompt and get a reply, and `dumpsys meminfo` prints a `TOTAL PSS:` line for the package. Leave it in the foreground for a few minutes: no "Gemini keeps stopping" dialog and no `FATAL EXCEPTION` in logcat means the run is stable.

## Troubleshooting

**Problem. The store page opens but the button says the app is incompatible.**
- Error: `Your device isn't compatible with this version.`
- Cause: the device model, its Android version, or the firmware build is not on the supported list for that listing. This is a store-side filter, not a download failure.
- Solution: confirm your values with `adb shell getprop ro.build.version.release` and `adb shell getprop ro.product.cpu.abi`, compare them with the compatibility block on the listing, then install the APK variant that matches your ABI over ADB: `adb install -r <file>-arm64-v8a.apk`. If the Android version is below the listed minimum, no APK variant will help — check the documentation for the current minimum.

**Problem. ADB refuses the package during install.**
- Error: `Failure [INSTALL_FAILED_INSUFFICIENT_STORAGE]`
- Cause: `/data` filled up. The APK download is not the whole cost — the native libraries are extracted on install, so the real footprint is larger than the file you copied.
- Solution: read the free space with `adb shell df -h /data`, then remove what you do not use: `adb shell pm uninstall --user 0 <unused.package.name>`. Re-run `adb install -r <file>.apk` and look for `Success`. A related variant, `Failure [INSTALL_FAILED_OLDER_SDK]`, means the APK targets a newer API level than your phone reports — pick an older build or stop here.

**Problem. Gemini installs but closes the moment you open it.**
- Error: `FATAL EXCEPTION: main` followed by `java.lang.OutOfMemoryError`, or `ANR in <package>` in logcat.
- Cause: not enough free RAM at launch. On a low-memory phone the background apps plus the new process exceed what the device can hold, and `lmkd` kills it.
- Solution: reboot the phone, apply the background process limit from Step 2, then launch again with `adb shell monkey -p <package> -c android.intent.category.LAUNCHER 1` while `adb logcat | grep -i -E "FATAL|ANR"` runs in a second terminal. If the crash repeats, use Gemini through your mobile browser instead of the app on that device.

## Summary and next steps

Read the device profile over ADB before installing, because the API level, ABI and free space decide both whether the package installs and whether it survives launch. Once Gemini runs, extend the same setup to fully offline models with [How to Run an AI Model Locally on Android: Apps and Setup](https://ai-release.org/guides/kak-zapustit-ii-model-lokalno-na-android-prilozheniya-i.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide).

## FAQ

**How much RAM does the Gemini app need on Android?**
The listing on Google Play is the authoritative source for your device and region; if the page does not state a figure, check the documentation. Measure your own headroom with `adb shell dumpsys meminfo` and compare the `Free RAM:` line against the app's `TOTAL PSS:` after launch.

**Why does Google Play say my phone is not compatible with Gemini?**
Either the Android version is below the listed minimum, the CPU ABI has no matching build, or the model is not on the supported list. Confirm with `adb shell getprop ro.build.version.release` and `adb shell getprop ro.product.cpu.abi` before trying a sideload.

**Can I install Gemini on a phone without Google Play?**
Yes, if you have the APK variant that matches your device ABI. Enable USB debugging, connect the cable, and run `adb install -r <file>.apk`; a `Success` line means the package landed. Without Play services the app may still refuse to sign in, so verify after launch.

**Will Gemini keep working if I open other apps on a low-RAM phone?**
Only within the memory you freed. Set Developer options → Background process limit to **At most 2 processes** and keep an eye on `adb shell dumpsys meminfo`; when free RAM drops, the system kills the backgrounded app and you get a cold start next time. For a fully local alternative that does not depend on a network round trip, see the local-model guide linked above.
