eternalterminal.dev

What is Eternal Terminal?

Eternal Terminal (ET) is a remote shell program designed to keep a terminal session alive across network problems. Instead of dropping your session when Wi-Fi flaps or your laptop changes networks, ET automatically reconnects and resumes where you left off. It uses SSH to initialize the connection, so it fits into existing SSH-based workflows rather than replacing your authentication setup.

The practical difference shows up in everyday situations. If you run a long build, edit files in tmux, or monitor logs over a flaky connection, a normal SSH session dies on a network outage and you reconnect to a fresh shell. ET keeps the session intact, so you return to the same state without restarting work.

How it compares

The trade-off is mainly in setup and environment. ET needs its own server component on the remote host, which may be a hurdle on managed systems where you cannot install software. Mosh is often easier to deploy on restricted machines, but you give up native scrolling and tmux control mode. If tmux control mode (tmux -CC) matters to your workflow, ET is the more direct fit.

Who it suits

• Developers and sysadmins working over unstable connections, VPNs, or mobile hotspots.
• Anyone who relies on tmux and wants sessions to survive IP roaming.
• Users who want SSH-like behavior with automatic recovery, not a new terminal paradigm.

If you are unsure, try a concrete test: start a long-running process in tmux over ET, disconnect your network for a minute, then reconnect. If the session resumes cleanly, ET is doing its job. The project provides installation and usage guidance at Eternal Terminal.

How does Eternal Terminal keep a session alive through network outages or IP changes?

Eternal Terminal (ET) keeps a session alive by decoupling the remote shell session from the underlying TCP connection. When the network drops or your IP address changes, the TCP connection dies, but the session state is preserved on the server. ET then reconnects and resumes the same session automatically, rather than starting a new one.

Eternal Terminal

The page describes ET as a "remote shell that automatically reconnects without interrupting the session," and notes it uses ssh to initialize the connection. The key difference from plain ssh is that an ET session survives network outages and IP roaming; with ssh, you must kill and reconnect after an outage.

Compared with related tools:

A concrete scenario: you are running a long build or editing in tmux over a flaky Wi-Fi or mobile connection. With ssh, a brief dropout kills the connection and you lose the live session; with ET, the connection can drop and recover, and your tmux session continues where it left off.

Next step: if you rely on tmux control mode or native scrolling, ET is designed to preserve those workflows across outages; if you only need basic auto-reconnect and can tolerate a fresh session, autossh may be enough.

How do I install and set up Eternal Terminal on my machines?

Eternal Terminal (ET) is a remote shell that keeps your session alive across network drops and IP changes, so you don't have to reconnect or restart your work. Installation is a two-part job: put ET on the machine you want to reach (the server) and on the machine you're typing from (the client). Both need the same major version.

Install on the server (the remote machine)

Use your distribution's package manager where an ET package exists, or build from source otherwise.

• Debian/Ubuntu: sudo apt install eternal-terminal
• Fedora/RHEL: sudo dnf install eternal-terminal
• macOS: brew install eternal-terminal
• From source (any platform): clone the repository and follow its CMake build instructions, then install the resulting binaries.

The server side runs a daemon called etserver. Start and enable it so it survives reboots:

sudo systemctl enable --now etserver

If your distribution doesn't ship a service file, run etserver manually or write a small unit file for it. Open TCP port 2022 in your firewall, since that is ET's default listening port.

Install on the client (your local machine)

Install the same package on your laptop or desktop. The command you'll use is et:

et myhost.example.com

ET initializes the connection over SSH, so you still need working SSH access and a valid key or password for the first handshake. After that, the session is carried over ET's own protocol and survives outages.

First-run checklist

1. Confirm etserver is running on the remote host: systemctl status etserver.
2. Confirm port 2022 is reachable: nc -vz myhost.example.com 2022.
3. Connect once with et myhost.example.com and verify you land in a shell.
4. Test resilience: start a long-running command, disconnect your network briefly, then reconnect. The session should resume rather than start fresh.

Where ET fits compared with alternatives

The trade-off is that ET needs its own daemon and an open port, which is more setup than plain SSH. If you only ever connect from stable networks, SSH plus tmux may be enough; if you roam between Wi-Fi and mobile data or work over flaky links, ET's automatic resume saves real time.

A concrete scenario

You're running a long database migration over SSH from a laptop on hotel Wi-Fi. The connection drops. With SSH you'd reconnect and find the migration killed unless you'd wrapped it in tmux. With ET, you reconnect and the session is exactly where you left it, including your tmux session and scrollback.

For background and the project's own comparison with ssh, autossh and mosh, see Eternal Terminal. If you want a terminal that also handles roaming and predictive local echo, Mosh is the closest alternative, though it lacks native scrolling and tmux control mode.

How does Eternal Terminal compare to ssh, autossh, and mosh?

Eternal Terminal (ET) is a remote shell built for one main advantage: a session that survives network drops and IP changes without starting over. It uses SSH to initialize the connection, then keeps the session alive across outages and roaming. Compared with plain SSH, autossh and Mosh, the differences are mostly about what happens when the network breaks and what terminal features you keep.

