Blink Shell: Professional SSH and Mosh Terminal for iOS

The Problem Blink Shell Solves for Mobile Developers

A mobile network is inherently unstable. Moving from Wi-Fi to cellular, riding the subway, or simply locking the screen can drop an SSH connection and force you to reconnect and find your place again. For developers who use an iPhone or iPad as a secondary machine, this makes standard SSH clients frustrating for any session longer than a few minutes.

Blink Shell addresses this with Mosh (Mobile Shell), a protocol designed for intermittent connections. Mosh maintains the session state locally and reconnects transparently when the network comes back. The README states that with Blink you can "check your Safari without fear of having to restart the SSH connection" and move from home, to a train, and to an office without losing the connection.

The second problem Blink targets is rendering quality. Terminals on iOS have historically used slow, incomplete terminal emulators that mishandle special encodings. Blink uses Chromium's HTerm as its rendering engine, which the README describes as ensuring rendering is "perfect and fast, even with those special, tricky encodings."

The target user is a developer who works regularly from a mobile device and needs a terminal that behaves like a desktop tool rather than a mobile app.

Core Architecture: Mosh, SSH, and HTerm

Blink is built on three core components. The first is libmoshios, the iOS port of Mosh. Mosh runs as a UDP-based protocol on top of SSH: you connect via SSH first, which starts a Mosh server, and subsequent communication happens over UDP in a way that handles packet loss and network changes without dropping the session.

The second is libssh2, the SSH client library. Blink uses SSH for initial connection establishment and for cases where Mosh is not available on the server. Key management is built into the application; you configure hosts and RSA keys through the Blink settings interface rather than managing ~/.ssh/config manually.

The third is HTerm, Chromium's terminal emulator ported to iOS. HTerm handles the rendering of escape sequences, colors, and special character encodings. The README attributes the terminal's rendering correctness and speed to this component.

Blink also includes ios_system.framework, a precompiled library that provides a set of Unix-like commands available inside the local shell without requiring a connection to a remote server. The full command set covers file operations, network utilities, and text processing.

Getting Blink: AppStore and Building from Source

Blink is available on the AppStore at https://itunes.apple.com/app/id1156707581. This is the easiest path for most users.

For developers who want to build it themselves or contribute to the project, the repository provides a build path via Xcode. The README describes these steps:

git clone --recursive https://github.com/blinksh/blink.git && \
    cd blink && ./get_frameworks.sh && ./get_resources.sh && \
    rm -rf Blink.xcodeproj/project.xcworkspace/xcshareddata/

After cloning, copy the configuration template:

cp template_setup.xcconfig developer_setup.xcconfig

Edit developer_setup.xcconfig with your Apple Developer ID, then open the project in Xcode, select your device as the build target, and run. The get_frameworks.sh script downloads the precompiled binary libraries: libssh2, OpenSSL, libmoshios, protobuf, and ios_system. Building without iCloud, Push Notifications, and Keychain Sharing requires turning off those capabilities in the Xcode project's entitlements before building.

The raw branch of the repository is used for testing future versions. Testing participation is by invitation.

Shell Utilities and Their Limitations

Blink includes a set of shell commands from ios_system.framework that run locally on the device without a remote connection. The available commands cover file operations (ls, cp, rm, mv, mkdir, chmod, chflags, stat), compression (gzip, tar), text processing (cat, grep, wc), and network transfers (curl, scp, sftp).

The curl command supports http, https, scp, and sftp, and uses the key management configured in Blink. An example from the README:

curl scp://host.name.edu/filename -o filename --key $SHARED/id_rsa --pass MyPassword

The scp and sftp commands are implemented as wrappers over curl, rewriting their arguments to the curl syntax:

scp [email protected]:filename .
sftp localFilename [email protected]:~/

The README notes this means some switches may not behave exactly as they would in a native scp or sftp client. Python and Lua scripting are available for combining these commands into scripts, and redirection works (>, <, &>). Pipes are not supported.

The absence of pipe support is a genuine limitation for shell scripting. You cannot chain commands with | inside Blink's local shell, which rules out most standard Unix one-liners.

There is also an iOS sandbox constraint: the home directory (~) is not writable in iOS. Programs that expect to write configuration files to ~ must have their paths redirected. The README shows the environment variables set in MCPSession.m to handle this:

setenv PATH = $PATH:~/Library/bin:~/Documents/bin
setenv PYTHONHOME = $HOME/Library/
setenv SSH_HOME = $HOME/Documents/
setenv CURL_HOME = $HOME/Documents/
setenv HGRCPATH = $HOME/Documents/.hgrc/
setenv SSL_CERT_FILE = $HOME/Documents/cacert.pem

Changing these permanently requires editing MCPSession.m and rebuilding from source.

SplitView, Keyboard Support, and Configuration

Blink supports iOS SplitView for running the terminal alongside another app, useful for looking up documentation while working in a session. Multiple connections are open simultaneously and navigated by swiping horizontally between them. Sliding down closes a connection.

Bluetooth keyboard support is explicit in the design goals. The README names specific customizations: mapping Caps Lock to Escape (for Vim users) or to Ctrl (for Emacs users), adding custom themes, and installing custom fonts. The interface has no menus; it is full-screen with gesture navigation.

Host configuration and RSA key management are handled through Blink's own settings UI rather than through the standard ~/.ssh/config file. This is both a constraint (you cannot just copy your ~/.ssh/config from a desktop machine) and a design choice that keeps the configuration accessible to users who are not comfortable editing config files.

Where Blink Falls Short

The no-pipe limitation in the local shell is the most significant constraint for shell scripting users. Any workflow that relies on piping the output of one command into another requires connecting to a remote server first.

The scp and sftp implementations as curl wrappers mean that edge-case flags may behave differently from native scp. Users who rely on specific scp options should test their exact workflow.

Blink is a GPL-3.0 project, which has implications for developers who want to build commercial products that include Blink's code. The license requires that derivative works be released under the same terms.

Building from source requires an active Apple Developer account with the correct entitlements. Without Keychain Sharing, iCloud, and Push Notifications configured correctly, the build will fail at signing time. The complexity of the dependency chain (five precompiled frameworks) makes troubleshooting build failures non-trivial.

Blink Shell versus iSH

iSH (iSH Shell) is a free iOS app that runs Alpine Linux using x86 user-mode emulation. It provides access to apk and a broad set of standard Unix utilities including a fully functional shell with pipes. The architecture is different: iSH emulates a local Linux environment rather than providing a terminal client for connecting to remote servers.

Blink is the right choice for developers whose primary use case is connecting to remote servers via SSH or Mosh. iSH is the right choice for developers who want a local Alpine Linux environment on their device for offline work or for running tools that would otherwise require a remote server.

For remote server work, Blink's Mosh integration is a meaningful advantage over iSH, which does not include Mosh. For local development without a server, iSH provides a more complete Unix environment including pipes.

Editorial conclusion

Blink Shell is the right choice for iOS developers who want a professional terminal with stable connections over mobile networks and who are willing to pay for an AppStore app or build it themselves. The combination of Mosh for connection resilience and HTerm for fast rendering addresses the two main failures of general-purpose SSH apps on mobile. It is a poor fit for users who primarily need a local Linux environment: iSH serves that purpose. The absence of pipe support in the built-in shell utilities is a real constraint for shell scripting. Before building from source, check that your Xcode version matches the project requirements and that your Apple Developer account has the necessary entitlements.

Frequently asked questions

Official sources

1. blinksh/blink on GitHub
2. Issues
3. License: GPL-3.0
4. Project website
5. README