mosh.org

Yes. Mosh is designed to keep an interactive terminal session alive across laptop sleep and temporary network loss. According to mosh.org, you can put your laptop to sleep and wake it up later "keeping your connection intact," and if your Internet connection drops, Mosh warns you but the connection resumes when network service comes back. This works because Mosh is built for roaming and intermittent connectivity, rather than treating every network change as a reason to start over.

What Mosh actually preserves

Mosh is a remote terminal application and a replacement for interactive SSH terminals. Its selling point is that it stays usable over Wi-Fi, cellular, and long-distance links where SSH tends to stall or disconnect.

The site's own framing is "Change IP. Stay connected." — Mosh automatically roams as you move between Internet connections, so switching from Wi-Fi on a train to Ethernet in a hotel to LTE elsewhere doesn't log you out. Most network programs, including SSH and web apps, lose their connections after roaming; Mosh is the exception described on the site.

Why it survives when SSH doesn't

The mechanism matters if you're deciding whether to rely on it:

• UDP-based protocol. After the initial login, Mosh runs mosh-server remotely and connects to it over UDP. The site notes this UDP-based protocol handles packet loss gracefully and sets the frame rate based on network conditions.
• Same login method, different transport. The mosh client logs in to the server via SSH using your existing credentials (password or public key), then hands off to the UDP session. Mosh itself doesn't listen on network ports or authenticate users.
• No privileged code, no daemon. You don't need superuser rights to install or run Mosh. The client and server are executables run by an ordinary user and last only for the life of the connection — so there's no background service holding things together.

A practical example: you're editing a file in vim over a cellular hotspot, close the lid to board a train, reopen it twenty minutes later on the train's Wi-Fi. With SSH you'd typically find a frozen or dead terminal and reconnect. With Mosh, per the site's description, the session is still there.

What you'll see when the network drops

Mosh doesn't silently pretend everything is fine. When connectivity is lost, it warns you, and the session resumes once the network is back. Separately, Mosh provides intelligent local echo: typing, deleting, and line editing respond instantly instead of waiting for the server's reply. On a bad connection, outstanding predictions are underlined so you aren't misled about what the server has actually received. This is why Mosh feels responsive even when the link is poor — and why it remains usable in full-screen programs like emacs and vim.

Limits worth knowing before you switch

• UTF-8 only. Mosh was designed from scratch and supports just one character set. The site presents this as fixing Unicode bugs found in other terminals and in SSH, but it does mean non-UTF-8 workflows aren't supported.
• It's a terminal program, not a GUI. Mosh runs inside xterm, gnome-terminal, urxvt, Terminal.app, iTerm, emacs, screen, or tmux, like ssh.
• Availability. Mosh is free software available for GNU/Linux, BSD, macOS, Solaris, Android, Chrome, and iOS.
• Control-C behaves better. Because the UDP protocol doesn't fill up network buffers, the site states Control-C always works to halt a runaway process.

Bottom line

If your concern is losing work when your laptop sleeps or your connection flaps, Mosh is built precisely for that case: sleep and wake keep the connection intact, drops produce a warning, and the session resumes when the network returns. If you need non-UTF-8 character support or a non-terminal interface, look elsewhere. For installation and usage details, the site points to its "Getting Mosh" and "Usage" pages.

Mosh is a command-line program that runs inside your existing terminal, just like ssh. You can launch it from xterm, gnome-terminal, urxvt, Terminal.app, iTerm, emacs, screen, or tmux. Its main limitation is that it supports only one character set: UTF-8. Within that constraint, it fixes Unicode bugs found in other terminals and in SSH, and its UDP-based protocol keeps Control-C working even when packets are lost.

What Mosh Is and How It Fits Your Terminal

Mosh (mobile shell) is a remote terminal application and a replacement for interactive SSH terminals. According to mosh.org, it is designed to be more robust and responsive than SSH, especially over Wi-Fi, cellular, and long-distance links. It is free software available for GNU/Linux, BSD, macOS, Solaris, Android, Chrome, and iOS.

Because Mosh is a command-line program, it does not replace your terminal emulator—it runs inside it. That means your existing terminal setup, multiplexer, or editor session can host a Mosh connection without a separate GUI.

How a Mosh Session Starts

Mosh keeps the same login method you already use with SSH:

1. The mosh client logs in to the server via SSH.
2. You present the same credentials as before (for example, a password or public key).
3. Mosh runs mosh-server remotely and connects to it over UDP.

No privileged code or daemon is involved. Both the client and server are executables run by an ordinary user, and they last only for the life of the connection. Mosh does not listen on network ports or authenticate users itself—SSH handles that step.

