# Remux: an iPhone terminal that treats a tmux session as a set of panes you can see

> Remux is a native SwiftUI client for remote tmux workspaces, built on the Ghostty terminal core with direct SSH and no relay and no account. The interesting engineering is not the terminal emulator, it is the mobile layer on top: live pane previews, a preview of the dev server running on the remote host, and long-press file previews.

**h3nock/remux** — A native iOS client for remote tmux workspaces, designed to feel natural on iPhone.

- Repository: https://github.com/h3nock/remux
- Website: https://getremux.app
- Stars: 521 · Forks: 50
- Language: Swift
- License: MIT
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/h3nock-remux

## A terminal client whose unit of work is the tmux pane

Remux describes itself as a native iOS client for remote tmux workspaces, built on Ghostty. The one line summary in the README adds that it brings tmux's session, window and pane model into a mobile-first interface, and that it previews files and running dev servers straight from the terminal, and uploads photos and files with markup for images.

That framing tells you the audience immediately. This is not a general purpose SSH terminal for an iPhone, and it is not a remote desktop. It is a client for a specific server-side workflow, one where a long-lived tmux session holds several windows and panes, and where the value of the tool is being able to navigate that structure on a small screen.

The feature list is written around that workflow. You attach to running sessions or start new ones. You swipe between windows, pick panes from a bottom sheet with live previews, and split, zoom or close them. A shortcut palette runs saved commands with a tap, and the starter sets cover shell, Claude Code and Codex, with your own commands and groups on top.

Two implementation facts explain the rest of the behaviour. The acknowledgements say Remux is built on Ghostty's terminal core and uses Citadel for SSH, so the terminal rendering and the SSH transport come from established components rather than being written here. And the README is explicit that Remux connects straight to the server, with no relay and no account, with passwords and private keys stored in the iOS Keychain and trusted host keys remembered.

The topics confirm the shape of the thing: ios, libghostty, mobile-terminal, ssh, swiftui, terminal, tmux.

## Windows and panes as a visual index

The pane model is where Remux departs from a scrolling terminal, and it is the feature to understand before anything else.

On a desktop, tmux panes are rectangles on a screen. On a phone, a rectangle the size of a text pane is unreadable, so the design has to change what a pane is. Remux's answer is to let you swipe between windows, pick panes from a bottom sheet with live previews, and split, zoom or close them. The bottom sheet is the key idea: instead of shrinking every pane into a mosaic, the client shows you one pane at a time and offers the others in a list, each rendered as a live miniature.

Splitting, zooming and closing are the same tmux operations a desktop user performs with a keyboard shortcut. On iOS they are gestures and buttons. The consequence for the server side is that the tmux session is doing the real work: sessions survive disconnects, the layout persists, and the client is a view onto a structure that lives on the host.

Cursor control is the other mobile-specific piece. The README describes holding the space bar or long-pressing in the terminal and then dragging to place the cursor. That is a workaround for a hardware limitation rather than a tmux feature, and it is worth noting that the feature list describes it in terms of gestures on a touch screen, so it depends on the terminal core's handling of pointer events rather than on any server-side support.

For a user, the payoff is that a phone becomes a usable way to inspect a running session: you look at the pane that matters rather than scrolling a transcript hoping to find the right output.

## Long-press opens the dev server that the remote machine is running

Two preview features are specific enough to be the reason someone installs this client.

The first is localhost preview. The README says that long-pressing a localhost URL opens the dev server running on the remote machine, hot reload and WebSockets included. That phrase is dense with meaning for anyone who develops on a remote box. A dev server bound to localhost on the server is unreachable from a phone unless something bridges the two, and here the client does it inside the terminal client itself, so the browser on the phone renders the remote server's output, and hot reload and WebSockets continue to work rather than being broken by the transport.

The second is file preview. Long-pressing a path in the terminal output previews it, and the formats listed are code, images, PDFs and HTML pages. So when a build finishes and prints a path, or a server logs a URL, the client can show the file rather than making you retype it somewhere else.

Both features share a design idea: the terminal output is treated as a surface with structure, not as plain text to be read. The client parses what it sees and offers the appropriate viewer.

The attachments feature completes the loop in the other direction. Remux uploads photos and files to the server, with markup for images, and the remote path is typed at the prompt, so the client fills in where the file landed. Voice dictation fills the other gap, letting you dictate text in the composer using on-device speech recognition, which avoids sending what you dictate to a speech service.

Taken together, these are the parts that make the phone experience workable rather than merely possible.

## Direct SSH with no relay and no account

The connection model is simple and worth stating precisely, because hosted terminal products usually work the other way round.

The README says Remux connects straight to the server, with no relay and no account. There is no intermediate service holding your sessions and no sign-up step. Your phone opens an SSH connection to the machine you already administer.

Credentials are handled locally. Passwords and private keys are stored in the iOS Keychain, and trusted host keys are remembered. The Keychain choice is the right one for a client that holds long-lived private keys, since it is the platform facility designed for exactly that and ties access to the device.

The host key part deserves a second look rather than a nod. Remembering trusted host keys means the client will trust the same host later without asking, which is convenient and is what every SSH client does, but it also means the trust decision is made once, on a phone, and then persists. If you deploy to a fleet of machines and reimage them, the remembered key will not match the new host and you will have to clear the remembered entry.

