# Termish puts an SSH terminal, a remote screen and an agent chat on your phone

> Termish is a Kotlin Multiplatform terminal for Android and iOS that connects straight to your servers over SSH or Mosh and adds a remote screen and a native chat for coding agents. It suits a developer who wants to drive Codex or Claude Code from a phone, and it is an MIT licensed app whose iOS build you compile yourself.

**farlume/termish** — Open-source mobile SSH/Mosh terminal and native AI workspace for Android and iOS.

- Repository: https://github.com/farlume/termish
- Website: https://termish.dev
- Stars: 525 · Forks: 6
- Language: Kotlin
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/farlume-termish

## The phone is a terminal, and the coding agent lives on the server

The architecture is the first thing to understand, and it is deliberately not a cloud agent. Termish connects your phone directly to the development machine over SSH or Mosh, and the primary path is named in the documentation as Termish to Herdr to Codex. Herdr and the coding tool run on the remote machine, while the phone provides the terminal, input, file transfer and a remote-screen view, and a missing Herdr installation can be prepared from the app. The critical line is that no Termish relay or account sits in the connection. That is a design commitment rather than a missing feature, and the capability table states it plainly with the row on hosts and credentials: connect directly to your servers, store saved secrets with Android Keystore or iOS Keychain, and no Termish account, telemetry or hosted relay is required. The consequence is that the trust boundary is your own SSH server, and everything the app does happens inside that session.

## Herdr is the remote workspace the terminal opens into

Herdr is the layer between the SSH session and the agent, and it is what makes the workflow more than a terminal emulator. The documentation says to keep the familiar terminal workflow: enter Herdr, run Codex or Pi, switch workspaces and inspect live task output, and Termish starts Herdr through SSH or Mosh and can guide its remote installation. The quick start spells out the sequence. You open the Hosts list, add a host with the SSH address, username and password or private key, and verify the server's host key fingerprint on first connection. Each host menu then opens Terminal, Herdr, Files, remote screen or Agent chat. The mobile development loop is described as giving an agent a task, uploading a screenshot or file, inspecting diffs and remote files, then continuing in the same terminal. That last clause is the design intent, because the point of the screen and the file browser is to keep you inside one session rather than switching between a terminal app and a remote desktop.

## The remote screen is a companion service, not a screen share

Viewing the remote desktop is implemented as a versioned companion service that runs in the computer's graphical session, installed from the app and accessed over SSH, with its standalone source, configuration and diagnostics documented in the screen service guide. The macOS implementation uses a Python session relay with native ScreenCaptureKit and CoreGraphics capture and VideoToolbox encoding, and the details there are the kind that decide whether the feature is usable. Authenticated sessions wake the display and hold temporary power assertions, and disconnecting releases them, so the remote machine does not stay awake forever after you close the app. macOS recording consent is required, and a stable signing certificate preserves the Helper's identity across updates, which matters because a helper whose identity changes will be treated as a different application by the system. On Linux the documentation says precompiled Rust services are used. The workflow from the app is described as viewing the remote desktop in a floating window or full screen, using touch or a virtual mouse to check and operate desktop apps alongside the terminal or Herdr.

## Agent chat is a separate path that uploads a Rust Bridge over SFTP

The native chat is not the same thing as the Herdr workspace, and the documentation is explicit that it is an alternative interface rather than a replacement. It uploads the bundled Rust Bridge over SFTP and starts it for your remote user, and the Bridge runs the selected agent and relays messages through the authenticated SSH connection. The practical advantages are stated: no Docker and no extra public listening port are needed, conversations stay on the host, and an active agent task can continue while your phone is disconnected. The agents it can drive are named in the capability table, covering Codex, Claude Code, Gemini CLI, OpenCode and Pi in a phone-native conversation, where you can follow streaming replies and tool calls, attach files, stop a task and resume conversations. The requirement on the remote side is that the host needs the agent's own login or a supported API provider configuration, missing supported CLIs can be installed from the app, and you do not need a Termish account.

## Mosh needs a server binary and a UDP port, and tmux covers the disconnect

The two connection modes behave differently and the difference is operational rather than cosmetic. For Mosh, you choose Mosh in the host's connection settings, the remote needs `mosh-server` and a reachable UDP port, and Termish offers guided installation when the server is missing. The capability table describes what Mosh buys you, namely network roaming and local echo prediction for typing over slower connections, alongside the ability to open multiple terminal tabs and run tmux, vim, htop or any TUI. The gap in Mosh is that a session does not survive the client disappearing, and the documentation gives the answer in one sentence: use a startup command such as `tmux new -A -s main` when you want terminal programs to survive client disconnects. That combination, Mosh for the roaming connection and tmux for the session lifetime, is the pattern the documentation is steering you towards, and it is also the pattern that makes a long agent run survive a tunnel.

## The download is a signed APK, and iOS is a source build

There are two platforms and they are not distributed the same way. The download table in the documentation is short:

