Eternal Terminal vs Mosh: The Persistent SSH Comparison

CodexFuse Team · 2026-11-03T21:47:54.219Z · 11 min read min read

What is the difference between Eternal Terminal and mosh?

Eternal Terminal (ET) is a remote shell that automatically reconnects without interrupting the session, while mosh is a replacement for interactive SSH terminals that is more robust and responsive, especially over Wi-Fi, cellular, and long-distance links. In this eternal terminal vs mosh comparison, the short answer is transport: ET reconnects over TCP on port 2022 after an SSH bootstrap, and mosh roams over UDP on ports 60001–60999 using a screen-state synchronization protocol with predictive local echo. Both solve the same daily frustration — a persistent SSH connection that survives when your laptop changes networks — but they pick different tradeoffs to do it.

The pain is familiar to anyone who manages a what is VPS hosting server from a laptop. You are mid-deploy, you walk from your desk to a meeting room, the Wi-Fi handoff changes your IP address, and plain SSH hangs. Your foreground job dies with it. A mosh alternative like Eternal Terminal changes the equation: the connection heals itself and your session is exactly where you left it. If your job is to keep your SSH session alive on a roaming network, both tools below earn a place in your kit. As of November 2026, ET is in very active development (version 7.1.1 shipped October 29, 2026), while mosh's newest release is 1.4.0 from October 2022 — and both are worth understanding before you pick.

Eternal Terminal vs mosh: side-by-side

The fastest way to keep a SSH session alive on a roaming network is to understand the four structural differences, because everything else follows from them. The table below is the whole eternal terminal mosh comparison in one place.

How Eternal Terminal keeps your session alive

ET starts like a normal SSH session and then changes the rules. The client SSHes into the server, authenticates, and launches etterminal as your user; etterminal registers with etserver, a permanent daemon listening on TCP port 2022. The client then drops the original SSH connection and keeps a reconnectable ET session directly against etserver. Each reconnect uses a negotiated ID and passkey, and saved reattachment credentials live in ~/.et/sessions (owner-only) on macOS and Linux. Keystrokes you type during an outage are cached and replayed when the link comes back. The headline requirement, straight from the docs: ET uses SSH for handshaking and encryption, so you must be able to SSH into the machine first.

Three details matter before you adopt it. First, privilege: etserver usually runs as a root system service. That is an honest tradeoff for a security-conscious admin, and the ET project is actively hardening that daemon — the 7.1.0 release fixed four pre-auth and privilege-escalation issues from security notices. Second, telemetry is on by default (error reports to Datadog, crashes to Sentry); you can opt out with ET_NO_TELEMETRY=1 or --telemetry=false. Third, the good news is genuinely good: port forwarding and SSH agent forwarding are built in, there is jumphost support, named saved sessions, and the client can serve as the transport for VS Code and Cursor Remote-SSH sessions.

How mosh keeps your session alive

Mosh also starts with SSH — for authentication and launching the remote mosh-server — and then speaks the State Synchronization Protocol over UDP, with datagrams encrypted and authenticated with AES-128 in OCB3. Instead of a byte stream, client and server keep snapshots of the terminal's screen state. Roaming is stateless by design: the client sends datagrams with rising sequence numbers plus a heartbeat at least every three seconds, and when the server sees a higher sequence number from a new IP address, that address becomes its new target. It works even when the client never notices its own IP changed, including behind NATs that roam themselves. This is why mosh shrugs off Wi-Fi-to-cellular handoffs.

Mosh's signature feature is predictive local echo. The client runs a model of what the server should display, so your typing and line edits appear instantly — mosh.org cites a trace evaluation where median keystroke response fell from 503 ms to nearly instant. Its signature limitation is scrollback: mosh synchronizes only the visible state of the terminal, so the FAQ tells you to run screen or tmux beginner guide on the remote side if you want history. The other hard requirement is working UDP: mosh uses the first free UDP port from 60001 to 60999, and if a firewall blocks it, nothing works until you open that range (a small range like 60000–60010 is fine for a few sessions, and mosh -p pins a single port). Both sides also need a clean UTF-8 locale or mosh stubbornly refuses to start.

Where mosh still wins

Mosh wins the simplicity and privilege story outright. "No privileged code. No daemon." — the client and server are ordinary-user executables that last only as long as the connection. That is exactly the contrast one lobste.rs commenter pointed at: they tried ET, it worked flawlessly, but ET's root-running server daemon sent them back to mosh. If you cannot or will not run a root daemon on the box, mosh's answer is clean.

Mosh also wins on the worst networks. Predictive local echo is not a gimmick — on a lossy hotel Wi-Fi or a long-distance link, watching your own typing appear instantly while the server catches up is the difference between working and giving up. The mobile client ecosystem is the third win: official paths exist for iOS (Blink Shell) and Android (Termux ships mosh, JuiceSSH added support), so mosh is the documented pick when your terminal lives on a phone. And the no-configuration story is real: install the package, open the UDP range, done.

Where Eternal Terminal wins

ET wins on restrictive networks. Mosh requires working UDP end to end; on corporate firewalls, hotel portals, and university networks where UDP is blocked, mosh cannot connect at all. ET rides a single TCP port — 2022 by default — through the same paths SSH already uses, which is why one terminal vendor's docs recommend ET as the workaround when mosh's UDP traffic never arrives, calling it "identical or better to mosh in all other areas." If your network lets SSH through but blocks UDP, the decision makes itself.

