I Built a 2D Godot Game From My Phone

I didn't plan to.

It started as a constraint — small pockets of time, no laptop nearby, ideas piling up.

So I tried something different:

What if the phone isn't the limitation — but the interface?

Within a few sessions, I was building and testing a 2D Godot game directly from my phone. Not through remote desktop. Not by painfully typing code on a touchscreen.

By steering a system that never stops running.

The Setup (Simple, but Different)

The phone does almost nothing.

It's just a terminal. A prompt interface.

Everything else lives on a remote machine:

Tailscale — secure connection (feels like local network)
Termius — SSH client on the phone
tmux — persistent session (always alive)
oh-my-opencode — agent runtime inside that session

That last piece is the shift.

I'm not opening a project. I'm connecting to one that's already running — and thinking.

The actual workflow, start to finish:

1. Enable Tailscale on phone
2. Open Termius
3. Run alias to attach tmux session
4. Paste prompt
5. Run alias to rebuild + export game
6. Refresh browser on phone

One detail worth noting: Godot's web export requires HTTPS. Tailscale Serve handles this — it exposes the local dev server over HTTPS on your Tailscale network, no certificate management, no port forwarding. The phone opens the Tailscale URL and the game just works.

The Loop That Replaces "Coding"

Once connected, everything reduces to a single loop:

prompt → agent updates → git push → Vercel deploy → preview URL

No extra setup. UI tweaks, content updates, structural changes — all done through the same terminal session.

Within seconds: Vercel builds, a preview URL is live, I open it on my phone.

The system that builds the game also builds the site that hosts it.

The Tools (Clear Roles)

Each piece is small. Together, they collapse the workflow.

Tailscale

Private mesh network. No port forwarding. Makes remote feel local.

Termius

Clean mobile SSH client. Fast reconnects. Snippets for common prompts.

tmux

Persistent environment. Survives disconnects. Holds the entire working state.

oh-my-opencode

The agent layer. Interprets prompts. Edits code, runs builds, pushes changes.

What Actually Changed

Before

Sit down
Open IDE
Reload context
Start working

Now

Connect
Prompt
Observe result

The difference isn't comfort — it's activation energy. When starting takes seconds instead of minutes, you iterate more, experiment more, ship more.

Friction (Still Real)

It's not magic. Prompts can be misinterpreted. Bad changes can get committed. Debugging without a GUI is slower.

But the loop is tight enough that recovery is fast: small prompts, quick validation, constant iteration.

The Real Unlock

This isn't about coding on a phone.

It's about removing the gap between idea and execution, between change and validation, between thought and shipped result.

The system is always running. You just drop in, nudge it forward, and leave.

And over time, those small nudges add up to something real.