| Platform | Get Termish |
| --- | --- |
| Android 8.0+ | [Download the signed APK](https://download.termish.dev/downloads/termish.apk). Allow installation from this source when prompted. |
| iOS | Build with macOS and Xcode using the [iOS guide](CONTRIBUTING.md#ios). No public App Store download is available yet. |

So on Android you are installing a signed APK and allowing installation from that source, and the release page carries the release notes and all assets, with SHA-256 checksums published separately. On iOS you need macOS, Xcode and the build guide. The signing story matters more than it looks, because the release notes in the documentation explain that once you have published any package, replacing the private key means existing users cannot install over the top, so the key is the thing that must not change. The repository has an `iosApp/` directory and a `composeApp/` directory, which is the Kotlin Multiplatform layout, and the iOS build has a one-time native dependency step that cross-compiles OpenSSL and libssh2 into `iosApp/native/`.

## The build is Gradle with a Makefile that only holds shortcuts

The Makefile in the repository is described in its own comment as a thin shell, with all the process knowledge living in the Gradle tasks in the root build.gradle.kts, and the note that running a Gradle task directly is equivalent and that CI reuses the same set of tasks. The targets are worth reading because they name the whole workflow. Building a debug APK is `$(GRADLEW) :composeApp:assembleDebug`, building, installing and launching is `$(GRADLEW) runDebug`, and reinstalling is `$(GRADLEW) reinstallDebug`, which the comment describes as the cure for a signing conflict. The test target runs the agent bridge tests, the screen service tests and the compose app unit tests, and the comment on it notes that the sshd and mosh parts are skipped automatically when they are not present. There is a separate integration target that starts sshd automatically, a lint target for Android lint, a ktlint check target that reads its rules from the `.editorconfig` file, and a release target that verifies the signing secrets before assembling the release APK and bundle.

## Where a mobile terminal with a remote screen is the wrong shape

Two limits are worth stating plainly. The first is that this is a view onto a remote machine, not a machine in your pocket. The agent runs on your server, the bridge runs on your server, the screen service runs in your server's graphical session, and the phone is the terminal, the input device and the file pipe. That design is a strength when your server already exists and holds your repository, which is the normal case for a self-hosted development box, and a liability when you want the agent to run somewhere you do not control, because the credentials and the task both stay on the host. The second is the platform asymmetry. Android gets a signed APK you can install today, and iOS gets a source build that needs macOS, Xcode and a native cross-compilation step, which means the two platforms are not at the same level of maturity in practice even though the repository is one Kotlin Multiplatform project. The alternative to weigh against is a plain terminal emulator with an SSH client, which does the same job with a fraction of the machinery and no remote screen, no agent bridge and no screen service to install on the server. The difference in approach is that Termish assumes the server can be modified and provisioned, and pays for that assumption with the setup steps on both ends.

## Conclusion

Termish is worth installing if you want to keep working on a server from a phone without a laptop open, because it connects directly over SSH or Mosh with no account and no hosted relay, and because the remote screen and the file transfer let you check a running task rather than guessing at its state. It is a poor fit for an iOS user who wants an App Store build, because the documentation says iOS is built with macOS and Xcode and that no public App Store download is available yet, and a poor fit for a workflow that needs the agent to keep running on your own hardware, since the agent and its bridge run on the remote host while the phone is the view. Before adopting it, read the Mosh requirements, because the remote needs `mosh-server` and a reachable UDP port, and check the release assets and SHA-256 checksums, since the Android build is a signed APK rather than a store listing. The last push to the repository was on 2026-10-19, with release v1.8.14 published the same day.

## FAQ

### How does Termish connect to my server?

Directly over SSH or Mosh, with no Termish account, no telemetry and no hosted relay. You add the SSH address, username and password or private key in the Hosts list, and you verify the server's host key fingerprint on the first connection. Saved secrets are stored with Android Keystore or iOS Keychain.

### What is the Herdr workspace in Termish?

It is the remote workspace the terminal opens into, where you run Codex or Pi and inspect live task output. Herdr runs on the remote machine and Termish starts it through SSH or Mosh, offering guided installation when it is not present yet, so the phone stays a terminal while the workspace lives on the server.

### How does native Agent chat differ from the Herdr terminal workflow?

Agent chat uploads the bundled Rust Bridge over SFTP and starts it for your remote user, and the Bridge runs the selected agent and relays messages through the authenticated SSH connection, so no Docker and no extra public listening port are needed. It is described as an alternative interface rather than a replacement for the Herdr terminal workspace.

### What does Mosh require on the remote server?

The remote needs mosh-server and a reachable UDP port, and Termish offers guided installation when the server is missing. Mosh supports network roaming and local echo prediction for typing over slower connections, and the readme recommends a startup command such as tmux new -A -s main so terminal programs survive client disconnects.

## Sources

- [farlume/termish on GitHub](https://github.com/farlume/termish)
- [License: MIT](https://github.com/farlume/termish/blob/main/LICENSE)
- [Project website](https://termish.dev)
- [README](https://github.com/farlume/termish/blob/main/README.md)
- [Releases](https://github.com/farlume/termish/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/farlume-termish