What is not in the README matters too. There is no description of port forwarding options, of agent forwarding, of how jump hosts are handled, or of what happens with hardware key authentication beyond storing a private key. The PRIVACY.md file at the repository root is where those questions are most likely to be answered, and it is the file to read before pointing the app at a production host.

The absence of an account also removes a whole category of feature. No cross-device sync of sessions, no shared workspace, no web console to fall back on, no server-side audit trail.

## Building from source means fetching GhosttyKit first

Remux is distributed as a public beta on TestFlight, and the README also documents a source build, which is the path anyone contributing or auditing the code will take.

The requirements are listed as Xcode with iOS 18 SDK support, and XcodeGen. The project file is generated rather than committed in a usable form, which is why the build steps start with fetching the prebuilt GhosttyKit framework:

```bash
scripts/fetch_ghosttykit.sh
```

Then the project is generated and built:

```bash
xcodegen generate

xcodebuild build \
  -project Remux.xcodeproj \
  -scheme Remux \
  -destination 'generic/platform=iOS Simulator'
```

The tests run through the same scheme on a named simulator:

```bash
xcodebuild test \
  -project Remux.xcodeproj \
  -scheme Remux \
  -destination 'platform=iOS Simulator,name=iPhone 17,OS=latest'
```

Two things stand out for a reviewer. The build depends on a network fetch of a prebuilt binary framework, which means a reproducible build requires trusting or reproducing that artefact. The README offers the alternative for anyone who wants that: build GhosttyKit yourself, using the remux-ghostty repository and scripts/build_release_ghosttykit.sh.

The repository layout follows a standard Xcode shape: Remux.xcodeproj/ for the generated project, RemuxApp/ for the application target, RemuxAppTests/ and RemuxAppUITests/ for the two test bundles, project.yml as the XcodeGen specification, scripts/ for the helper shell scripts, docs/ for documentation, and remux-site/ for the website content behind getremux.app.

## A TestFlight beta with no tagged release

Distribution is the practical constraint on this project, and the README is upfront about it. Remux is available as a public beta on TestFlight, and you can also build from source.

That has a specific meaning for users and for contributors. A TestFlight public beta is an installation channel that requires an Apple ID and a beta approval, and it is the kind of channel that can change or close without notice. There is no line in the README about an App Store release, so on the evidence available here, the app is distributed outside the App Store.

For contributors, the source build is the real entry point, and the environment requirements are narrow enough to be satisfied: an Xcode with iOS 18 SDK support, XcodeGen, and either the prebuilt GhosttyKit or the ability to build it.

The project is licensed under MIT, with a LICENSE file at the repository root, which is a permissive grant that puts no obstacle in front of a fork or a redistribution. The repository has no GitHub releases, so there is no tagged artefact to point at, and the only version reference in the tree is the TestFlight build itself. The last push was on 2026-10-20, so the code is moving.

The privacy file is worth reading alongside the licence. For an application whose whole function is to hold credentials and open SSH sessions to your infrastructure, the privacy policy is not boilerplate, and PRIVACY.md is short enough to read before you install.

## Conclusion

Remux fits an iPhone owner who drives a remote tmux workspace on a server and wants the session, window and pane model visible rather than scrolled through, especially when the work involves reading a dev server output or previewing a file from a phone. It does not fit an Android user, an iPad workflow, or anyone who needs a stable release trail, since the project ships through a TestFlight public beta with no GitHub releases. Verify first that you can build it with the stated toolchain of Xcode with iOS 18 SDK support and XcodeGen, that the prebuilt GhosttyKit fetch script works in your environment or that you can build it yourself, and that the host key handling matches your own trust model before you store credentials on the device.

## FAQ

### How do I install Remux?

Remux is available as a public beta on TestFlight, and the README also documents building from source, which needs Xcode with iOS 18 SDK support and XcodeGen, then scripts/fetch_ghosttykit.sh, xcodegen generate and xcodebuild.

### Does Remux need an account or a relay server?

No. The README states that Remux connects straight to the server, with no relay and no account, and that passwords and private keys are stored in the iOS Keychain with trusted host keys remembered.

### Can I preview a dev server running on the remote machine from my iPhone?

Yes. Long-pressing a localhost URL in the terminal output opens the dev server running on the remote machine, with hot reload and WebSockets included.

### What tmux features does Remux support?

You can attach to running tmux sessions or start new ones, swipe between windows, pick panes from a bottom sheet with live previews, and split, zoom or close them.

### What can Remux preview besides the terminal output?

Long-pressing a path in the terminal output previews the file, with code, images, PDFs and HTML pages supported, and you can upload photos and files to the server with markup for images, where the remote path is typed at the prompt.

### What licence is Remux released under?

MIT, with the LICENSE file at the repository root. The project ships through a TestFlight public beta and the repository has no GitHub releases, with the last push on 2026-10-20.

## Sources

- [h3nock/remux on GitHub](https://github.com/h3nock/remux)
- [Issues](https://github.com/h3nock/remux/issues)
- [License: MIT](https://github.com/h3nock/remux/blob/main/LICENSE)
- [Project website](https://getremux.app)
- [README](https://github.com/h3nock/remux/blob/main/README.md)

---

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