I use Tilda (drop-down terminal) on Ubuntu as my "command central" - pretty much the way others might use GNOME Do, Quicksilver or Launchy.

However, I'm struggling with how to completely detach a process (e.g. Firefox) from the terminal it's been launched from - i.e. prevent that such a (non-)child process

  • is terminated when closing the originating terminal
  • "pollutes" the originating terminal via STDOUT/STDERR

For example, in order to start Vim in a "proper" terminal window, I have tried a simple script like the following:

exec gnome-terminal -e "vim $@" &> /dev/null &

However, that still causes pollution (also, passing a file name doesn't seem to work).

  • 1
    That, too, is a good question. I think it's fair to consider Bash a programming language - although indeed the scope of this question is probably more on the sysadmin side...
    – AnC
    Commented Mar 23, 2009 at 12:26
  • This is a duplicate of this question stackoverflow.com/questions/285015/… Commented Mar 23, 2009 at 13:11
  • dup of:superuser.com/questions/177218/…
    – behrooz
    Commented Apr 25, 2011 at 18:07
  • Your use case does not describe complete detachment, per se.
    – jiggunjer
    Commented Aug 25, 2016 at 17:24

21 Answers 21


First of all; once you've started a process, you can background it by first stopping it (hit Ctrl-Z) and then typing bg to let it resume in the background. It's now a "job", and its stdout/stderr/stdin are still connected to your terminal.

You can start a process as backgrounded immediately by appending a "&" to the end of it:

firefox &

To run it in the background silenced, use this:

firefox </dev/null &>/dev/null &

Some additional info:

nohup is a program you can use to run your application with such that its stdout/stderr can be sent to a file instead and such that closing the parent script won't SIGHUP the child. However, you need to have had the foresight to have used it before you started the application. Because of the way nohup works, you can't just apply it to a running process.

disown is a bash builtin that removes a shell job from the shell's job list. What this basically means is that you can't use fg, bg on it anymore, but more importantly, when you close your shell it won't hang or send a SIGHUP to that child anymore. Unlike nohup, disown is used after the process has been launched and backgrounded.

What you can't do, is change the stdout/stderr/stdin of a process after having launched it. At least not from the shell. If you launch your process and tell it that its stdout is your terminal (which is what you do by default), then that process is configured to output to your terminal. Your shell has no business with the processes' FD setup, that's purely something the process itself manages. The process itself can decide whether to close its stdout/stderr/stdin or not, but you can't use your shell to force it to do so.

To manage a background process' output, you have plenty of options from scripts, "nohup" probably being the first to come to mind. But for interactive processes you start but forgot to silence (firefox < /dev/null &>/dev/null &) you can't do much, really.

I recommend you get GNU screen. With screen you can just close your running shell when the process' output becomes a bother and open a new one (^Ac).

Oh, and by the way, don't use "$@" where you're using it.

$@ means, $1, $2, $3 ..., which would turn your command into:

gnome-terminal -e "vim $1" "$2" "$3" ...

That's probably not what you want because -e only takes one argument. Use $1 to show that your script can only handle one argument.

It's really difficult to get multiple arguments working properly in the scenario that you gave (with the gnome-terminal -e) because -e takes only one argument, which is a shell command string. You'd have to encode your arguments into one. The best and most robust, but rather cludgy, way is like so:

gnome-terminal -e "vim $(printf "%q " "$@")"
  • Thanks a lot for this! Sadly I can only accept one answer. I ended up with "nohup $@ &> /dev/null &" and "alias wvim='launch.sh gnome-terminal -x vim'"
    – AnC
    Commented Mar 23, 2009 at 21:33
  • Strange: when I am did «Ctrl-z» in terminal, and next «bg», the process should not anymore relying on terminal. But when I closed the terminal, it was closed too o.O
    – Hi-Angel
    Commented Oct 7, 2014 at 9:07
  • 1
    @Hi-Angel when you close an interactive bash shell, bash HUPs all active jobs. When you ^Z and bg a process it is still a job, be it a background one. To remove it as a job, use disown, then the process will keep on living after you close the shell since bash won't HUP it anymore.
    – lhunath
    Commented Oct 8, 2014 at 12:47
  • 3
    Won't using $* instead of $@ fix the problem of the separate strings already?
    – sjas
    Commented Jan 28, 2015 at 19:15
  • 3
    What you can't do, is change the stdout/stderr/stdin of a process after having launched it. - not exactly true. Use reptyr for this. Commented Sep 23, 2016 at 19:08
nohup cmd &

nohup detaches the process completely (daemonizes it)

  • 7
    Although succinct is valuable, completeness is more valuable. Although nohup is a GNU coreutil, a bash-only answer (or note about there not being one) would be appropriate here. Good answer nonetheless. Commented Jun 6, 2013 at 14:48
  • 44
    nohup just ignores the SIGHUP signal. It executes the process normally. No daemonization.
    – nemo
    Commented Mar 4, 2015 at 16:29
  • 2
    @nemo Which means the process is not detached, but would become detached (and a child of init) if the shell exited... right?
    – Noldorin
    Commented Apr 8, 2016 at 0:35
  • 1
    In Linux nohup is not enough to disassociate the process from the terminal. Programs list ssh will still know what terminal are you from and ask you -for instance- if you want to add something to the known hosts lists. Other Unixes used to have setpgrp and other tricks to completely remove a process from the termios session. Commented Aug 15, 2019 at 19:41
  • 3
    Just to clarify: So nohup cmd &> /dev/null &disown would be the way to go (In case you don't want output in the nohup.out file)? Commented Aug 28, 2019 at 13:02

If you are using bash, try disown [jobspec]; see bash(1).

Another approach you can try is at now. If you're not superuser, your permission to use at may be restricted.

  • "disown" don't seem to be an internal bash command (not available on my machine, and I use bash). "nohup", as Ben suggested, might be a much better (and standard) way of doing this.
    – Eigir
    Commented Mar 23, 2009 at 12:08
  • 2
    at to delegate execution to someone else, I like it! +1
    – Alain
    Commented Apr 12, 2013 at 19:23
  • 1
    As a point of reference, this works in zsh as well.
    – Coderer
    Commented May 28, 2014 at 11:10
  • at now Fantastic!
    – Ani
    Commented Aug 26, 2014 at 13:00
  • 4
    Also, disown doesn't seem to have the desired effect with gnome-terminal--disowned processes are still killed when the terminal exits. I'd love to know why/how. Commented Sep 13, 2016 at 23:00

Reading these answers, I was under the initial impression that issuing nohup <command> & would be sufficient. Running zsh in gnome-terminal, I found that nohup <command> & did not prevent my shell from killing child processes on exit. Although nohup is useful, especially with non-interactive shells, it only guarantees this behavior if the child process does not reset its handler for the SIGHUP signal.

In my case, nohup should have prevented hangup signals from reaching the application, but the child application (VMWare Player in this case) was resetting its SIGHUP handler. As a result when the terminal emulator exits, it could still kill your subprocesses. This can only be resolved, to my knowledge, by ensuring that the process is removed from the shell's jobs table. If nohup is overridden with a shell builtin, as is sometimes the case, this may be sufficient, however, in the event that it is not...

disown is a shell builtin in bash, zsh, and ksh93,

<command> &


<command> &; disown

if you prefer one-liners. This has the generally desirable effect of removing the subprocess from the jobs table. This allows you to exit the terminal emulator without accidentally signaling the child process at all. No matter what the SIGHUP handler looks like, this should not kill your child process.

After the disown, the process is still a child of your terminal emulator (play with pstree if you want to watch this in action), but after the terminal emulator exits, you should see it attached to the init process. In other words, everything is as it should be, and as you presumably want it to be.

What to do if your shell does not support disown? I'd strongly advocate switching to one that does, but in the absence of that option, you have a few choices.

  1. screen and tmux can solve this problem, but they are much heavier weight solutions, and I dislike having to run them for such a simple task. They are much more suitable for situations in which you want to maintain a tty, typically on a remote machine.
  2. For many users, it may be desirable to see if your shell supports a capability like zsh's setopt nohup. This can be used to specify that SIGHUP should not be sent to the jobs in the jobs table when the shell exits. You can either apply this just before exiting the shell, or add it to shell configuration like ~/.zshrc if you always want it on.
  3. Find a way to edit the jobs table. I couldn't find a way to do this in tcsh or csh, which is somewhat disturbing.
  4. Write a small C program to fork off and exec(). This is a very poor solution, but the source should only consist of a couple dozen lines. You can then pass commands as commandline arguments to the C program, and thus avoid a process specific entry in the jobs table.
  1. nohup $COMMAND &
  2. $COMMAND & disown
  3. setsid command

I've been using number 2 for a very long time, but number 3 works just as well. Also, disown has a nohup flag of -h, can disown all processes with -a, and can disown all running processes with -ar.

Silencing is accomplished by $COMMAND &>/dev/null.

Hope this helps!

  • Short and sweet; thanks for this very helpful summary!
    – Jonathan H
    Commented Jan 10, 2019 at 10:20
  • I can't believe I still get notifications for this post... Commented Mar 21, 2019 at 0:41

Most simple and only correct answer for bash:

command & disown

You dont have to detach the process from terminal, but from the shell.

  • This is the only sequence of commands that worked for me Commented Feb 7, 2023 at 1:29

I think screen might solve your problem


in tcsh (and maybe in other shells as well), you can use parentheses to detach the process.

Compare this:

> jobs # shows nothing
> firefox &
> jobs
[1]  + Running                       firefox

To this:

> jobs # shows nothing
> (firefox &)
> jobs # still shows nothing

This removes firefox from the jobs listing, but it is still tied to the terminal; if you logged in to this node via 'ssh', trying to log out will still hang the ssh process.


To disassociate tty shell run command through sub-shell for e.g.


When exit used terminal closed but process is still alive.

check -

(sleep 100) & exit

Open other terminal

ps aux | grep sleep

Process is still alive.

  • This is exactly what I needed. I was attempting to add a console shortcut for sublime text and it works perfectly, here's what I ended up with: ("/opt/Sublime Text 2/sublime_text" $@)&
    – Ron E
    Commented Dec 3, 2013 at 21:10

Backgrounding and foregrounding a job is probably one of the very first things every Unix sys-admin should know.

Here is how it is done with bash:

# suspend process
# background process
# list all backgrounded jobs
# bring it back to foreground

You can run your command using the nohup command, this detach your process and redirects outputs to a given file... but I am not sure that is exactly what you need ..

  • I could swear I had tried nohup before using exec - but apparently not properly, as it does work like this: nohup gnome-terminal -e "vim $@" &> /dev/null &
    – AnC
    Commented Mar 23, 2009 at 12:30

To detach your program completely from your current SSH session, run:

setsid nohup script.sh &

.. and to redirect all logs (stderr & stdout), you can run:

setsid nohup script.sh &>/tmp/script.log &

To double check if your process got detache, run:

ps -efj --forest

and look at the hierarchical process tree.

  • I quite confuse when seeing that you put setsid and nohup together. We can run setsid with -f option so it will be always running in a new process. If you don't want nohup still print out to the terminal, use your second way (can remove the part setsid away too). Anything that I don't know? Commented Oct 24, 2020 at 17:08
  • 1
    This is the only approach that worked for me. My use-case: I have a bash script: "start.sh" The script cleans up some stuff, runs some http server, and then tails the logs generated by the server. I run the ./start.sh script from SSH. I wanted to be able to SSH, ./start.sh, watch the log, but also be able to press Ctrl+C to exit the "tail -f..." command - but still have the HTTP server running.
    – eitama
    Commented Aug 1, 2022 at 13:01

Try daemon -- should be available from your friendly package manager and comprehensively take care of every way of disassociating itself from the terminal.

  • This is great! You can even use it to do a bad thing, something that these other commands won't let you do (because they don't give you the chance to type your password): sudo daemon xed
    – mmortal03
    Commented Aug 22, 2022 at 9:46

Just add this in your bashrc/zshrc:

detach() {
  "$@" 1>/dev/null 2>/dev/null &; disown

Then you can run disowned commands like this:

detach gedit ~/.zshrc
  • 1
    On bash you can just do &> /dev/null
    – Annahri
    Commented May 16, 2021 at 2:07

I have found on Mac OS X that I need to use both nohup AND disown to ensure that the child process is not torn down with the terminal.


In my .bashrc, I have these functions for precisely that purpose:

function run_disowned() {
    "$@" & disown

function dos() {
    # run_disowned and silenced

    run_disowned "$@" 1>/dev/null 2>/dev/null

Prefix a command with dos to run it detached from the terminal.

The function is written to work with bash and zsh.

  • 2
    I am slightly confused as to why this answer uses one function wrapped into another, when its sufficient to just use one function with body like this: ( "$@" & disown) &> /dev/null . It also makes not much sense to use 1> and 2> , because you're using disown, which means you are using bash, and in bash you can just easily do &> to redirect both stdout and stderr Commented Aug 7, 2016 at 18:53
  • I have it as two functions because (1) I think it's easier to read this way, and (2) I need the run_disowned functionality in other places in my dotfiles. You're right about the &> thing, of course.
    – mic_e
    Commented Aug 8, 2016 at 7:17

sudo apt install ucommon-utils

pdetach command

There you go :)


kstart5 from KDE, available in the package kde-cli-tools can help

kstart5 my-command &

We can as well manage multiple aspect of an x window if we are running a gui

Sources: Linuxhacks.org
Disclosure: I am the owner of Linuxhacks.org


I use the following script to do this. It stops the process printing to the terminal, detaches with nohup, and exits with the return status if the command finishes within the TIMEOUT.



CMD=( "$@" )
#Could have some shortcuts here, e.g. replace "somefile.c" with "gedit somefile.c"

#use nohup to run the command, suppressing its output and allowing the terminal to be closed
#also send nohup's output to /dev/null, supressing nohup.out
#run nohup in the background so this script doesn't block
#print the command for debugging and to see bash variable expansion
printf "%q " "${CMD[@]}"
nohup "${CMD[@]}" >/dev/null 2>&1 &

#kill this script after a short time, exiting with success status - command is still running
#this is needed as there is no timeout argument for `wait` below
trap "exit 0" SIGINT SIGTERM
sleep $TIMEOUT && kill $MY_PID 2>/dev/null & #ignore "No such process" error if this exits normally

#if the command finishes before the above timeout, everything may be just fine or there could have been an error
#print an error if there was any. most commonly, there was a typo in the command
[ $NOHUP_STATUS != 0 ] && echo "Error: $CMD"
#return the exit status of nohup, whatever it was

Usage example:

>>> run false
Error: false
>>> echo $?
>>> run true
>>> run sleep 10
sleep 10

Not related to GUI, but I add this very handy answer here because it's one of the topmost results in search.

So, if you want to run something then be able to close the terminal and keep that something running, with the ability to redirect stdin/stdout/stderr:

echo "my_command param1 param2 > out" | at now+1min

Of course, the process will start in 1 minute. Use atq to check status and atrm task_number to cancel the future start.

It does not work for already running processes, only for new ones.


If your goal is to simply launch a command line application without keeping the terminal window around, then you might try running the application after launching the terminal with alt-F2.

You must log in to answer this question.