xinit - ArchWiki

Jump to content

# xinit

From ArchWiki

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`.

Category:

- Xorg commands

Hidden category:

- Pages or sections flagged with Template:Move

xinit
Add topic