How to Use screen to Keep an Application Running After Closing SSH

Verify whether screen is already available:

which screen && screen --version

If the command returns a path (/usr/bin/screen) and the version, skip to the next section. If it returns empty or “command not found”, proceed with the installation.

Install on Debian/Ubuntu-based systems:

sudo apt update
sudo apt install -y screen

On Red Hat-family distributions (Rocky Linux, AlmaLinux, CentOS Stream):

sudo dnf install -y screen

Confirm the installation:

screen --version

The expected output is something like Screen version 4.09.00 (GNU) — any 4.x version will do. 3.x versions still work but are rare these days.

Create a named session. Use a descriptive name for what will run inside:

screen -S deploy

You’ll notice a “clean” screen — it looks like a normal terminal, but you are now inside a screen session. Run any long-running command here. As an example:

ping -c 1000 8.8.8.8

Detach the session without killing the process. This is the most important operation in screen — the shortcut Ctrl+a followed by d:

Press Ctrl+a (hold Ctrl, tap a, release both), then press d alone.

You return to the original shell. The message [detached from 12345.deploy] confirms the session keeps running in the background. You can even close the SSH connection now — the ping keeps counting inside.

List all your active sessions:

screen -ls

The output shows each session with PID, name, and state:

There are screens on:
        12345.deploy    (Detached)
        12890.build     (Detached)
2 Sockets in /run/screen/S-root.

The number before the dot is the daemon PID, and what comes after is the name you gave it. Common states: (Detached) = idle, waiting to be reattached, (Attached) = someone is connected right now, (Dead) = dead but with an orphaned socket (clean it up with screen -wipe).

Reattach the session. Use the name or the PID:

screen -r deploy

You’ll land exactly where you left off — all process output, cursor position, command history. Everything preserved. If there is only one detached session, screen -r with no arguments handles it.

Force reattach. If you forget to detach and open a new SSH connection trying to reattach, you’ll get the error There is no screen to be resumed matching .... Solve it by forcing:

screen -dr deploy

The -d flag forces a detach of the current session (even if another terminal is attached) before reattaching to yours. Use -D -RR for “force detach, attach, create if not exists” — useful in scripts.

Reattach the session and stop the process normally (Ctrl+C or the app’s exit command). Then close the session’s shell:

exit

This closes the shell that screen created. The session is destroyed and disappears from screen -ls. This is the clean way.

Kill a session by force without reattaching (use when it’s stuck):

screen -X -S deploy quit

The -X flag sends a command to a specific session, and quit terminates it. Useful when the process inside is stuck and you don’t want to reattach to debug.

Clean up dead sessions that still appear in screen -ls:

screen -wipe

This command removes all orphaned sockets from sessions whose process has already died. It runs fast and is safe — it doesn’t touch valid active or detached sessions.

Create a test session with a simple counter:

screen -S test
for i in $(seq 1 600); do echo "Tick $i — $(date +%T)"; sleep 1; done

Detach with Ctrl+a d and close the SSH connection completely (exit or close the terminal).

Reconnect to the server via SSH and reattach:

screen -r test

The counter should be well past where you detached — proof it kept running without you. Stop it with Ctrl+C and exit.