Remote desktop / VNC
- Screen-share latency and compression
- Desktop UI squeezed onto a 6-inch display
- Cursor emulation for mouse-first controls
- A reconnect can interrupt the whole interaction
TouchWorkstationOpen test hub
Open navigation
Self-hosted · single-tenant · free alpha
Your Linux workstation. In your pocket.
Not remote desktop: the phone renders a touch-first interface while your own Linux box runs the terminals, repos, dev servers, and agents.
- runs on
- your box
- remote access
- Tailscale
- public ports
- zero
- cloud relay
- none
phone UI · linux processes
Mission
The touchscreen was never the problem. The interface was.
Real development work is still chained to a desk. Most mobile options are either read-only dashboards or remote desktops that put a 1440p interface behind a six-inch window and ask you to drag a fake cursor through it.
The bet behind TouchWorkstation is simple: build the interface for touch from the start and leave the heavy work on the machine. A phone becomes a legitimate control surface—you can pull a repo, run it, preview it live, hand it to an agent, verify the result, and ship it.
It installs on your machine, runs as a systemd service, and stays on your network. Your machine, your network, your data. No TouchWorkstation account, no telemetry, and no cloud dependency.
Category check
Not a remote desktop
The difference is not lower latency. It is a different interface and a different failure model.
TouchWorkstation
- Native touch UI rendered on the phone
- Real controls and components, not streamed pixels
- tmux sessions survive disconnects
- Works over Tailscale on cellular
Feature deep-dive
The full development loop, designed for a phone
Each screen maps to something real on the workstation. There is no simulated shell and no hosted copy of the repository.
Terminal
A terminal that actually works on a phone
Every session runs inside tmux. Put the app in the background, switch networks, or lose signal in a tunnel—the process keeps running on your machine.
The interface gives you real scrollback, usable selection and copy/paste, plus a control-key row for the keys mobile keyboards decided you did not need.
- Persistent tmux sessions
- Ctrl, Esc, Tab, arrows, and common chords
- Reconnect without losing scrollback
tmux: api-gatewayattached
$ bun run devready in 412 mslocal: http://localhost:5173 [detached · process still running]$ tmux attach -t api-gateway Projects
Clone it, run it, see it live
Pick a repository, install its dependencies, and start the dev server on the Linux box. TouchWorkstation probes readiness before opening the preview, so the first thing you see is the app—not a browser error while Vite is still waking up.
Projects become first-class items on the home screen. Start, stop, inspect, and reopen them without reconstructing the command from shell history.
- Repository-to-running-app workflow
- Readiness probing for dev servers
- Start and stop from the home tile grid
GitHub
GitHub, wired into the machine
Connect through GitHub's device-flow OAuth using the gh CLI already running on your box. Credentials stay where your development credentials already live.
Browse repositories, clone one, inspect status, and run common Git actions without typing commands one-handed. The full terminal is still there when you need it.
- gh CLI device-flow authentication
- Browse and clone repositories
- Status, commit, pull, and push controls
Agents
Coding agents, scoped to the project
Launch Claude Code or Codex directly into a managed terminal session for the repository you are working in. Agent output is surfaced in the phone UI while the real process keeps running on the workstation.
The runtime is deliberately pluggable. TouchWorkstation coordinates the session and workflow; it does not force every project through one vendor or one model.
- Claude Code and Codex sessions
- Project-scoped working directory
- Pluggable agent runtime
Verification
Tests are a gate, not an afterthought
A green agent response is not the same as a working change. Test runs are a visible stage between editing and commit, with their result attached to the project workflow.
You decide what ships. The interface keeps the test state in front of you before commit and push instead of burying it in a terminal tab you forgot was open.
- Visible pass and fail state
- Run tests before commit
- Keep verification beside the diff and preview
project / verify
lintPASS
unit · 48PASS
integration · 12PASS
buildPASS
ready to commit
Machine
Files, services, containers, and system health
The phone interface exposes the small set of machine controls you actually reach for: a file browser, Docker containers, systemd services, running processes, and resource use.
This is not a launcher that dumps every installed desktop application into a smaller grid. It is a focused control surface for development work.
- File browser and editor
- Docker logs and container controls
- systemd service status
- CPU, memory, disk, and process views
Files
1,284
Containers
4 running
Services
healthy
Processes
126
Phone interface
Built like an app, not a responsive website
TouchWorkstation is an installable React PWA designed around a phone screen from the first route. Navigation, gestures, and controls are built for thumbs instead of being desktop UI that happens to fit.
The home screen is yours: drag tiles into the order you use them, keep the frequent tools close, and leave the rest off the first screen.
- Installable PWA
- Edge swipe-back and hardware back support
- Haptic feedback
- Drag-to-reorder home tiles
Security
Your machine stays on your network
The local service uses a JWT session cookie and forces a password change on first login. Remote access is through Tailscale, not a public port or a relay operated by TouchWorkstation.
If the service crashes, recovery is explicit: the next login shows a plain-language notice rather than silently dropping state and pretending nothing happened.
- Local authentication
- Forced first-login password change
- Tailscale-only remote access
- Visible crash-recovery notice
tailscale0CONNECTED
- public ports
- 0
- session
- httpOnly JWT
- service
- active (running)
- recovery
- clean
TouchWorkstation / Omarchy live
Same machine, same theme, fewer reasons to unfold a laptop.
- system
- OMARCHY
- status
- LIVE
- theme
- SYNCED
- package
- PACMAN
01 / mobile controlactive
02 / agent looprunning
03 / control centeronline
$ it compiled on one machine. naturally, this is now a supported platform.
How it works
One service on the box. One app on the phone.
- 01
Install
Run one command on the Linux machine. The package installs the local service and its systemd unit.
- 02
Add the PWA
Open the local URL on your phone and add TouchWorkstation to the home screen.
- 03
Connect Tailscale
Put both devices on your tailnet for access away from home without opening a public port.
- 04
Work
Open terminals, pull repos, start projects, preview apps, and hand scoped tasks to agents.
Under the hood
Plain parts, running locally
The pieces are intentionally boring enough to inspect, restart, and remove.
clientReact PWA · installed on the phone
agentNode / Express · runs on the workstation
proxynginx · port 8088
processsystemd · starts on boot · restarts on failure
networkLAN or Tailscale · no public listener
Install by distro
The same installer picks the right package
Run the one-liner on the Linux workstation. It detects the package manager and architecture, then pulls the matching alpha artifact.
install / latest alphashell
curl -fsSL https://touchworkstation.com/api/public/install | shThe installer endpoint chooses an uploaded build first and falls back to the matching GitHub release artifact when needed. No access code is required.
Debian
.deb
apt / dpkg
Ubuntu
.deb
apt / dpkg
Fedora · RHEL
.rpm
dnf / yum
openSUSE
.rpm
zypper
Arch
PKGBUILD
makepkg
Omarchy
PKGBUILD
pacman
Alpha status
Early enough that your bug report can change the product
Expect rough edges, incomplete paths, and builds that need a second pass. Expect to file bugs. If the workflow clicks, expect the phone to become useful for work you previously postponed until you got back to a laptop.
This is for
Developers who own a Linux machine, are comfortable in a terminal, and want to test a phone-first control surface.
This is not for
Anyone looking for a hosted workspace, a managed cloud IDE, or a service they do not have to install and operate.
FAQ
Before you put it on a machine
Is this remote desktop?
No. TouchWorkstation does not stream desktop pixels or emulate a mouse. The phone renders a touch-first interface while commands and processes run on your Linux machine.
Do you see my code or my data?
No. TouchWorkstation is single-tenant and runs on your hardware. Your repositories, terminal sessions, credentials, and project files remain on that machine.
Do I need to expose my machine to the internet?
No. The service listens on your network and remote access uses Tailscale. You do not open a public HTTPS endpoint or forward router ports.
What Linux distros are supported?
The alpha targets Debian and Ubuntu with .deb packages, Fedora, RHEL, and openSUSE with .rpm packages, and Arch through a PKGBUILD. Omarchy support is live.
Does it work on iOS and Android?
Yes. The client is an installable PWA and is designed for current mobile browsers on both iOS and Android.
What happens to my sessions when I lose signal?
Terminal and agent sessions keep running inside tmux on your workstation. Reopen the app when connectivity returns and attach to the same session and scrollback.
Is it open source?
Yes. The source and build history live on GitHub under TouchWorkStation/TouchWorkstation.
What does it cost?
Nothing during the alpha. TouchWorkstation is currently a free alpha for developers willing to run it, test it, and report the rough edges.
Test hub
Put your Linux box in your pocket
The test hub is open. Browse the build history, grab the installer, report issues, and see what's known before you put it on a machine.
No account with us. No telemetry. No hosted workspace.