I know that I can append & to a command to run the process in the background.

I'm SSH'ing into an Ubuntu 12.04 box and running a python program with $python program.py & -- but when I go to close the terminal window I get a message saying that closing the terminal will kill the running process.

Why is this? I am using the ampersand to run the process in the background. How can I get it to run regardless of if I am SSH'ed in?


5 Answers 5


When you close a terminal window, the terminal emulator sends a SIGHUP to the process it is running, your shell. Your shell then forwards that SIGHUP to everything it's running. On your local system, this is the ssh. The ssh then forwards the SIGHUP to what it's running, the remote shell. So your remote shell then sends a SIGHUP to all its processes, your backgrounded program.

There are 2 ways around this.

  1. Disassociate the backgrounded program from your shell.
    1. Use the disown command after backgrounding your process. This will make the shell forget about it.
    2. Prefix your command with nohup (nohup $python program.py &). This accomplishes the same thing, but by using an intermediate process. Basically it ignores the SIGHUP signal, and then forks & executes your program which inherits the setting, and then exits. Because it forked, the program being launched is not a child of the shell, and the shell doesn't know about it. And unless it installs a signal handler for SIGHUP, it keeps the ignore action anyway.
  2. Use logout (or Ctrl+d) instead of closing the terminal window. When you use logout, this isn't a SIGHUP, and so the shell won't send a SIGHUP to any of its children.

Additionally you must make sure that your program doesn't write to the terminal through STDOUT or STDERR, as both of those will no longer exist once the terminal exits. If you don't redirect them to something like /dev/null, the program will still run, but if it tries to write to them, it'll get a SIGPIPE, and the default action of SIGPIPE is to kill the process).

  • 8
    Technically, ssh dying causes the connection to drop, the connection to drop causes sshd on the other end to die. That sshd controlling the master side of the pseudo-terminal that the remote shell runs, when it dies, that's a hang-up (it's like pulling the plug on a real terminal), so the system sends a SIGHUP to the remote shell. Commented Jun 6, 2014 at 22:04
  • 4
    Never mind, answered my own question. POSIX IEEE 1003.1 chap 11, If a modem disconnect is detected by the terminal interface for a controlling terminal ... the SIGHUP signal shall be sent to the controlling process.
    – phemmer
    Commented Jun 6, 2014 at 22:24
  • 2
    Also note that nohup generates a nohup.out file with output of the program you start with it. May be annoying to delete that file every time you've used nohup to start an app this way (or you'd need to redirect its output to /dev/null).
    – Ruslan
    Commented Jun 7, 2014 at 14:42
  • 2
    Instead of nohup python program.py & I'd recommend using setsid python program.py instead, which immediately disowns the program. Commented Aug 26, 2016 at 5:13
  • 1
    Note that logging out without nohuping or disowning the backgrounded process will cause the SSH process to stay active until the backgrounded process terminates or until you interrupt it, and if you do the latter the backgrounded process still gets the SIGHUP and goes byebye. Commented May 30, 2022 at 8:50

The process is running in the background in the terminal, but the output from stdout (and stderr) is still being sent to the terminal. To stop this, add > /dev/null 2>&1 before the & to redirect both the outputs to /dev/null - adding disown also makes sure the process is not killed after you close the terminal:

COMMAND > /dev/null 2>&1 & disown

In your case this would be:

python program.py > /dev/null 2>&1 & disown
  • Is there a way to not have the PID be printed ? Also FYI Put to background immediately: COMMAND > /dev/null 2>&1 &! disown (Bang, exclamation after the ampersand)
    – tgkprog
    Commented Sep 12, 2023 at 21:50

The & operator separates commands to run in parallel, just as ; separates commands to run in series. Both kinds of commands will still run as a child of the shell process.

So, when you close the shell which started those children, the children will be closed also.

What you appear to want is a daemon process, which is significantly more tricky because it needs to dissociate entirely from the parent process. The shell usually doesn't have a simple way of doing that.


When you logout, background processes associated with the login session are normally killed as well. If you want them to be disconnected from the session, run them with nohup.

nohup python program.py &

After the command ending with ampersand (&), at the command prompt run the command bg:

bash> python program.py &  
bash> bg  

This will put the "&" command to the background

bash> jobs  

This will list the jobs running in the background

bash> fg 1   

This will bring Job #1 to the foreground

Another way, (to be able to log out)

bash> at now  
bash> /full/path/python /full/path/program.py  
bash> ^d   `(# That is, Control-D, to run the command, Control-C to cancel)`  

Multiple lines can be submitted to the at command, before the ^d (Control-D)
see man at.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .