When we want to run a programs as root we use
gksudo and etc. Now my question is how do we can run a Terminal as the root user in Terminal?
I tried with using
gksudo terminal and
gksu terminal but nothing happens. and by running
sudo terminal I get error
sudo: terminal: command not found.
Here is Solutions:
We have many solutions to this problem, But we recommend you to use the first solution because it is tested & true solution that will 100% work for you.
What You Really Want
What you probably want is a shell running as root, as though it were produced from a root login (for example, with all the environment variables set for root rather than for your user).
Assuming that’s what you want, as steeldriver has suggested, just run:
You’ll have a root shell in which commands you enter will be run as root (without having to precede them with
But if you really want to run the graphical terminal emulator application as root, read on. I present two ways: with
gksdo, and with the
Since you have the gksu package installed, you can run
gnome-terminal as root with either of:
gksu is set to sudo-mode in Ubuntu by default, these should be equivalent.)
gnome-terminal as root without a controlling non-root terminal:
Virtually every desktop environment provides a facility to run a command without having to open a terminal (which would then, if closed, usually cause the command to be terminated).
This is usually achieved with Alt+F2. A textbox labeled Run command (or similar) will appear and you can enter your command.
For example, it looks like this in Unity:
And like this in MATE (GNOME Flashback/Fallback, Xfce, LXDE are similar):
Note that this works with
gksudo because they use a graphical authentication dialog. If you were to press Alt+F2 and run
sudo ..., you would then be unable to interact with the password prompt.
If you don’t have the gksu package and you won’t want to install it, you can use:
sudo -H gnome-terminal
-H flag is important because it sets the
HOME environment variable to
/root instead of your own user’s home directory. You should not use
sudo gnome-terminal as it can break the gnome-terminal configuration belonging to the non-root user. For more information about this, see:
- RootSudo on the Ubuntu help wiki
- Why should users never use normal sudo to start graphical applications?
sudo -i gnome-terminal is also okay.)
Getting rid of the controlling non-root terminal:
If you (1) open a graphical terminal, (2) run something like
sudo -H gnome-terminal in it, to create a new graphical root terminal, and (3) quit the original non-root graphical terminal …then the root graphical terminal quits as well.
This is because the root graphical terminal is sent SIGHUP when the terminal that owns it is exited.
To prevent this, you might think you could instead launch the graphical root terminal with:
sudo -H gnome-terminal &
But this will only work if
sudo doesn’t have to prompt for a password. If it does, you won’t see the password prompt.
One way to work around this is to use:
sudo -v sudo -H gnome-terminal
sudo -v exists for just this purpose. As explained in
man sudo, it “update[s] the user’s cached credentials, authenticating the user if necessary.”
Note that this will still not work if run directly from your desktop environment’s Alt+F2 “run command” box, because you still need a terminal to enter your password for
Or you can do it in what might be called the traditional way, by suspending the job after it starts:
sudo -H gnome-terminalfrom the original non-root graphical terminal.
- Enter your password as prompted by
sudo. The graphical terminal will start.
- Still in the non-root terminal, press Ctrl+Z to suspend the root terminal. While the root terminal is suspended, you can’t use it; its interface will not respond to your actions.
- Quit the controlling non-root terminal with
exit. The graphical root terminal job will be both unsuspended and disowned by the non-root terminal, automatically.
sudo -H gnome-terminal ^Z exit
But suppose you wanted to keep using the original, non-root terminal too. Then you could run
bg N, where
N is the graphical root terminal’s job number, to resume the job in the background. You can run
jobs to find
N but you probably won’t have to–that number was shown as
[N] when you pressed Ctrl+Z. For example:
[email protected]:~$ sudo -H gnome-terminal [sudo] password for ek: ^Z + Stopped sudo -H gnome-terminal [email protected]:~$
gksudo gnome-terminal (assuming gksu is installed)
opens a terminal as root:
No need to explain that you can use this to open any terminal as root like this; like Vala (
gksudo vala-terminal), Xterm (
gksudo xterm), Termit (
gksudo termit), UXTerm (
gksudo uxterm), Konsole (
gksudo konsole) and so on.
As previously stated, you ask how to run Terminal as root, but more likely you actually want to run the graphical Terminal application as your normal user, and start a root shell inside it where you are logged on as root. In this way the graphical terminal application is not granted root privileges. The previous answers don’t seem to give clear command lines to use so here’s what I use.
xterm -bg black -fg red -e sudo -i
The ‘-e sudo -i’ tells xterm to switch to root in the session, and the colours are just to make it very obvious that it’s a root shell.
With Gnome Terminal
gnome-terminal -- sudo -i
Personally, I bind Gnome keybindings to launch terminals easily
Go to Keyboard settings, add a custom shortcut with Shortcut Super+X and command ‘xterm -bg black -fg white -sb -sl 5000’, and root xterm with Shortcut Super+Z and command ‘xterm -bg black -fg red -sb -sl 5000 -e sudo -i’.
In the past I have tended to prefer xterm over Gnome Terminal because the font is small and simple, but I’m coming round to Terminal now I run high DPI big screens. Colour coding your terminals is a very good idea once you start to run different profiles with dangerous consequences to avoid accidents (e.g. local root, remote client’s machine, remote client root).
That question sounds so simple that there must be a simple solution, right?
Of course you can use
gksudo or similar tools but there may be environments where you don’t want to depend on GTK. It’s confusing but a
terminal is not a
The terminal is that thing what shows you stuff, where the shell is the thing that has those fancy features like environment variables, conditionals and all that scripting stuff. That’s why
x-terminal-emulator -e ... just expects a program to run. No scripts possible here, it just starts a new process. When a terminal starts it just knows that there’s some kind of screen showing you stuff and the input of your keyboard which pours directly in there.
A shell delivers all the logic of a script language like eg. sh, bash, ash, zsh, …!
The other important distinction is who is running the terminal and what shell is running inside it. You may run a terminal in the context of an ordinary user which runs a root shell inside of it but this has some disadvantages eg. when you start a new tab a new shell is spawned but it falls back to the privileges of an ordinary user. Your command of a ‘New shell please’ goes to the terminal and not the shell!
A disappointment when you realize that you have to enter all those sudo stuff once again for every tab you open.
Now, is there a way to open a terminal and not a shell as root without using packages like gksudo? Expecting a debian context:
bash -c "xhost +si:localuser:root; ssh-askpass | sudo -S -Hb /usr/bin/xfce4-terminal --default-working-directory=/root"
Although it looks simple a lot stuff is happening here:
- allow root to access the X desktop of the current user.
- since sudo requires a tty, we avoid that by running
in the context of the current user and asks for your pass.
- sudo now reads that pass from the stdin (-S), it set’s the home folder (-H) and spawns a new process detaching from our context (-b).
- and finally sets the terminal process’ default home folder to root to avoid landing in the home of the current user.
You have a terminal running as root spawned in the context of the current user. Now when you spawn a new tab it’s happening inside the root terminal instead of the user who spawned it.
There’s is a reason why this stuff is so complicated. Keep in mind in whatever X|VNC|RDP session you are running it. It just keeps a terminal open. That’s the downside! If someone is able to capture your session (however likely it may be), root access is for free! Your decision.
There’s another way to do this, tested and working on Ubuntu 16.04 LTS:
First install gnome-panel:
sudo apt install gnome-panel
Then install gksu:
sudo apt install gksu
After installation is complete, run:
gnome-desktop-item-edit ~/Desktop/ --create-new
This creates a desktop shortcut. You should have the option to name it. I called mine ‘X-Term’ but you can call yours pretty much whatever you want. Type in
/usr/bin/gksu* for the ‘Command’ path.
When you launch your new desktop shortcut you will be prompted for an application to run. Type in:
You will now be prompted for your password; once you enter it you’ll have access to a working root terminal. Remember to use only when absolutely necessary and close down when you’re finished with it.
*assuming you installed Ubuntu with default settings and haven’t changed any of the file-systems significantly since installation.
I’m using Debian 9 stretch
Go to keyboard shortcuts, add a command like this:
I had put
Super + T as shortcut.
Now everytime that you wanna open a terminal as root, just type you shortcut
I hope it may help someone in the future
You can start an interactive shell with:
For more information do:
and read the
-s --shell section.
Note: Use and implement solution 1 because this method fully tested our system.
Thank you 🙂