Terminal Behavior: Echo, Roaming, and Control-C

Mosh's design changes how the terminal feels in several concrete ways:

• Intelligent local echo. SSH waits for the server's reply before showing your own typing, which can make the interface feel laggy. Mosh gives an instant response to typing, deleting, and line editing, adaptively, and it works even in full-screen programs like emacs and vim. On a bad connection, outstanding predictions are underlined so you are not misled.
• Roaming. Mosh automatically roams as you move between internet connections—Wi-Fi on a train, Ethernet in a hotel, LTE on a beach—and you stay logged in. Most network programs, including SSH, lose their connections after roaming.
• Sleep and dropped connections. You can put your laptop to sleep and wake it later with the connection intact. If the internet connection drops, Mosh warns you, and the connection resumes when network service returns.
• Control-C reliability. Unlike SSH, Mosh's UDP-based protocol handles packet loss gracefully and sets the frame rate based on network conditions. Mosh does not fill up network buffers, so Control-C always works to halt a runaway process.

Limitations to Know Before You Switch

The UTF-8-only design is the most visible constraint: if your workflow depends on a non-UTF-8 character set, Mosh is not a drop-in fit. For UTF-8 environments, the trade-off is deliberate—Mosh was designed from scratch around that single character set and fixes Unicode bugs in other terminals and in SSH.

Choosing Mosh for Your Workflow

Mosh is a good fit if you work in UTF-8 terminals, move between networks, or deal with laggy long-distance links, and you want instant local echo plus reliable Control-C. It is less suitable if you need a character set other than UTF-8 or if your environment cannot run the mosh client and mosh-server as an ordinary user over SSH and UDP. In short: same login as SSH, better behavior inside the terminal, with UTF-8 as the boundary condition.

Mosh is a replacement for interactive SSH terminals that keeps your session alive when your network changes, your connection drops, or your laptop sleeps, and it echoes your typing instantly instead of waiting for the server. It is the better choice when you work over Wi-Fi, cellular, or long-distance links; plain SSH remains fine for stable wired connections or for non-interactive tasks like file transfer and remote command execution.

The core differences at a glance

Roaming and intermittent connectivity

Mosh "automatically roams as you move between Internet connections." The site's example is using Wi-Fi on a train, Ethernet in a hotel, and LTE on a beach while staying logged in. Most network programs, including SSH and web apps, lose their connections after roaming.

The same resilience covers interruptions. You can put your laptop to sleep and wake it later with the connection intact. If the Internet connection drops, Mosh warns you, and the connection resumes when network service comes back.

Responsive typing and honest predictions

SSH shows your own typing only after the server replies, which feels laggy on slow links. Mosh responds instantly to typing, deleting, and line editing, and it does this adaptively, including inside full-screen programs like emacs and vim. On a bad connection, predictions that haven't been confirmed are underlined so you aren't misled about what the server has actually received.

How the connection is established

Mosh doesn't listen on network ports or authenticate users itself. The mosh client logs in to the server via SSH using the same credentials you already use (password or public key). It then runs mosh-server remotely and connects to it over UDP. In practice, this means:

1. Input: you run mosh with a destination, the same way you would use ssh.
2. Action: the client authenticates over SSH, starts mosh-server on the remote host, and switches to a UDP session.
3. Expected result: an interactive terminal that survives roaming and drops and echoes your keystrokes immediately.

Two conditions follow from this design: the remote host must be able to run mosh-server, and UDP traffic between the two machines must be permitted. Neither step requires superuser privileges.

Terminal behavior

Mosh is a command-line program like ssh and runs inside xterm, gnome-terminal, urxvt, Terminal.app, iTerm, emacs, screen, or tmux. It was designed from scratch and supports only UTF-8, which the project says fixes Unicode bugs found in other terminals and in SSH. Because its UDP protocol handles packet loss gracefully and sets the frame rate based on network conditions, it doesn't fill network buffers, so Control-C always works to halt a runaway process.

When to choose which

• Choose Mosh for interactive shell work on laptops and mobile devices, especially over Wi-Fi, cellular, or long-haul links, and when you need sessions to survive sleep, drops, or network switches.
• Stay with SSH when you need a stable, traditional TCP session, are working on a fast and reliable wired network, or are doing non-interactive work such as transfers and scripted remote commands.
• Check first that the server side can run mosh-server and that UDP is allowed through the path between client and server; otherwise the SSH login will succeed but the Mosh session won't come up.

Mosh is free software, and the project distributes it for the platforms listed above.

