Run Code in 16 Languages on Android — On-Device

Most ways to "run code" on a phone quietly send it somewhere else — a cloud runner, a remote sandbox, a website's server. That's fine until the signal drops or you'd rather your code didn't leave your device. PocketCode does the opposite: it executes real languages on the device itself, so running a script is as local as opening a note.

Here's the full picture of what runs, what's ready instantly, what needs a one-time download, and what is not available yet.

Thirteen languages and file types inside the app

These ship inside the APK, so they are there from first launch — nothing to download. You need a free account and a connection to sign in; after that, open a file, tap Run (the button is marked experimental), and your code executes on the device:

HTML, Markdown and JSON are previews and checks rather than runtimes, but they are what you reach for in the everyday trio of "write a script, build a page, check some data". They work the second you open the app.

Want the deep dive on one of them? We wrote a full guide to running Python on Android — how the WebAssembly build executes locally, what the standard library covers, and its honest limits (no pip, so it's a scripting and learning environment, not a data-science stack).

Three more, one download away

Beyond the included languages, PocketCode offers optional language packs. You download a pack once, from Settings → Compilers and runtimes → Additional language runtimes, and from then on that language runs on the device, just like the built-in ones. The packs you can install today:

• Lua 5.4 (about 0.6 MB). The editor has no Lua highlighting, so .lua files open as plain text.
• Go (about 38 MB), through the Yaegi interpreter. It is not a full go build: standard library only, one file at a time, no go get, no projects with go.mod.
• Rust-style scripts (about 1.4 MB), through Rhai. It is a scripting language with Rust-like syntax, not rustc: no advanced traits, lifetimes, async or crates.

Altogether that is 16 languages and file types, through 17 runners (Kotlin has a backup runner), from the same editor on the same phone, without a server in the loop.

What does not run yet

The plugin manager also lists Perl, C++ (Clang), C#, Zig, Dart and Swift, but none of the six can be installed in this version: the app doesn't include the checksum it needs to download them. Their files open in the editor, and Run stays greyed out. Java is not compiled either, and there is no real Rust (rustc) or full Go toolchain. We don't count any of these as running.

Why "on-device" is the whole point

Running locally isn't a technical footnote — it changes what a phone can be for:

• Your code runs on the device. Once you're signed in, the included languages and any pack you've downloaded execute locally. That matters most where mobile shines: commutes, flights, patchy coverage, emerging-market networks. (The app needs a connection to sign in; opening the app with a session already started works offline.)
• Your code stays yours. Nothing is shipped to a third-party runner to execute. The WebAssembly engines (Python, Ruby, PHP, Lua, Go, Rhai) have no network by default; Run with arguments has an Allow network in WASM engines switch. Node.js, C and the shell are not affected by it.
• There's nothing to assemble. No terminal environment to bootstrap, no toolchain to hand-compile. The runtime is already there; you just press Run.
• It's immediate. There is no remote container to wake up — execution begins on the device.

The editor around it

A runner is only half the story; you also want to write the code well. Every language opens in the same code editor: TextMate syntax highlighting for 39 languages, one-tap language servers for 19 of them (Java, Kotlin, Go, Rust, C, C++ and Ruby are not among them), a built-in formatter for 24, multi-cursor editing and a programming symbol bar. Output streams into the Run panel — print/console.log, stack traces, exit codes, and a stdin box for programs that read input. There is also a built-in terminal: its shell has node on the path, but Python, Ruby, PHP, C, Java and Kotlin run from the editor's Run button, not as shell commands.

What this is, and isn't

Being straight about scope keeps expectations honest:

• Great for scripting, learning a language, algorithm practice, automation, prototyping, and running real code away from a desk.
• Not a full native build farm. Heavy compute runs at interpreter speed, and runtimes that rely on huge native ecosystems (think Python's C-extension packages) stay within what each language ships on-device. Plugins are WebAssembly files only: Google Play doesn't allow downloading native compilers.

Within those lines, it's a pocket-sized multi-language runtime that executes locally.

---

One phone, 16 languages and file types, executing on the device in your hand.

PocketCode is available on Google Play. Get PocketCode and run your language of choice on your own device.