Quick comparison

What this means in practice

• SSH is the baseline. It is widely available and works well on stable networks, but if your connection drops or your IP changes, the session ends. You reconnect and start again, unless you are using a multiplexer like tmux or screen.
• autossh automates reconnection. It is useful when you want an SSH session to come back after a drop, but it still creates a new session each time. If you rely on tmux control mode, you may have to wait for the old connection to die before reattaching.
• Mosh is a popular alternative that also survives outages and roaming. Its trade-off, according to the project notes, is that it does not support native scrolling or tmux control mode (tmux -CC).
• Eternal Terminal aims to combine the two: it keeps the session alive and resumes quickly, while retaining native scrolling and tmux control mode. The site describes it as heavily inspired by SSH, autossh and Mosh, and says it uses SSH to initialize the connection.

A concrete scenario

Suppose you are working over a flaky Wi-Fi or mobile connection, with a tmux session running on a remote server. With SSH, a brief drop ends the connection; you reconnect and reattach. With autossh, the connection may come back, but the session is new. With Mosh, the session survives, but you lose native scrollback and tmux control mode. With ET, the session is meant to continue, and you keep those terminal features.

How to choose

• If your network is stable and you only need basic remote access, plain SSH is usually enough.
• If you want automatic reconnection but can tolerate a new session, autossh may fit.
• If roaming and outage survival matter more than scrolling or tmux control mode, Mosh is a strong option.
• If you want outage survival plus native scrolling and tmux control mode, ET is designed for that combination.

A useful next step is to test ET on a connection you can deliberately interrupt, such as by toggling Wi-Fi or switching networks, and compare how quickly each tool resumes your work.

Does Eternal Terminal support tmux control mode and native scrolling?

Yes. Eternal Terminal (ET) explicitly supports both tmux control mode (tmux -CC) and native scrolling. Its own documentation draws the comparison directly: Mosh, its closest alternative, “does not support native scrolling nor tmux control mode,” while ET does.

Why that matters in practice

• tmux control mode (tmux -CC) lets your local terminal act as a controller for a remote tmux session, so windows and panes appear as native tabs/splits and you can use local copy/paste, search and scrollback. That workflow only works if the transport preserves it across reconnects.
• Native scrolling means your terminal emulator's own scrollback handles history, so mouse wheel, search and selection behave as they do locally, instead of relying on the remote program to emulate scrolling.

How ET differs from the alternatives

The key distinction is between reconnecting and resuming. autossh restarts ssh, so you get a fresh session and must re-attach tmux; ET keeps the session alive through the TCP failure and resumes it, which is what makes tmux -CC and local scrollback usable on an unstable link.

When to choose it

Pick ET if you work over flaky Wi-Fi, cellular or a laptop that changes networks, and you want tmux control mode plus your terminal's native scrolling to keep working. Pick plain ssh when the connection is stable and you want zero extra setup. Consider mosh if you mainly care about roaming and don't use tmux -CC or native scrollback, since it's more widely packaged.

A concrete scenario: you run tmux -CC from a laptop on a train, lose signal in a tunnel, and reconnect. With ssh or autossh you'd rebuild the session and re-attach; with ET the tmux session and your scrollback continue where they left off.

Next step: check the install and tutorial pages at Eternal Terminal to confirm client and server setup on your platforms before relying on it as a daily driver.

What are the security and encryption considerations when using Eternal Terminal?

Eternal Terminal (ET) encrypts session traffic and authenticates the connection, but it is not a drop-in replacement for every SSH security model. The page describes ET as a remote shell that keeps a session alive across network outages and IP roaming, and notes that it uses ssh to initialize the connection. That initialization step matters: the initial trust and authentication usually ride on SSH, while the ongoing ET session is maintained by ET's own protocol.

Eternal Terminal

H3 Practical security considerations

• SSH is still part of the trust path. Because ET uses ssh to start the connection, your existing SSH host keys, user keys, and server access rules remain relevant. If SSH access is poorly secured, ET inherits that weakness.
• Session persistence changes the risk profile. A session that survives network drops and IP changes is convenient, but it also means an authenticated session can remain usable longer. Treat an ET session like a long-lived login: lock your screen, avoid leaving sensitive terminals open, and disconnect when finished.
• Encryption is not the same as endpoint security. ET protects traffic in transit, but it cannot protect a compromised client or server. Malware on either end, a stolen key, or an unpatched host can still expose the session.
• Roaming and reconnection can complicate network controls. If your organization relies on source-IP restrictions or short-lived network sessions, ET's ability to resume from a new network may conflict with those policies. Check with your security team before using it on restricted networks.

H3 How it compares with alternatives

A useful next step is to test ET on a non-critical host and review how it handles authentication in your environment. If you need strict source-IP controls or short session lifetimes, confirm whether ET's roaming behavior can be constrained before rolling it out more broadly. For general remote-access hardening, follow your organization's SSH key management and patching practices rather than assuming ET changes those requirements.