xinit

Related articles
Display manager
Xorg
xprofile
Xresources
From
Wikipedia
:
The
xinit
program allows a user to manually start an
Xorg
display server. The
startx(1)
script is a front-end for
xinit(1)
.
xinit
is typically used to start
window managers
or
desktop environments
. While you can also use
xinit
to run GUI applications without a window manager, many graphical applications expect an
EWMH
compliant window manager.
Display managers
start
Xorg
for you and generally source
xprofile
.
Installation
Install
the
xorg-xinit
package.
Configuration
xinit
and
startx
take an optional client program argument, see
#Override xinitrc
.  If you do not provide one they will look for
~/.xinitrc
to run as a shell script to start up client programs.
xinitrc
~/.xinitrc
is handy to run programs depending on X and set environment variables on X server startup. If it is present in a user's home directory,
startx
and
xinit
execute it. Otherwise
startx
will run the default
/etc/X11/xinit/xinitrc
.
Note
Xinit
has its own default behaviour instead of executing the file. See
xinit(1)
for details.
This default xinitrc will start a basic environment with
Twm
,
xorg-xclock
and
Xterm
(assuming that the necessary packages are installed). Therefore, to start a different window manager or desktop environment, first create a copy of the default
xinitrc
in your home directory:
$ cp /etc/X11/xinit/xinitrc ~/.xinitrc
Then
edit
the file and replace the default programs with desired commands. Remember that lines following a command using
exec
would be ignored. For example, to start
xscreensaver
in the background and then start
openbox
, use the following:
~/.xinitrc
...
xscreensaver &
exec openbox-session
Note
At the very least, ensure that the last
if
block in
/etc/X11/xinit/xinitrc
is present in your
~/.xinitrc
file to ensure that the scripts in
/etc/X11/xinit/xinitrc.d
are sourced.
Long-running programs started before the window manager, such as a screensaver and wallpaper application, must either fork themselves or be run in the background by appending an
&
sign. Otherwise, the script would halt and wait for each program to exit before executing the window manager or desktop environment. Note that some programs should instead not be forked, to avoid race bugs, as is the case of
xrdb
. Prepending
exec
will replace the script process with the window manager process, so that X does not exit even if this process forks to the background.
xserverrc
The
xserverrc
file is a shell script responsible for starting up the X server. Both
startx
and
xinit
execute
~/.xserverrc
if it exists,
startx
will use
/etc/X11/xinit/xserverrc
otherwise.
See
Xserver(1)
for a list of all command line options.
Passing virtual terminal number
In order to maintain an
authenticated session
with
logind
and to prevent bypassing the screen locker by switching terminals,
Xorg
has to be started on the same virtual terminal where the login occurred
[1]
. For this purpose,
Xorg
needs to be passed the number of the current virtual terminal.
If you are invoking
startx
, nothing more needs to be done – it
contains logic
to compute and pass the virtual terminal number to
Xorg
.
In other cases, e.g. if you are running
xinit
, it is recommended to specify
vt$XDG_VTNR
in the
~/.xserverrc
file:
~/.xserverrc
#!/bin/sh

exec /usr/bin/Xorg -nolisten tcp "$@" vt$XDG_VTNR
Tip
-nolisten local
can be added after
-nolisten tcp
to disable abstract sockets of X11 to help with isolation.  There is a
quick background
on how this potentially affects X11 security.
Note
To re-enable redirection of the output from X session into the Xorg log file, add the
-keeptty
option. See
Xorg#Session log redirection
for details.
Usage
To run Xorg as a regular user, issue:
$ startx
Or if
#xserverrc
is configured:
$ xinit -- :1
Note
xinit
does not handle multiple displays when another X server is already started. For that you must specify the display by appending
-- :
display_number
, where
display_number
is
1
or more.
Your window manager (or desktop environment) of choice should now start correctly.
To quit X, run your window manager's exit function (assuming it has one). If it lacks such functionality, run:
$ pkill -15 Xorg
Note
pkill
will kill all running X instances. To specifically kill the window manager on the current virtual terminal, run:
$ pkill -15 -t tty"$XDG_VTNR" Xorg
See also
signal(7)
.
Tips and tricks
Override xinitrc
If you have a working
~/.xinitrc
but just want to try other window manager or desktop environment, you can run it by issuing
startx
followed by the path to the window manager, for example:
$ startx /usr/bin/i3
If the binary takes arguments, they need to be quoted to be recognized as part of the first parameter of
startx
:
$ startx "/usr/bin/
application
--
key value
"
Note that the full path is
required
. You can also specify custom options for the
#xserverrc
script by appending them after the double dash
--
sign:
$ startx /usr/bin/enlightenment -- -br +bs -dpi 96
See also
startx(1)
.
Note
Since the scripts under
/etc/X11/xinit/xinitrc.d/
are skipped, the environment variable
DISPLAY
may need be to set. You can try out
i3
on the desired display by executing
DISPLAY=:
display_number
startx /usr/bin/i3
.
Tip
This can be used to start regular GUI programs but without any of the basic window manager features. See also
#Starting applications without a window manager
and
Running program in separate X display
.
Autostart X at login
Make sure that
startx
is properly
configured
.
Place the following in your
login shell
initialization file (e.g.
~/.bash_profile
for
Bash
or
~/.zprofile
for
Zsh
):
if [ -z "$DISPLAY" ] && [ "$XDG_VTNR" -eq 1 ]; then
  exec startx
fi
You can replace the
-eq
comparison with one like
-le 3
(for vt1 to vt3) if you want to use graphical logins on more than one virtual terminal.
Alternative conditions to detect the virtual terminal include
"$(tty)" = "/dev/tty1"
, which does not allow comparison with
-le
, and
"$(fgconsole 2>/dev/null || echo -1)" -eq 1
, which does not work in
serial consoles
.
The
exec
command ensures that the user is logged out when the X server exits, crashes or is killed by an attacker. If you want to take the risk and remain logged in when the X session ends, remove
exec
.
See also
fish#Start X at login
.
Tip
This method can be combined with
automatic login to virtual console
.
Switching between desktop environments/window managers
If you are frequently switching between different desktop environments or window managers, it is convenient to either use a
display manager
or expand
~/.xinitrc
to make the switching possible.
The following example shows how to start a particular desktop environment or window manager with an argument:
~/.xinitrc
...

# Here Xfce is kept as default
session=${1:-xfce}

case $session in
    i3|i3wm           ) exec i3;;
    kde               ) exec startplasma-x11;;
    xfce|xfce4        ) exec startxfce4;;
    # No known session, try to run it as command
    *                 ) exec $1;;
esac
To pass the argument
session
:
$ xinit
session
or
$ startx ~/.xinitrc
session
Starting applications without a window manager
It is possible to start only specific applications without a window manager, although most likely this is only useful with a single application shown in full-screen mode. For example:
~/.xinitrc
...

exec chromium
Alternatively the binary can be called directly from the command prompt as described in
#Override xinitrc
.
With this method you need to set each application's window geometry through its own configuration files (if possible at all).
Tip
This can be useful to launch graphical games, where excluding the overhead of a compositor can help improve the game's performance.
See also
Display manager#Starting applications without a window manager
.
Output redirection using startx
See
Xorg#Session log redirection
for details.
Running in a virtual server
This article or section is a candidate for moving to
Xorg
.
Notes:
Not related to
xinit
. (Discuss in
Talk:Xinit
)
Useful for running graphical applications:
Without showing their GUI.
On testcases.
Within a system that does not have
xorg-server
running.
While
building in a clean chroot
.
Install
xorg-server-xvfb
, then run
xvfb-run
command
.