I've recently come to like setsid. It starts off looking like you're just running something from the terminal but you can disconnect (close the terminal) and it just keeps going.

This is because the command actually forks out and while the input comes through to the current terminal, it's owned by a completely different parent (that remains alive after you close the terminal).

An example:

setsid gnome-calculator

I'm also quite partial to disown which can be used to separate a process from the current tree. You use it in conjunction with the backgrounding ampersand:

gnome-calculator & disown

I also just learnt about spawning subshells with parenthesis. This simple method works:

(gnome-calculator &)

And of course there's nohup as you mentioned. I'm not wild about nohup because it has a tendency to write to ~/nohup.out without me asking it to. If you rely on that, it might be for you.

nohup gnome-calculator

And for the longer-term processes, there are things like screen and other virtual terminal-muxers that keep sessions alive between connections. These probably don't really apply to you because you just want temporary access to the terminal output, but if you wanted to go back some time later and view the latest terminal activity, screen would probably be your best choice.

The internet is full of screen tutorials but here's a simple quick-start:

• https://thingsilearned.com/things/gnu-screen-super-basic-tutorial/

Yes. Just add an ampersand (&) at the end of command.

You'll also be able to redirect standard output using > and standard error with 2>.

ex:

ls &                                 # will background the LS command (you'll have a ready prompt) but will show standard output and standard error
ls > /dev/null &                     # will do LS in background showing only standard error
ls > /dev/null 2>&1 &                # will execute the LS command discarding any output        
ls > ls_output.txt &                 # will background LS and store the output in ls_output.txt while error still on video
ls > ls_output.txt 2>ls_error.log &  # will put LS output in ls_output.txt and errors in ls_error.log
ls > ls_output_all.txt 2>&1 &        # will put both LS standard error and standard output to same output_all.txt

Before running the command, you can append & to the command line to run in the background:

long-running-command &

After starting a command, you can press CtrlZ to suspend it, and then bg to put it in the background:

long-running-command
[Ctrl+Z]
bg

Suspend the process with CTRL+Z then use the command bg to resume it in background. For example:

Copysleep 60
^Z  #Suspend character shown after hitting CTRL+Z
[1]+  Stopped  sleep 60  #Message showing stopped process info
bg  #Resume current job (last job stopped)

More about job control and bg usage in bash manual page:

JOB CONTROL
Typing the suspend character (typically ^Z, Control-Z) while a process is running causes that process to be stopped and returns control to bash. [...] The user may then manipulate the state of this job, using the bg command to continue it in the background, [...]. A ^Z takes effect immediately, and has the additional side effect of causing pending output and typeahead to be discarded.

bg [jobspec ...]
Resume each suspended job jobspec in the background, as if it had been started with &. If jobspec is not present, the shell's notion of the current job is used.

EDIT

To start a process where you can even kill the terminal and it still carries on running

Copynohup [command] [-args] > [filename] 2>&1 &

e.g.

Copynohup /home/edheal/myprog -arg1 -arg2 > /home/edheal/output.txt 2>&1 &

To just ignore the output (not very wise) change the filename to /dev/null

To get the error message set to a different file change the &1 to a filename.

In addition: You can use the jobs command to see an indexed list of those backgrounded processes. And you can kill a backgrounded process by running kill %1 or kill %2 with the number being the index of the process.

There are different ways to run a terminal program and continue using the terminal:

• You can open another terminal tab (right-click, then select "Open New Tab").
• You can append & to the command you run. Be aware that you will not see text output to the terminal, such as error messages.
• You can type Ctrl-Z and then run bg. This has the same effect as running command &
• You can run nohup command & and then press enter. (Thanks to ccpizza, see comments below.)

However, pressing Alt-F2 and then running your command from the GUI is usually considered best practice - there is no terminal at all!

Note that when using & (not nohup), closing the terminal will still terminate the application unless you run disown afterwards.

EDIT: It looks like using nohup will sometimes leave little droppings in your home folder. What would normally have been logged to the terminal is apparently saved to a file in ~/.

~~

A simple way to run a program in the background is program-name & disown, which will drop you to a terminal which can be closed without killing the process.