Pocket Studio gives it the toolchain. Real Gradle, the Kotlin and Java compilers and a C++ NDK, running as native processes on the device in your pocket. Builds run on your hardware — no cloud compute, and your code never leaves.
Android SDK 33–37 · Gradle 7.2–9.6 · OpenJDK 17 & 21 264-module projects Product flavors and build variants — debug or release, APK or AAB clang · cmake · ninja · Python — on the phone No toolchain to assemble, no per-project workarounds
Not a code viewer with syntax colours. The real toolchain, running natively.
Gradle, the Android Gradle Plugin, the Kotlin compiler and an OpenJDK (independent build) runtime, all running as native processes on your device. Build variants and flavors, keystore management, signing, and C/C++ projects with CMake and ndk-build.
A Linux-style shell with git, python, bash, node, vim and tmux, plus a built-in Git panel for status, diff, commit and push. Project-wide search across your tree. The dev-tools userland installs on first use.
Stays smooth in large files, where mobile editors usually give up. Syntax highlighting for 20+ languages. Completion, go-to-definition, quick fixes and reformat come from real language servers for Kotlin, Java, C/C++ and Rust, plus diagnostics, quick fixes and formatting for Python — all installed on first use.
A real JDWP debugger: breakpoints, call stack, frames, locals and stepping against a running app process — including an app running on a second phone over the network. Part of the Ultra plan.
A phone is a small thermal envelope, so the build engine respects it: thermal guards and Battery saver / Balanced / Performance presets, and long builds are protected from Android's low-memory killer instead of being silently killed at minute nine.
Generate and fix code without leaving the editor. Bring your own API key — free on every plan, talking to the provider directly, with no request passing through us. Pro adds the agent that edits, builds and fixes build errors on its own.
Clone, branch, stage, diff, commit and push from a panel built into the IDE. Sign in once and private repositories work the same on the phone as they do on a laptop.
Tablets, foldables and desktop-mode docks get a real multi-pane layout, with physical keyboard shortcuts and mouse support. The same project, the same toolchain, a bigger screen — not a stretched phone UI.
Shortcuts you already know work where you'd expect them: Ctrl S to save, Ctrl F to find, Ctrl B to build.
Three steps, and the third one produces a file you can install.
Start from a template or open an existing Gradle project — clone it with the built-in Git support, or point Pocket Studio at a folder you already have on the device.
Completion and go-to-definition work across your whole project and its dependencies, not just the file on screen.
Gradle runs on the phone and produces an installable APK. Install and launch it without ever connecting to a computer.
These are real open-source Android apps, built on a phone to a signed APK during development testing — not sample projects.
$ gradle :app:assembleDebug > Task :app:preBuild UP-TO-DATE> Task :app:compileDebugKotlin> Task :app:mergeDebugResources> Task :app:packageDebug> Task :app:assembleDebug BUILD SUCCESSFUL in 2m 41s47 actionable tasks: 39 executed, 8 up-to-date app-debug.apk 8.2 MB ✓ installed on this deviceIllustration of on-device Gradle output. Results were produced on the development device; your device will differ — see how phones compare.
There are two ways to write code on a phone today. One doesn't really build, and the other builds somewhere else. This is a third.
| Mobile code editors | Cloud & remote IDEs | Pocket Studio | |
|---|---|---|---|
| Where the build runs | Usually nowhere — no Android build | A server you rent | The device in your hand |
| Where your source lives | On the device | Uploaded to the remote machine | On the device |
| Gradle and the Android Gradle Plugin | Rarely | Yes | Yes, running natively |
| C and C++ with the NDK | No | Yes | Yes |
| Code intelligence | Often highlighting only | Real language servers | Real language servers |
| JVM debugger | No | Yes, against the remote process | Yes, on-device — Ultra plan |
| On a train, in a tunnel | Editing works | Nothing works without the link | Edit, terminal and Git work; starting a build needs a brief check-in |
| What you're paying for | The editor | Metered compute, by the hour | A flat plan — your own hardware does the work |
Every plan includes the full IDE — the editor, the terminal, Git and bring-your-own-key AI. Plans differ in how many builds you get, what you can sign, and whether you get the debugger.
Try it on a real project
For regular on-the-go development
Phone as the primary machine
Pricing is set per country through Google Play and will be shown on the store listing. Subscriptions are billed by Google Play; you can cancel any time from your Play account.
An arm64 (64-bit) Android phone or tablet running Android 8.0 or newer. Practically speaking, building large projects is memory-hungry work: 8 GB of RAM or more gives a comfortable experience, and you'll want several gigabytes of free storage for the toolchain, your projects and Gradle's caches.
32-bit-only devices are not supported.
Editing, browsing your code, the terminal and Git all work offline. Starting a build requires a network connection — each build checks in with our server first. That is a deliberate anti-piracy decision, and we would rather state it plainly than have you discover it on a train.
Gradle itself will also need the network the first time it resolves a project's dependencies, exactly as it does on a desktop.
No, and that's on purpose — a single enormous APK would be a bad trade. The app installs what you actually use, when you first use it: the language servers for Kotlin, Java, C/C++, Python and Rust (Python is diagnostics and formatting; the others add completion and go-to-definition), the command-line dev tools that back the terminal, and the native compiler toolchain for C/C++ projects.
You'll be told what is being fetched and roughly how large it is before it downloads.
Yes. Pocket Studio produces standard, signed APK and AAB artifacts. Release signing on paid tiers is done server-side with a signing key generated for your account and stored encrypted; you download the signed artifact and upload it to Google Play yourself. We never publish on your behalf.
It isn't. AI is bring-your-own-key on every plan, including Free, and your requests go straight to the provider — they never pass through our servers, so we never meter them and never mark them up. You pay your provider directly, at their price.
What the paid plans add is the agent: on Pro and above it edits, builds and fixes build errors on its own, rather than only answering in chat. That is a product capability, not an AI allowance.
Compiling a large project is genuinely heavy work, and a phone is a small thermal envelope — a long build will warm the device and use battery, just as it spins up the fans on a laptop. Short and incremental builds are far lighter. Building while charging, and giving the device a moment between long builds, makes for the best experience.
No. Pocket Studio runs entirely as a normal Android app, within the sandbox, on a stock device. No root, no unlocked bootloader, no ADB tinkering required to use it.
Pocket Studio Academy is a free course that takes you from "what is an app?" to three finished Android apps — written, compiled and installed entirely on your phone. No PC, no prior experience.
The first part builds and installs a real app on your phone before any theory. After that, Kotlin properly — types, null safety, collections, coroutines — then how Android actually works, and Jetpack Compose.
A dice game, a notes app backed by a database, and a focus timer with settings and a hand-drawn stats chart. Every chapter ships a downloadable project you can open and build to check your work.
Pocket Studio is finishing its launch preparation on Google Play.