ET also wins the everyday desktop details. Scrollback is native — no tmux required just to see what scrolled past — and the bundled htm/htmd pair speak tmux control mode so stock terminals can attach with OS-native tabs and scroll bars. Port forwarding (--tunnel and OpenSSH-style -L, including reverse tunnels) and SSH agent forwarding are built in, which matters the moment your remote workflow needs a tunnel or your keys. And momentum counts: ET 7.1.1 shipped five days before this comparison was written, while mosh 1.4.0 dates to October 2022. ET is actively fixing security issues in that root daemon; mosh works but is, in one commenter's fair words, accumulating unfixed bugs while the build process gets harder with time. A caveat on the other side: ET's README still points Windows users at WSL even though the 7.1.x releases now ship native windows-x64.zip assets — verify the install path on Windows at setup time.

How to try both in under ten minutes

Install on the client and the server (both tools need their server half). Then connect with the same syntax as SSH.

1. Install Eternal Terminal. macOS: brew install et. Ubuntu: sudo add-apt-repository ppa:jgmath2000/et && sudo apt-get update && sudo apt-get install et. Fedora: sudo dnf install et. FreeBSD: pkg install eternalterminal.
2. Install mosh. Ubuntu: sudo apt-get install mosh. Both sides need a UTF-8 locale (check with locale; force one with mosh remotehost --server="LANG=en_US.UTF-8 mosh-server" if needed).
3. Connect with ET: et user@your-server. Verify the reconnect path: put your laptop to sleep or flip Wi-Fi off and on — the session resumes where it was.
4. Connect with mosh: mosh user@your-server. If it hangs at "Nothing received from the server on UDP port 60003", your firewall is blocking UDP — open 60000–61000 (or a small slice) on the server.
5. Test roaming properly. Start a long-running command in each session (for example ping), switch from Wi-Fi to a phone hotspot, and watch which session is still alive when you come back. On a server that also runs your containers, our Docker beginner guide covers the runtime side of that box.

Which one should you pick?

Pick mosh if you roam on hostile networks where every millisecond of typing latency matters, you connect from a phone or tablet, and you will not run a root daemon on the server. Pick Eternal Terminal if your network blocks UDP, you want native scrollback and tmux control mode without extra setup, you need port forwarding or SSH agent forwarding in the session, or you simply want the tool that is shipping fixes this month. Whichever order you searched — "mosh vs eternal terminal" or "eternal terminal vs mosh" — the deciding question is the same: what does your network block, and what does your security policy allow? For a persistent SSH connection Linux users can rely on, either tool works; only your constraints differ. Note the pairing insight both sides agree on: either tool plus tmux is the belt-and-suspenders setup — ET and mosh keep the connection alive, while tmux keeps the session alive if the connection ever truly dies.

As of November 3, 2026, the honest summary is this: mosh is the finished, no-privilege workhorse with a 2022 release that still works; Eternal Terminal is the actively developed TCP alternative that wins on firewalls, scrollback, and forwarding, at the cost of a root-running server daemon. Try the ten-minute test above on your own network before you commit your dotfiles to either.

Sources

• Eternal Terminal — https://eternalterminal.dev/ (fetch date: 2026-11-03)
• Eternal Terminal README (master) — https://raw.githubusercontent.com/MisterTea/EternalTerminal/master/README.md (fetch date: 2026-11-03)
• Eternal Terminal releases — https://api.github.com/repos/MisterTea/EternalTerminal/releases (fetch date: 2026-11-03)
• Mosh (official site, usage + FAQ) — https://mosh.org/ (fetch date: 2026-11-03)
• Mosh releases — https://api.github.com/repos/mobile-shell/mosh/releases (fetch date: 2026-11-03)
• Eternal Terminal discussion thread — https://lobste.rs/s/jpdyog/eternal_terminal (user anecdotes; fetch date: 2026-11-03)

Frequently Asked Questions

Can mosh and Eternal Terminal replace SSH?

Neither replaces SSH's authentication or its ecosystem — both use SSH to bootstrap (mosh spawns mosh-server; ET spawns etterminal and registers with etserver). Think of them as resilience layers that take over after SSH does the handshake, not as SSH substitutes.

Why does mosh need UDP ports 60001–60999 open?

Mosh's screen-state protocol runs over UDP for roaming and responsiveness, and each session takes the first free UDP port starting at 60001. If a firewall blocks those ports, mosh cannot connect; you can pin a smaller range (for example 60000–60010) or a single port with mosh -p, but UDP must be reachable.

Is Eternal Terminal safe to run if etserver runs as root?

ET's README says etserver "usually runs as root/system service," which is a real tradeoff on shared or hardened boxes. The project is actively hardening that daemon — version 7.1.0 fixed four pre-auth and privilege-escalation issues — and you can disable its default telemetry with ET_NO_TELEMETRY=1. If a root daemon is a dealbreaker, mosh runs entirely as an ordinary user with no daemon.

ET vs mosh on a phone — which is better?

Mosh has the stronger mobile story today: documented iOS clients like Blink Shell and Android support via Termux and JuiceSSH, plus predictive local echo that shines on cellular links. ET works from mobile terminals too, but the vendor-documented mobile path belongs to mosh.

Can I use Eternal Terminal with tmux?

Yes — two ways. ET bundles htm/htmd, which speak tmux control mode so stock terminals get native tabs and scroll bars, or you can simply run plain tmux (or screen) inside an ET session. Mosh users pair with tmux for a different reason: tmux supplies the scrollback that mosh itself does not keep.