Documentation

Getting started

What you need, what happens the first time you run it, and what to do when something goes wrong.

Device requirements

RequirementMinimumComfortable
Android version8.0 (API 26)11 or newer
CPU architecturearm64 (64-bit)arm64
RAM4 GB8 GB or more
Free storage~4 GB10 GB or more
NetworkRequired to buildWi-Fi for first setup
32-bit-only devices are not supported: the entire on-device toolchain is compiled for arm64. Storage fills up faster than people expect — Gradle caches, the Android platform, and your projects' dependencies all live on the device.

No root, no unlocked bootloader, and no desktop computer are required at any point.

First run

The first launch sets up the toolchain. This is a one-time download and unpack, it needs a decent connection, and it is worth doing on Wi-Fi while charging. The setup screen shows each component as it lands, so you can see what's happening rather than watching a featureless spinner.

You don't need to sign in to look around: opening projects, editing, the terminal and Git all work signed out. Signing in with Google is required before your first build.

What installs on demand

The APK deliberately doesn't contain everything — that would be a huge download most people would never fully use. Instead, components arrive when you first need them:

ComponentFetched when
Language servers (Kotlin, Java, C/C++, Python, Rust) You first open a file in that language
Command-line dev tools behind the terminal You first open the terminal
Native C/C++ compiler toolchain You first build a project with native code
Android platform & build-tools A project needs a version you don't have

You are told what is downloading and roughly how big it is before it starts.

Your first build

  1. Get a project. Create one from the built-in template, or clone an existing repository with the Git panel, or open a folder already on the device.
  2. Let it sync. Gradle resolves dependencies on first open, exactly as on a desktop. This is the slowest step and it needs the network.
  3. Press Run. The build runs on the device and streams its output to the Build workspace.
  4. Install it. On success you get a real APK, which you can install and launch from the app.

Expect the first build to be slow, and every build after it to be much faster. The first one downloads dependencies, warms Gradle's caches and trains the runtime's class-data archives. Judge the experience on your second build, not your first.

Every build needs a connection: the app checks in for a build permit before it starts. See the terms for what that means and why it works that way.

Permissions

PermissionWhy
InternetDependency resolution, build permits, sign-in, downloads.
NotificationsBuild progress while the app is in the background.
Install unknown appsOnly if you install an APK you just built. Optional.
Storage accessOnly for projects you keep outside the app's own directory. Optional.
Builds run in a foreground service with a wake lock so that Android doesn't suspend a long compile when the screen turns off. That's why a notification appears while building.

Signing a release

You have two options, and they're both real:

  • Your own keystore, on the device. Manage keystores in the app and sign locally. Nothing leaves your phone. Available on every tier.
  • Server-side signing (paid tiers). We generate a signing key for your account, hold it encrypted, and sign artifacts you upload. Convenient, and it means the key survives losing your phone — but read the terms section on signing first, because deleting your account destroys that key permanently.

Either way, you get a standard signed APK or AAB and you upload it to Google Play yourself. Pocket Studio never publishes on your behalf.

Troubleshooting

The build stopped, or the app closed mid-build

Almost always memory pressure — Android kills apps to reclaim RAM, including the one you're looking at, and a big Gradle build is exactly the trigger. The app tries to abort the build cleanly before that happens rather than dying mid-compile.

Close other apps first, lower the build memory settings on smaller devices, and prefer incremental builds while iterating.

The device is hot and the build slowed down

Sustained compilation heats a phone, and Android throttles the CPU to protect it — so a second long build back-to-back is genuinely slower than the first. Build while charging, take the case off if it's a thick one, and give it a minute between heavy builds. This is also why benchmark results flag throttled runs separately.

"Build requires a connection"

Expected behaviour, on all tiers — builds check in with the server first. Editing, the terminal and Git work offline. If you're online and still blocked, check the service status.

Running out of storage

Gradle's caches grow steadily and dependencies are not small. If you're tight on space, remove Android platform versions you no longer target, and clean build outputs for projects you're not actively working on.

Completion or go-to-definition isn't working

Confirm the language server for that language finished downloading, and give it time to index a freshly opened project. For Kotlin specifically, resolution across your dependencies gets much better after the project has been built once — that's when the real classpath becomes available.

Something not covered here? Support has the contact details and the most common issues in more depth.