Mosh (mobile shell) is a remote terminal application and a replacement for interactive SSH terminals, distributed as free software from mosh.org. It is designed for unstable or high-latency connections: it supports roaming between networks, survives intermittent connectivity and sleep/wake cycles, and gives instant local echo of your typing. It runs on GNU/Linux, BSD, macOS, Solaris, Android, Chrome, and iOS. Choose it when you work over Wi-Fi, cellular, or long-distance links and want a session that stays alive and feels responsive; stick with plain SSH if you need a minimal, universally installed tool or cannot use UDP.

What problem it solves

Standard SSH ties a session to a TCP connection and waits for the server's reply before displaying your keystrokes. On a slow or flaky link, that means laggy typing and a session that dies when your IP address changes. Mosh addresses both:

• Roaming: it keeps you logged in as you move between connections — Wi-Fi on a train, Ethernet in a hotel, LTE elsewhere. Most network programs, including SSH, drop the connection on roaming.
• Intermittent connectivity: you can suspend your laptop and resume later with the connection intact. If the network drops, Mosh warns you and resumes when service returns.
• Responsiveness: typing, deleting, and line editing respond instantly, adaptively, even inside full-screen programs like emacs and vim. On a bad connection, unconfirmed predictions are underlined so you are not misled.
• Robustness under loss: the UDP-based protocol handles packet loss gracefully and sets its frame rate from network conditions. It does not fill network buffers, so Control-C reliably halts a runaway process.

How it works and what it does not change

Mosh is a command-line program like ssh, run inside xterm, gnome-terminal, urxvt, Terminal.app, iTerm, emacs, screen, or tmux. It does not listen on network ports or authenticate users itself. Instead:

1. The mosh client logs in to the server over SSH using your existing credentials (password or public key).
2. It starts mosh-server remotely and connects to it over UDP.

No superuser privileges are needed to install or run it, and no daemon persists: the client and server are ordinary-user executables that last only for the life of the connection. One constraint to plan for: Mosh supports only UTF-8, though it fixes Unicode bugs found in other terminals and in SSH.

When to use it — and when not to

Getting started

The official site's "Getting Mosh" page is the entry point for installation on each supported platform. Before installing, confirm that UDP traffic is permitted between client and server and that your terminal uses UTF-8; both are prerequisites for a working session. After connecting, verify success by typing in a full-screen editor such as vim — instant echo with underlined predictions on a poor link is the expected behavior — then test roaming by switching networks and confirming the session survives.

No. Mosh does not require superuser privileges and does not run a daemon. The client and server are ordinary executables run by your normal user account, and they exist only for the life of the connection. Mosh also does not listen on network ports or authenticate users itself — it logs in over SSH using the same credentials you already use.

What "no privileged code, no daemon" means in practice

Mosh's own documentation states this directly: you don't need to be the superuser to install or run Mosh, and the client and server are executables run by an ordinary user that last only for the life of the connection.

That gives you three concrete properties:

• No root to install or run. You can install and use Mosh as a regular user. You are not adding a system service or changing how the machine boots.
• Nothing stays running. There is no background process waiting for connections after you disconnect. When the session ends, the mosh processes end with it.
• No new attack surface from listening ports. Mosh does not listen on network ports. It is not a server you expose and harden; it is a pair of short-lived processes tied to one session.

How login still works without its own authentication

Mosh deliberately does not implement its own authentication. The sequence is:

1. The mosh client logs in to the server via SSH, using the same credentials as before — password, public key, or whatever your SSH setup uses.
2. Once authenticated, Mosh starts mosh-server remotely.
3. The client then connects to that server over UDP.

So your existing SSH trust model — keys, authorized_keys, sshd configuration — remains the gatekeeper. Mosh adds a UDP transport for the session itself, not a second login system.

What this means for your setup

A practical consequence: if SSH access already works for a user, that user is the right person to run Mosh. You don't need to grant elevated rights or open an additional inbound service just to get roaming and local echo. The trade-off is that Mosh depends on SSH being reachable for the initial login — it is a replacement for interactive SSH terminals, not a way to bypass SSH.

Where the UDP connection fits

Because the session runs over UDP rather than the SSH channel, Mosh can survive IP changes and dropped connectivity: the documentation describes automatic roaming between Wi-Fi, Ethernet, and cellular, and resuming after a laptop sleeps or the network drops. That robustness comes from the UDP protocol, while access control stays with SSH. If you are troubleshooting a connection, separate the two stages — SSH login first, then the UDP session — since a failure in either produces a different symptom.