diff --git a/CNAME b/CNAME new file mode 100644 index 0000000..d56ea0e --- /dev/null +++ b/CNAME @@ -0,0 +1 @@ +build.i3wm.org diff --git a/docs/bigpicture.png b/docs/bigpicture.png new file mode 100644 index 0000000..031673b Binary files /dev/null and b/docs/bigpicture.png differ diff --git a/docs/debugging.html b/docs/debugging.html new file mode 100644 index 0000000..c2d79a2 --- /dev/null +++ b/docs/debugging.html @@ -0,0 +1,249 @@ + + + + + + +i3: Debugging i3: How To + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+
+

This document describes how to debug i3 to send us useful bug +reports, even if you have no knowledge of C programming.

+

Thank you for being interested in debugging i3. It really means +something to us to get your bug fixed. If you have any questions about the +process and/or need further help, do not hesitate to contact us!

+
+
+
+

Verify you are using i3 ≥ 4.10

+
+

Only the latest major version of i3 is supported. To verify which version +you are running, use:

+
+
+
$ i3 --moreversion 2>&- || i3 --version
+Binary i3 version:  4.7 (2013-12-22, branch "tags/4.7")
+Running i3 version: 4.7-84-gac74a63 (2014-01-01, branch "next") (pid 1995)
+
+

Your version can look like this:

+
+
+4.7 (release version) +
+
+

+You are using a release version. In many cases, bugs are already +fixed in the development version of i3. Even if the bug is not a known fixed +one, we will still ask you to reproduce your error with the most recent +development version of i3. Therefore, please upgrade to a development version +if you can. +

+
+
+4.7-85-g9c15b95 (development version) +
+
+

+Your version is 85 commits newer than 4.7, and the git revision of your +version is 9c15b95. Go to https://github.com/i3/i3/commits/next and see if +the most recent commit starts with the same revision. If so, you are using the +latest version. +

+
+
+

Development versions of i3 have logging enabled by default and are compiled +with debug symbols.

+
+
+
+

Enabling logging

+
+

If you are using a development version (see previous section), you don’t need +to do anything — skip to section 3.

+

If you are using a release version with a custom ~/.xsession (or xinitrc) +file, execute i3 with a line like this:

+
+
+
# Use 25 MiB of RAM for debug logs
+exec i3 --shmlog-size=26214400
+
+

If you are NOT using an ~/.xsession file but you just chose "i3" from the +list of sessions in your desktop manager (gdm, lxdm, …), edit +/usr/share/xsessions/i3.desktop and replace the Exec=i3 line with:

+
+
+
Exec=i3 --shmlog-size=26214400
+
+

If you cannot restart i3 for some reason, you can enable debug logging on the +fly:

+
+
+
i3-msg 'debuglog on; shmlog on; reload'
+
+
+
+
+

Reproducing the problem

+
+

Before submitting an issue, please make sure to close down on the problem as +much as you can yourself. Here are some steps you should consider:

+
    +
  • +

    +Find a deterministic, reliable way to reproduce the problem and provide it + with your bug report. +

    +
    • +
  • +

    +Try using the default i3 config to reproduce the problem. If the issue does + not appear with the default config, gradually adapt it to track down what + change(s) to the config introduce the problem. +

    +
    • +
  • +

    +Reproduce the problem with a minimal setup, i.e., only use as few applications, + windows and steps as necessary. +

    +
    • +
  • +

    +In addition, try to stick to applications that are common and, even more + importantly, free / open source. +

    +
    • +
  • +

    +Before obtaining the log file, restart i3 in-place, execute the steps to + reproduce the problem and then save the logs. This keeps the log file as + small as possible and necessary. +

    +
    • +
+

Please be aware that we cannot support compatibility issues with closed-source +software, as digging into compatibility problems without having access to the +source code is too time-consuming. Additionally, experience has shown that +often, the software in question is responsible for the issue. Please raise an +issue with the software in question, not i3.

+
+
+
+

Obtaining the debug logfile

+
+
+ + + +
+
Caution
+		 +

Logs may contain sensitive information, so please inspect the log before +submitting it. Logs may be viewed by anyone, once posted. If you choose to +redact the log, make an effort not to discard information which may be relevant +to the issue you are reporting.

+

The best way to avoid submitting such information is to only run the necessary +steps to reproduce the behavior when saving the log file. This will also make +analyzing the log file easier.

+
+
+

No matter whether i3 misbehaved in some way without crashing or whether it just +crashed, the logfile provides all information necessary to debug the problem.

+

To upload a compressed version of the logfile (for a bugreport), use:

+
+
+
DISPLAY=:0 i3-dump-log | bzip2 -c | curl --data-binary @- https://logs.i3wm.org
+
+

This command does not depend on i3 (it also works while i3 displays +the crash dialog), but it requires a working X11 connection.

+

After running it, you will get a URL to the logfile. Please include that URL in +your bug report.

+
+
+
+

On crashes: Obtaining a backtrace

+
+

When i3 crashes, it will display a dialog stating “i3 just crashed”, offering +you to save a backtrace to a text file.

+

To actually get useful backtraces, you should make sure that your version of i3 +is compiled with debug symbols:

+
+
+
$ file `which i3`
+/usr/bin/i3: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically
+linked (uses shared libs), for GNU/Linux 2.6.18, not stripped
+
+

Notice the not stripped, which is the important part. If you have a version +which is stripped, please check whether your distribution provides debug +symbols (package i3-wm-dbg on Debian for example) or if you can turn off +stripping. If nothing helps, please build i3 from source.

+

Once you have made sure that your i3 is compiled with debug symbols and the C +debugger gdb is installed on your machine, you can let i3 generate a +backtrace in the crash dialog.

+

After pressing "b" in the crash dialog, you will get a file called +/tmp/i3-backtrace.%d.%d.txt where the first %d is replaced by i3’s process +id (PID) and the second one is incremented each time you generate a backtrace, +starting at 0.

+

In Linux, if the backtrace just says No stack., that’s because gdb does not +have necessary permissions to attach to a running process. You can fix that by +running from a terminal (you can open a new tty, e.g. with ctrl-alt-F2):

+
+
+
echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
+
+

Afterwards, try re-generating the stack trace. Note that this setting re-sets +after reboot, see more info at +https://www.kernel.org/doc/Documentation/security/Yama.txt.

+
+
+
+

Debugging i3bar

+
+

To debug i3bar problems, use the --verbose commandline parameter, +or add verbose yes to all bar {} blocks in your i3 +config, reload your config and then restart all i3bar instances like this:

+
+
+
$ i3 reload
+$ killall i3bar
+$ for c in $(i3-msg -t get_bar_config | python -c \
+      'import json,sys;print("\n".join(json.load(sys.stdin)))'); do \
+    (i3bar --bar_id=$c >i3bar.$c.log 2>&1) & \
+  done;
+
+

There will now be i3bar.*.log files in your current directory that you can provide +in your bug report.

+
+
+
+
+ + + diff --git a/docs/gaps1920.png b/docs/gaps1920.png new file mode 100644 index 0000000..21ff927 Binary files /dev/null and b/docs/gaps1920.png differ diff --git a/docs/hacking-howto.html b/docs/hacking-howto.html new file mode 100644 index 0000000..000aabf --- /dev/null +++ b/docs/hacking-howto.html @@ -0,0 +1,1541 @@ + + + + + + +i3: Hacking i3: How To + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+
+

This document is intended to be the first thing you read before looking and/or +touching i3’s source code. It should contain all important information to help +you understand why things are like they are. If it does not mention something +you find necessary, please do not hesitate to contact me.

+
+WARNING! +

+

This document is not 100% up to date. Specifically, everything up to and +including [startup] has been updated recently. The rest might contain +outdated information.

+

+
+
+
+
+

Building i3

+
+

You can build i3 like you build any other software package which uses +The Meson Build system; see +Quickstart +Guide → Compiling a Meson project. In case you’re unfamiliar:

+
+
+
mkdir -p build
+meson setup build
+meson compile -C build
+
+
+

Build system features

+
    +
  • +

    +ninja test runs the i3 testsuite. See docs/testsuite for details. +

    +
    • +
  • +

    +meson dist builds a release tarball and runs tests on the result. +

    +
    • +
  • +

    +meson -Ddocs=true -Dmans=true will enable the options to build docs and + manpages. These options require additional dependencies that are normally not + required for users who just want to build i3. +

    +
    • +
  • +

    +meson -Db_sanitize=address will enable the address sanitizer which is + disabled by default. A summary of memory leaks will be printed on program + exit. This can include false-positives. For other options of the b_sanitize + flag see https://mesonbuild.com/Builtin-options.html. +

    +
    • +
+
+
+
+
+

Pull requests

+
+

Please talk to us before working on new features to see whether they will be +accepted. A good way for this is to open an issue and asking for opinions on it. +Even for accepted features, this can be a good way to refine an idea upfront. +However, we don’t want to see certain features in i3, e.g., switching window +focus in an Alt+Tab like way.

+

When working on bugfixes, please make sure you mention that you are working on it +in the corresponding bug report at https://github.com/i3/i3/issues. In case there +is no bug report yet, please create one.

+

After you are done, please submit your work for review as a pull request at +https://github.com/i3/i3. In order to make your review go as fast as possible, +you could have a look at previous reviews and see what the common mistakes are.

+
+

Which branch to use?

+

Work on i3 generally happens in two branches: “next” (default) and “stable”.

+

The contents of “stable” are always stable. That is, it contains the source code +of the latest release, plus any bugfixes that were applied since that release.

+

New features are only found in the “next” branch. Always use this branch when +writing new code (both bugfixes and features).

+
+
+
+
+

Window Managers

+
+

A window manager is not necessarily needed to run X, but it is usually used in +combination with X to facilitate some things. The window manager’s job is to +take care of the placement of windows, to provide the user with some mechanisms +to change the position/size of windows and to communicate with clients to a +certain extent (for example handle fullscreen requests of clients such as +MPlayer).

+

There are no different contexts in which X11 clients run, so a window manager +is just another client, like all other X11 applications. However, it handles +some events which normal clients usually don’t handle.

+

In the case of i3, the tasks (and order of them) are the following:

+
    +
  1. +

    +Grab the key bindings (events will be sent upon keypress/keyrelease) +

    +
    2. +
  2. +

    +Iterate through all existing windows (if the window manager is not started as + the first client of X) and manage them (reparent them, create window + decorations, etc.) +

    +
    3. +
  3. +

    +When new windows are created, manage them +

    +
    4. +
  4. +

    +Handle the client’s _WM_STATE property, but only _WM_STATE_FULLSCREEN and + _NET_WM_STATE_DEMANDS_ATTENTION +

    +
    5. +
  5. +

    +Handle the client’s WM_NAME property +

    +
    6. +
  6. +

    +Handle the client’s size hints to display them proportionally +

    +
    7. +
  7. +

    +Handle the client’s urgency hint +

    +
    8. +
  8. +

    +Handle enter notifications (focus follows mouse) +

    +
    9. +
  9. +

    +Handle button (as in mouse buttons) presses for focus/raise on click +

    +
    10. +
  10. +

    +Handle expose events to re-draw own windows such as decorations +

    +
    11. +
  11. +

    +React to the user’s commands: Change focus, Move windows, Switch workspaces, + Change the layout mode of a container (default/stacking/tabbed), start a new + application, restart the window manager +

    +
    12. +
+

In the following chapters, each of these tasks and their implementation details +will be discussed.

+
+

Tiling window managers

+

Traditionally, there are two approaches to managing windows: The most common one +nowadays is stacking (or floating, using i3’s terminology), which means the user +can freely move/resize the windows, potentially overlapping them. The other +approach is called tiling, which means that the window manager distributes +windows to use as much space as possible while not overlapping each other.

+

The idea behind tiling is that you should not need to waste your time +moving/resizing windows while you usually want to get some work done. After +all, most users sooner or later tend to lay out their windows in a way which +corresponds to tiling or stacking mode in i3. Therefore, why not let i3 do this +for you? Certainly, it’s faster than you could ever do it.

+

The problem with most tiling window managers is that they are too inflexible. +In my opinion, a window manager is just another tool, and similar to vim which +can edit all kinds of text files (like source code, HTML, …) and is not limited +to a specific file type, a window manager should not limit itself to a certain +layout (like dwm, awesome, …) but provide mechanisms for you to easily create +the layout you need at the moment.

+
+
+

The layout tree

+

The data structure which i3 uses to keep track of your windows is a tree. Every +node in the tree is a container (type Con). Some containers represent actual +windows (every container with a window != NULL), some represent split +containers and a few have special purposes: they represent workspaces, outputs +(like VGA1, LVDS1, …) or the X11 root window.

+

So, when you open a terminal and immediately open another one, they reside in +the same split container, which uses the default layout. In case of an empty +workspace, the split container we are talking about is the workspace.

+

To get an impression of how different layouts are represented, just play around +and look at the data structures — they are exposed as a JSON hash. See +https://i3wm.org/docs/ipc.html#_tree_reply for documentation on that and an +example.

+
+
+
+
+

Files

+
+

i3’s source code is in the src folder while header files reside in include. +Other tools such as i3bar and i3-nagbar have their own folders. i3 and its tools +share an internal library called “libi3” which also has its own folder.

+

The following list gives an overview of the codebase, explaining the +functionality of the most important, core source code files. Other files in the +tree that are not mentioned here implement specific functionalities: for example, +src/scratchpad.c is obviously about the scratchpad functionality.

+
+
+include/data.h +
+
+

+Contains data definitions used by nearly all files. +

+
+
+include/*.h +
+
+

+Contains forward definitions for all public functions, as well as +doxygen-compatible comments (so if you want to get a bit more of the big +picture, either browse all header files or use doxygen if you prefer that). +

+
+
+src/config_directives.c +
+
+src/commands.c +
+
+

+Contain the definitions for all high-level config and command directives. These +are excellent places to start with a top-to-bottom approach to understand +specific i3 behavior. For example, if you want to investigate a bug that happens +for the move to mark command, you can use gdb to pause in +cmd_move_con_to_mark and then work your way from there, stepping into +lower-level functions. +

+
+
+src/con.c +
+
+

+Contains all functions which deal with containers directly (creating containers, +searching containers, getting specific properties from containers, …). Contains +abstractions and auxiliary functions necessary to work with the container +structure which is used in almost all parts of the codebase. +

+
+
+src/tree.c +
+
+

+Contains functions which deal with the tree abstraction. However, be aware that +src/con.c also contains functions that heavily interact with the tree +structure. Some functions that are included in str/tree.c are those that handle +opening and closing containers in the tree, finding the container that should be +focused next and flattening the tree. See also src/move.c for other +move-specific functions that interact with the tree, which were moved into their +own file because they are so long. +

+
+
+src/workspace.c +
+
+

+Contains functions which deal with workspaces. Includes code that creates new +workspaces, shows existing ones and deals with workspace assignments. +

+
+
+src/handlers.c +
+
+

+Contains all handlers for all kinds of X events (new window title, new hints, +unmapping, key presses, button presses, …). This is a very important file to +understand how i3 interacts with changes to its environment. +

+
+
+src/command_parser.c +
+
+src/config_parser.c +
+
+

+Contain a hand-written parser to parse commands and configuration (commands are what +you bind on keys and what you can send to i3 using the IPC interface, like +move left or workspace 4). src/config.c is responsible for calling the +configuration parser. +

+
+
+src/click.c +
+
+src/resize.c +
+
+

+Contain functions which handle mouse button clicks (right mouse button +clicks initiate resizing and thus are relatively complex). +

+
+
+src/manage.c +
+
+

+Looks at existing or new windows and decides whether to manage them. If so, it +reparents the window and inserts it into our data structures. +

+
+
+src/match.c +
+
+

+A "match" is a data structure which acts like a mask or expression to match +certain windows or not. For example, when using commands, you can specify a +command like this: [title="Firefox"] kill. The title member of the match +data structure will then be filled and i3 will check each window using +match_matches_window() to find the windows affected by this command. +

+
+
+src/randr.c +
+
+

+The RandR API is used to get (and re-query) the configured outputs (monitors, +…). Legacy Xinerama support resides in src/xinerama.c. +

+
+
+src/render.c +
+
+

+Renders the tree data structure by assigning coordinates to every node. These +values will later be pushed to X11 in src/x.c. +

+
+
+src/sighandler.c +
+
+

+Handles SIGSEGV, SIGABRT and SIGFPE by showing a dialog that i3 crashed. +You can choose to let it dump core and restart i3 in-place (either trying to +preserve layout or forget about it). +

+
+
+src/window.c +
+
+

+Handlers to update X11 window properties like WM_CLASS, _NET_WM_NAME, +CLIENT_LEADER, etc. +

+
+
+include/.xmacro. +
+
+

+A file containing all X11 atoms which i3 uses. This file will be included +various times (for defining, requesting and receiving the atoms), each time +with a different definition of xmacro(). +

+
+
+
+
+
+

Data structures

+
+

See include/data.h for documented data structures. The most important ones are +explained here.

+

The following picture is generated by the contrib/dump-asy.pl script.

+

+ +The Big Picture + +

+

The hierarchy is:

+
    +
  1. +

    +Root container +

    +
    2. +
  2. +

    +Output containers: eDP-1 in this example and the internal __i3+ output +

    +
    3. +
  3. +

    +Content and 2 dockarea containers +

    +
    4. +
  4. +

    +Workspaces: Numbered workspace “1” and a “Named workspace” +

    +
    5. +
  5. +

    +Split containers: One horizontal in the first workspace and a tabbed one in + the named one. +

    +
    6. +
  6. +

    +Leaf containers: Windows like vim and an i3bar dock. +

    +
    7. +
+

The data type is Con, in all cases.

+
+

Root container

+

The root container (global variable croot) is the up-most ascendant of every i3 +container. It can be used to iterate over the whole tree structure. E.g., it is +used to reply to the GET_WORKSPACES request, iterating over it’s children to +find all workspaces. This is different from the X11 root window.

+

The X11 root window (global variable root) is a single window per X11 display +(a display is identified by :0 or :1 etc.). The root window is what you draw +your background image on. It spans all the available outputs, e.g. VGA1 is a +specific part of the root window and LVDS1 is a specific part of the root +window.

+
+
+

Output container

+

Every active output obtained through RandR is represented by one output +container. Outputs are considered active when a mode is configured (meaning +something is actually displayed on the output) and the output is not a clone.

+

For example, if your notebook has a screen resolution of 1280x800 px and you +connect a video projector with a resolution of 1024x768 px, set it up in clone +mode (xrandr --output VGA1 --mode 1024x768 --same-as LVDS1), i3 will +reduce the resolution to the lowest common resolution and disable one of the +cloned outputs afterwards.

+

However, if you configure it using xrandr --output VGA1 --mode 1024x768 +--right-of LVDS1, i3 will set both outputs active. For each output, a new +workspace will be assigned. New workspaces are created on the output you are +currently on.

+
+
+

Content container

+

Each output has multiple children. Two of them are dock containers which hold +the top and bottom dock clients. The other one is the content container, which +holds the actual content (workspaces) of this output.

+
+
+

Workspace

+

A workspace is identified by its name. Basically, you could think of +workspaces as different desks in your office, if you like the desktop +metaphor. They just contain different sets of windows and are completely +separate of each other. Other window managers also call this “Virtual +desktops”.

+
+
+

Split container

+

A split container is a container which holds an arbitrary amount of split +containers or X11 window containers. It has an orientation (horizontal or +vertical) and a layout.

+

Split containers (and X11 window containers, which are a subtype of split +containers) can have different border styles.

+
+
+

Leaf containers

+

A leaf container holds exactly one X11 window. They can’t have any children.

+
+
+
+
+

List/queue macros

+
+

i3 makes heavy use of the list macros defined in BSD operating systems. To +ensure that the operating system on which i3 is compiled has all the expected +features, i3 comes with include/queue.h. On BSD systems, you can use man +queue(3). On Linux, you have to use google (or read the source).

+

The lists used are SLIST (single linked lists), CIRCLEQ (circular queues) +and TAILQ (tail queues). Usually, TAILQ is used which allows inserting +elements at arbitrary positions or at the end of the list. If only forward +traversal is necessary, an SLIST can be used. CIRCLEQ is used just to +manage the X11 state of each window.

+
+
+
+

Startup (src/main.c, main())

+
+

Among other things, the main() function does the following:

+
    +
  • +

    +Establish the xcb connection +

    +
    • +
  • +

    +Load the i3 config +

    +
    • +
  • +

    +Check for XKB extension on the separate X connection, load Xcursor +

    +
    • +
  • +

    +Set up EWMH hints +

    +
    • +
  • +

    +Grab the keycodes for which bindings exist +

    +
    • +
  • +

    +Check for XRandR screens +

    +
    • +
  • +

    +Manage all existing windows +

    +
    • +
  • +

    +Exec configured startup processes +

    +
    • +
  • +

    +Start i3bar if configured +

    +
    • +
  • +

    +Enter the event loop +

    +
    • +
+
+
+
+

Keybindings

+
+
+

Grabbing the bindings

+

Grabbing the bindings is quite straight-forward. You pass X your combination of +modifiers and the keycode you want to grab and whether you want to grab them +actively or passively. Most bindings (everything except for bindings using +Mode_switch) are grabbed passively, that is, just the window manager gets the +event and cannot replay it.

+

We need to grab bindings that use Mode_switch actively because of a bug in X. +When the window manager receives the keypress/keyrelease event for an actively +grabbed keycode, it has to decide what to do with this event: It can either +replay it so that other applications get it or it can prevent other +applications from receiving it.

+

So, why do we need to grab keycodes actively? Because X does not set the +state-property of keypress/keyrelease events properly. The Mode_switch bit is +not set and we need to get it using XkbGetState. This means we cannot pass X +our combination of modifiers containing Mode_switch when grabbing the key and +therefore need to grab the keycode itself without any modifiers. This means, +if you bind Mode_switch + keycode 38 ("a"), i3 will grab keycode 38 ("a") and +check on each press of "a" if the Mode_switch bit is set using XKB. If yes, it +will handle the event, if not, it will replay the event.

+
+
+

Handling a keypress

+

As mentioned in "Grabbing the bindings", upon a keypress event, i3 first gets +the correct state.

+

Then, it looks through all bindings and gets the one which matches the received +event.

+

The bound command is parsed by the i3 parser, see parse_command in +src/commands_parser.c.

+
+
+
+
+

Manage windows (src/main.c, manage_window() and reparent_window())

+
+

manage_window() does some checks to decide whether the window should be +managed at all:

+
    +
  • +

    +Windows have to be mapped, that is, visible on screen +

    +
    • +
  • +

    +The override_redirect must not be set. Windows with override_redirect shall + not be managed by a window manager +

    +
    • +
+

Afterwards, i3 gets the initial geometry and reparents the window (see +reparent_window()) if it wasn’t already managed.

+

Reparenting means that for each window which is reparented, a new window, +slightly larger than the original one, is created. The original window is then +reparented to the bigger one (called "frame").

+

After reparenting, the window type (_NET_WM_WINDOW_TYPE) is checked to see +whether this window is a dock (_NET_WM_WINDOW_TYPE_DOCK), like dzen2 for +example. Docks are handled differently, they don’t have decorations and are not +assigned to a specific container. Instead, they are positioned at the bottom +or top of the screen (in the appropriate dock area containers). To get the +height which needs to be reserved for the window, the _NET_WM_STRUT_PARTIAL +property is used.

+

Furthermore, the list of assignments (to other workspaces, which may be on +other screens) is checked. If the window matches one of the user’s criteria, +it may either be put in floating mode or moved to a different workspace. If the +target workspace is not visible, the window will not be mapped.

+
+
+
+

What happens when an application is started?

+
+

i3 does not care about applications. All it notices is when new windows are +mapped (see src/handlers.c, handle_map_request()). The window is then +reparented (see section "Manage windows").

+

After reparenting the window, render_tree() is called which renders the +internal layout table. The new window has been placed in the currently focused +container and therefore the new window and the old windows (if any) need to be +moved/resized so that the currently active layout (default/stacking/tabbed mode) +is rendered correctly. To move/resize windows, a window is “configured” in +X11-speak.

+

Some applications, such as MPlayer obviously assume the window manager is +stupid and try to configure their windows by themselves. This generates an +event called configurerequest. i3 handles these events and tells the window the +size it had before the configurerequest (with the exception of not yet mapped +windows, which get configured like they want to, and floating windows, which +can reconfigure themselves).

+
+
+
+

_NET_WM_STATE

+
+

Only the _NET_WM_STATE_FULLSCREEN and _NET_WM_STATE_DEMANDS_ATTENTION atoms +are handled.

+

The former calls toggle_fullscreen() for the specific client which just +configures the client to use the whole screen on which it currently is. +Also, it is set as fullscreen_client for the i3Screen.

+

The latter is used to set, read and display urgency hints.

+
+
+
+

WM_NAME

+
+

When the WM_NAME property of a window changes, its decoration (containing the +title) is re-rendered. Note that WM_NAME is in COMPOUND_TEXT encoding which is +totally uncommon and cumbersome. Therefore, the _NET_WM_NAME atom will be used +if present.

+
+
+
+

_NET_WM_NAME

+
+

Like WM_NAME, this atom contains the title of a window. However, _NET_WM_NAME +is encoded in UTF-8. i3 will recode it to UCS-2 in order to be able to pass it +to X. Using an appropriate font (ISO-10646), you can see most special +characters (every special character contained in your font).

+
+
+
+

Size hints

+
+

Size hints specify the minimum/maximum size for a given window as well as its +aspect ratio. This is important for clients like mplayer, who only set the +aspect ratio and resize their window to be as small as possible (but only with +some video outputs, for example in Xv, while when using x11, mplayer does the +necessary centering for itself).

+

So, when an aspect ratio was specified, i3 adjusts the height of the window +until the size maintains the correct aspect ratio. For the code to do this, see +src/layout.c, function resize_client().

+
+
+
+

Rendering (src/layout.c, render_layout() and render_container())

+
+

Rendering in i3 version 4 is the step which assigns the correct sizes for +borders, decoration windows, child windows and the stacking order of all +windows. In a separate step (x_push_changes()), these changes are pushed to +X11.

+

Keep in mind that all these properties (rect, window_rect and deco_rect) +are temporary, meaning they will be overwritten by calling render_con. +Persistent position/size information is kept in geometry.

+

The entry point for every rendering operation (except for the case of moving +floating windows around) currently is tree_render() which will re-render +everything that’s necessary (for every output, only the currently displayed +workspace is rendered). This behavior is expected to change in the future, +since for a lot of updates, re-rendering everything is not actually necessary. +Focus was on getting it working correct, not getting it work very fast.

+

What tree_render() actually does is calling render_con() on the root +container and then pushing the changes to X11. The following sections talk +about the different rendering steps, in the order of "top of the tree" (root +container) to the bottom.

+
+

Rendering the root container

+

The i3 root container (con→type == CT_ROOT) represents the X11 root window. +It contains one child container for every output (like LVDS1, VGA1, …), which +is available on your computer.

+

Rendering the root will first render all tiling windows and then all floating +windows. This is necessary because a floating window can be positioned in such +a way that it is visible on two different outputs. Therefore, by first +rendering all the tiling windows (of all outputs), we make sure that floating +windows can never be obscured by tiling windows.

+

Essentially, though, this code path will just call render_con() for every +output and x_raise_con(); render_con() for every floating window.

+

In the special case of having a "global fullscreen" window (fullscreen mode +spanning all outputs), a shortcut is taken and x_raise_con(); render_con() is +only called for the global fullscreen window.

+
+
+

Rendering an output

+

Output containers (con→layout == L_OUTPUT) represent a hardware output like +LVDS1, VGA1, etc. An output container has three children (at the moment): One +content container (having workspaces as children) and the top/bottom dock area +containers.

+

The rendering happens in the function render_l_output() in the following +steps:

+
    +
  1. +

    +Find the content container (con→type == CT_CON) +

    +
    2. +
  2. +

    +Get the currently visible workspace (con_get_fullscreen_con(content, + CF_OUTPUT)). +

    +
    3. +
  3. +

    +If there is a fullscreened window on that workspace, directly render it and + return, thus ignoring the dock areas. +

    +
    4. +
  4. +

    +Sum up the space used by all the dock windows (they have a variable height + only). +

    +
    5. +
  5. +

    +Set the workspace rects (x/y/width/height) based on the position of the + output (stored in con→rect) and the usable space + (con→rect.{width,height} without the space used for dock windows). +

    +
    6. +
  6. +

    +Recursively raise and render the output’s child containers (meaning dock + area containers and the content container). +

    +
    7. +
+
+
+

Rendering a workspace or split container

+

From here on, there really is no difference anymore. All containers are of +con→type == CT_CON (whether workspace or split container) and some of them +have a con→window, meaning they represent an actual window instead of a +split container.

+
+

Default layout

+

In default layout, containers are placed horizontally or vertically next to +each other (depending on the con→orientation).

+
+
+

Stacked layout

+

In stacked layout, only the focused window is actually shown (this is achieved +by calling x_raise_con() in reverse focus order at the end of render_con()).

+

The available space for the focused window is the size of the container minus +the height of the window decoration for all windows inside this stacked +container.

+

If border style is "1pixel" or "none", no window decoration height will be +reserved (or displayed later on), unless there is more than one window inside +the stacked container.

+
+
+

Tabbed layout

+

Tabbed layout works precisely like stacked layout, but the window decoration +position/size is different: They are placed next to each other on a single line +(fixed height).

+
+
+

Dock area layout

+

This is a special case. Users cannot choose the dock area layout, but it will be +set for the dock area containers. In the dockarea layout (at the moment!), +windows will be placed above each other.

+
+
+
+

Rendering a window

+

A window’s size and position will be determined in the following way:

+
    +
  1. +

    +Subtract the border if border style is not "none" (but "normal" or "1pixel"). +

    +
    2. +
  2. +

    +Subtract the X11 border, if the window has an X11 border > 0. +

    +
    3. +
  3. +

    +Obey the aspect ratio of the window (think MPlayer). +

    +
    4. +
  4. +

    +Obey the height- and width-increments of the window (think terminal emulator + which can only be resized in one-line or one-character steps). +

    +
    5. +
+
+
+
+
+

Pushing updates to X11 / Drawing

+
+

A big problem with i3 before version 4 was that we just sent requests to X11 +anywhere in the source code. This was bad because nobody could understand the +entirety of our interaction with X11, it lead to subtle bugs and a lot of edge +cases which we had to consider all over again.

+

Therefore, since version 4, we have a single file, src/x.c, which is +responsible for repeatedly transferring parts of our tree datastructure to X11.

+

src/x.c consists of multiple parts:

+
    +
  1. +

    +The state pushing: x_push_changes(), which calls x_push_node(). +

    +
    2. +
  2. +

    +State modification functions: x_con_init, x_reinit, + x_reparent_child, x_move_win, x_con_kill, x_raise_con, x_set_name + and x_set_warp_to. +

    +
    3. +
  3. +

    +Expose event handling (drawing decorations): x_deco_recurse() and + x_draw_decoration(). +

    +
    4. +
+
+

Pushing state to X11

+

In general, the function x_push_changes should be called to push state +changes. Only when the scope of the state change is clearly defined (for +example only the title of a window) and its impact is known beforehand, one can +optimize this and call x_push_node on the appropriate con directly.

+

x_push_changes works in the following steps:

+
    +
  1. +

    +Clear the eventmask for all mapped windows. This leads to not getting + useless ConfigureNotify or EnterNotify events which are caused by our + requests. In general, we only want to handle user input. +

    +
    2. +
  2. +

    +Stack windows above each other, in reverse stack order (starting with the + most obscured/bottom window). This is relevant for floating windows which + can overlap each other, but also for tiling windows in stacked or tabbed + containers. We also update the _NET_CLIENT_LIST_STACKING hint which is + necessary for tab drag and drop in Chromium. +

    +
    3. +
  3. +

    +x_push_node will be called for the root container, recursively calling + itself for the container’s children. This function actually pushes the + state, see the next paragraph. +

    +
    4. +
  4. +

    +If the pointer needs to be warped to a different position (for example when + changing focus to a different output), it will be warped now. +

    +
    5. +
  5. +

    +The eventmask is restored for all mapped windows. +

    +
    6. +
  6. +

    +Window decorations will be rendered by calling x_deco_recurse on the root + container, which then recursively calls itself for the children. +

    +
    7. +
  7. +

    +If the input focus needs to be changed (because the user focused a different + window), it will be updated now. +

    +
    8. +
  8. +

    +x_push_node_unmaps will be called for the root container. This function + only pushes UnmapWindow requests. Separating the state pushing is necessary + to handle fullscreen windows (and workspace switches) in a smooth fashion: + The newly visible windows should be visible before the old windows are + unmapped. +

    +
    9. +
+

x_push_node works in the following steps:

+
    +
  1. +

    +Update the window’s WM_NAME, if changed (the WM_NAME is set on i3 + containers mainly for debugging purposes). +

    +
    2. +
  2. +

    +Reparents a child window into the i3 container if the container was created + for a specific managed window. +

    +
    3. +
  3. +

    +If the size/position of the i3 container changed (due to opening a new + window or switching layouts for example), the window will be reconfigured. + Also, the pixmap which is used to draw the window decoration/border on is + reconfigured (pixmaps are size-dependent). +

    +
    4. +
  4. +

    +Size/position for the child window is adjusted. +

    +
    5. +
  5. +

    +The i3 container is mapped if it should be visible and was not yet mapped. + When mapping, WM_STATE is set to WM_STATE_NORMAL. Also, the eventmask of + the child window is updated and the i3 container’s contents are copied from + the pixmap. +

    +
    6. +
  6. +

    +x_push_node is called recursively for all children of the current + container. +

    +
    7. +
+

x_push_node_unmaps handles the remaining case of an i3 container being +unmapped if it should not be visible anymore. WM_STATE will be set to +WM_STATE_WITHDRAWN.

+
+
+

Drawing window decorations/borders/backgrounds

+

x_draw_decoration draws window decorations. It is run for every leaf +container (representing an actual X11 window) and for every non-leaf container +which is in a stacked/tabbed container (because stacked/tabbed containers +display a window decoration for split containers, which consists of a representation +of the child container’s names.

+

Then, parameters are collected to be able to determine whether this decoration +drawing is actually necessary or was already done. This saves a substantial +number of redraws (depending on your workload, but far over 50%).

+

Assuming that we need to draw this decoration, we start by filling the empty +space around the child window (think of MPlayer with a specific aspect ratio) +in the user-configured client background color.

+

Afterwards, we draw the appropriate border (in case of border styles "normal" +and "1pixel") and the top bar (in case of border style "normal").

+

The last step is drawing the window title on the top bar.

+
+
+
+
+

User commands (parser-specs/commands.spec)

+
+

In the configuration file and when using i3 interactively (with i3-msg, for +example), you use commands to make i3 do things, like focus a different window, +set a window to fullscreen, and so on. An example command is floating enable, +which enables floating mode for the currently focused window. See the +appropriate section in the User’s Guide for a reference of +all commands.

+

In earlier versions of i3, interpreting these commands was done using lex and +yacc, but experience has shown that lex and yacc are not well suited for our +command language. Therefore, starting from version 4.2, we use a custom parser +for user commands and the configuration file. +The input specification for this parser can be found in the file +parser-specs/*.spec. Should you happen to use Vim as an editor, use +:source parser-specs/highlighting.vim to get syntax highlighting for this file +(highlighting files for other editors are welcome).

+
+
Excerpt from commands.spec
+
+
state INITIAL:
+  '[' -> call cmd_criteria_init(); CRITERIA
+  'move' -> MOVE
+  'exec' -> EXEC
+  'workspace' -> WORKSPACE
+  'exit' -> call cmd_exit()
+  'restart' -> call cmd_restart()
+  'reload' -> call cmd_reload()
+
+

The input specification is written in an extremely simple format. The +specification is then converted into C code by the Perl script +generate-commands-parser.pl (the output file names begin with GENERATED and the +files are stored in the include directory). The parser implementation +src/commands_parser.c includes the generated C code at compile-time.

+

The above excerpt from commands.spec illustrates nearly all features of our +specification format: You describe different states and what can happen within +each state. State names are all-caps; the state in the above excerpt is called +INITIAL. A list of tokens and their actions (separated by an ASCII arrow) +follows. In the excerpt, all tokens are literals, that is, simple text strings +which will be compared with the input. An action is either the name of a state +in which the parser will transition into, or the keyword call, followed by +the name of a function (and optionally a state).

+
+

Example: The WORKSPACE state

+

Let’s have a look at the WORKSPACE state, which is a good example of all +features. This is its definition:

+
+
WORKSPACE state (commands.spec)
+
+
# workspace next|prev|next_on_output|prev_on_output
+# workspace back_and_forth
+# workspace <name>
+# workspace number <number>
+state WORKSPACE:
+  direction = 'next_on_output', 'prev_on_output', 'next', 'prev'
+      -> call cmd_workspace($direction)
+  'back_and_forth'
+      -> call cmd_workspace_back_and_forth()
+  'number'
+      -> WORKSPACE_NUMBER
+  workspace = string
+      -> call cmd_workspace_name($workspace)
+
+

As you can see from the commands, there are multiple different valid variants +of the workspace command:

+
+
+workspace <direction> +
+
+

+ The word workspace can be followed by any of the tokens next, + prev, next_on_output or prev_on_output. This command will + switch to the next or previous workspace (optionally on the same + output).
+ There is one function called cmd_workspace, which is defined + in src/commands.c. It will handle this kind of command. To know which + direction was specified, the direction token is stored on the stack + with the name "direction", which is what the "direction = " means in + the beginning.
+

+
+
+
+ + + +
+
Note
+		Note that you can specify multiple literals in the same line. This has + exactly the same effect as if you specified direction = + next_on_output → call cmd_workspace($direction) and so forth.
+
+
+ + + +
+
Note
+		Also note that the order of literals is important here: If next were + ordered before next_on_output, then next_on_output would never + match.
+
+
+
+workspace back_and_forth +
+
+

+ This is a very simple case: When the literal back_and_forth is found + in the input, the function cmd_workspace_back_and_forth will be + called without parameters and the parser will return to the INITIAL + state (since no other state was specified). +

+
+
+workspace <name> +
+
+

+ In this case, the workspace command is followed by an arbitrary string, + possibly in quotes, for example "workspace 3" or "workspace bleh".
+ This is the first time that the token is actually not a literal (not in + single quotes), but just called string. Other possible tokens are word + (the same as string, but stops matching at a whitespace) and end + (matches the end of the input). +

+
+
+workspace number <number> +
+
+

+ The workspace command has to be followed by the keyword number. It + then transitions into the state WORKSPACE_NUMBER, where the actual + parameter will be read. +

+
+
+
+
+

Introducing a new command

+

The following steps have to be taken in order to properly introduce a new +command (or possibly extend an existing command):

+
    +
  1. +

    +Define a function beginning with cmd_ in the file src/commands.c. Copy + the prototype of an existing function. +

    +
    2. +
  2. +

    +After adding a comment on what the function does, copy the comment and + function definition to include/commands.h. Make the comment in the header + file use double asterisks to make doxygen pick it up. +

    +
    3. +
  3. +

    +Write a test case (or extend an existing test case) for your feature, see + i3 testsuite. For now, it is sufficient to simply call + your command in all the various possible ways. +

    +
    4. +
  4. +

    +Extend the parser specification in parser-specs/commands.spec. Run the + testsuite and see if your new function gets called with the appropriate + arguments for the appropriate input. +

    +
    5. +
  5. +

    +Actually implement the feature. +

    +
    6. +
  6. +

    +Document the feature in the User’s Guide. +

    +
    7. +
+
+
+
+
+

Moving containers

+
+

The movement code is pretty delicate. You need to consider all cases before +making any changes or before being able to fully understand how it works.

+
+

Case 1: Moving inside the same container

+

The reference layout for this case is a single workspace in horizontal +orientation with two containers on it. Focus is on the left container (1).

+
+ +++ + + + + + +

1

2

+
+

When moving the left window to the right (command move right), tree_move will +look for a container with horizontal orientation and finds the parent of the +left container, that is, the workspace. Afterwards, it runs the code branch +commented with "the easy case": it calls TAILQ_NEXT to get the container right +of the current one and swaps both containers.

+
+
+

Case 2: Move a container into a split container

+

The reference layout for this case is a horizontal workspace with two +containers. The right container is a v-split with two containers. Focus is on +the left container (1).

+
+ +++ + + + + + + + + +

1

2

3

+
+

When moving to the right (command move right), i3 will work like in case 1 +("the easy case"). However, as the right container is not a leaf container, but +a v-split, the left container (1) will be inserted at the right position (below +2, assuming that 2 is focused inside the v-split) by calling insert_con_into.

+

insert_con_into detaches the container from its parent and inserts it +before/after the given target container. Afterwards, the on_remove_child +callback is called on the old parent container which will then be closed, if +empty.

+

Afterwards, con_focus will be called to fix the focus stack and the tree will +be flattened.

+
+
+

Case 3: Moving to non-existent top/bottom

+

Like in case 1, the reference layout for this case is a single workspace in +horizontal orientation with two containers on it. Focus is on the left +container:

+
+ +++ + + + + + +

1

2

+
+

This time however, the command is move up or move down. tree_move will look +for a container with vertical orientation. As it will not find any, +same_orientation is NULL and therefore i3 will perform a forced orientation +change on the workspace by creating a new h-split container, moving the +workspace contents into it and then changing the workspace orientation to +vertical. Now it will again search for parent containers with vertical +orientation and it will find the workspace.

+

This time, the easy case code path will not be run as we are not moving inside +the same container. Instead, insert_con_into will be called with the focused +container and the container above/below the current one (on the level of +same_orientation).

+

Now, con_focus will be called to fix the focus stack and the tree will be +flattened.

+
+
+

Case 4: Moving to existent top/bottom

+

The reference layout for this case is a vertical workspace with two containers. +The bottom one is a h-split containing two containers (1 and 2). Focus is on +the bottom left container (1).

+
+ +++ + + + + + + + + +

3

1

2

+
+

This case is very much like case 3, only this time the forced workspace +orientation change does not need to be performed because the workspace already +is in vertical orientation.

+
+
+

Case 5: Moving in one-child h-split

+

The reference layout for this case is a horizontal workspace with two +containers having a v-split on the left side with a one-child h-split on the +bottom. Focus is on the bottom left container (2(h)):

+
+ +++ + + + + + + + + +

1

3

2(h)

+
+

In this case, same_orientation will be set to the h-split container around +the focused container. However, when trying the easy case, the next/previous +container swap will be NULL. Therefore, i3 will search again for a +same_orientation container, this time starting from the parent of the h-split +container.

+

After determining a new same_orientation container (if it is NULL, the +orientation will be force-changed), this case is equivalent to case 2 or case +4.

+
+
+

Case 6: Floating containers

+

The reference layout for this case is a horizontal workspace with two +containers plus one floating h-split container. Focus is on the floating +container.

+

TODO: nice illustration. table not possible?

+

When moving up/down, the container needs to leave the floating container and it +needs to be placed on the workspace (at workspace level). This is accomplished +by calling the function attach_to_workspace.

+
+
+
+
+

Click handling

+
+

Without much ado, here is the list of cases which need to be considered:

+
    +
  • +

    +click to focus (tiling + floating) and raise (floating) +

    +
    • +
  • +

    +click to focus/raise when in stacked/tabbed mode +

    +
    • +
  • +

    +floating_modifier + left mouse button to drag a floating con +

    +
    • +
  • +

    +floating_modifier + right mouse button to resize a floating con +

    +
    • +
  • +

    +click on decoration in a floating con to either initiate a resize (if there + is more than one child in the floating con) or to drag the + floating con (if it’s the one at the top). +

    +
    • +
  • +

    +click on border in a floating con to resize the floating con +

    +
    • +
  • +

    +floating_modifier + right mouse button to resize a tiling con +

    +
    • +
  • +

    +click on border/decoration to resize a tiling con +

    +
    • +
+
+
+
+

Gotchas

+
+
    +
  • +

    +Forgetting to call xcb_flush(conn); after sending a request. This usually + leads to code which looks like it works fine but which does not work under + certain conditions. +

    +
    • +
  • +

    +Forgetting to call floating_fix_coordinates(con, old_rect, new_rect) after + moving workspaces across outputs. Coordinates for floating containers are + not relative to workspace boundaries, so you must correct their coordinates + or those containers will show up in the wrong workspace or not at all. +

    +
    • +
+
+
+
+

Thought experiments

+
+

In this section, we collect thought experiments, so that we don’t forget our +thoughts about specific topics. They are not necessary to get into hacking i3, +but if you are interested in one of the topics they cover, you should read them +before asking us why things are the way they are or why we don’t implement +things.

+
+

Using cgroups per workspace

+

cgroups (control groups) are a linux-only feature which provides the ability to +group multiple processes. For each group, you can individually set resource +limits, like allowed memory usage. Furthermore, and more importantly for our +purposes, they serve as a namespace, a label which you can attach to processes +and their children.

+

One interesting use for cgroups is having one cgroup per workspace (or +container, doesn’t really matter). That way, you could set different priorities +and have a workspace for important stuff (say, writing a LaTeX document or +programming) and a workspace for unimportant background stuff (say, +JDownloader). Both tasks can obviously consume a lot of I/O resources, but in +this example it doesn’t really matter if JDownloader unpacks the download a +minute earlier or not. However, your compiler should work as fast as possible. +Having one cgroup per workspace, you would assign more resources to the +programming workspace.

+

Another interesting feature is that an inherent problem of the workspace +concept could be solved by using cgroups: When starting an application on +workspace 1, then switching to workspace 2, you will get the application’s +window(s) on workspace 2 instead of the one you started it on. This is because +the window manager does not have any mapping between the process it starts (or +gets started in any way) and the window(s) which appear.

+

Imagine for example using dmenu: The user starts dmenu by pressing Mod+d, dmenu +gets started with PID 3390. The user then decides to launch Firefox, which +takes a long time. So they enter firefox into dmenu and press enter. Firefox +gets started with PID 4001. When it finally finishes loading, it creates an X11 +window and uses MapWindow to make it visible. This is the first time i3 +actually gets in touch with Firefox. It decides to map the window, but it has +no way of knowing that this window (even though it has the _NET_WM_PID property +set to 4001) belongs to the dmenu the user started before.

+

How do cgroups help with this? Well, when pressing Mod+d to launch dmenu, i3 +would create a new cgroup, let’s call it i3-3390-1. It launches dmenu in that +cgroup, which gets PID 3390. As before, the user enters firefox and Firefox +gets launched with PID 4001. This time, though, the Firefox process with PID +4001 is also member of the cgroup i3-3390-1 (because fork()ing in a cgroup +retains the cgroup property). Therefore, when mapping the window, i3 can look +up in which cgroup the process is and can establish a mapping between the +workspace and the window.

+

There are multiple problems with this approach:

+
    +
  1. +

    +Every application has to properly set _NET_WM_PID. This is acceptable and + patches can be written for the few applications which don’t set the hint yet. +

    +
    2. +
  2. +

    +It does only work on Linux, since cgroups are a Linux-only feature. Again, + this is acceptable. +

    +
    3. +
  3. +

    +The main problem is that some applications create X11 windows completely + independent of UNIX processes. An example for this is Chromium (or + gnome-terminal), which, when being started a second time, communicates with + the first process and lets the first process open a new window. Therefore, if + you have a Chromium window on workspace 2 and you are currently working on + workspace 3, starting chromium does not lead to the desired result (the + window will open on workspace 2). +

    +
    4. +
+

Therefore, my conclusion is that the only proper way of fixing the "window gets +opened on the wrong workspace" problem is in the application itself. Most +modern applications support freedesktop startup-notifications which can be +used for this.

+
+
+
+
+
+ + + diff --git a/docs/i3-config-wizard.html b/docs/i3-config-wizard.html new file mode 100644 index 0000000..6b84c3e --- /dev/null +++ b/docs/i3-config-wizard.html @@ -0,0 +1,128 @@ + + + + + + +i3: i3-config-wizard(1) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+

NAME

+
+

i3-config-wizard - creates a keysym based config based on your layout

+
+
+
+

SYNOPSIS

+
+

i3-config-wizard [-s socket] [-m modifier] [-v] [-h]

+
+
+
+

OPTIONS

+
+
+
+-s, --socket socket +
+
+

+Overwrites the path to the i3 IPC socket. +

+
+
+-m, --modifier modifier +
+
+

+Generates the configuration file headlessly. Accepts win or alt. +

+
+
+-v, --version +
+
+

+Display version number and exit. +

+
+
+-h, --help +
+
+

+Display a short help message and exit. +

+
+
+
+
+
+

FILES

+
+
+

/etc/i3/config.keycodes

+

This file contains the default configuration with keycodes. All the bindcode +lines will be transformed to bindsym and the user-specified modifier will be +used.

+
+
+
+
+

DESCRIPTION

+
+

i3-config-wizard is started by i3 in its default config, unless ~/.i3/config +exists. i3-config-wizard creates a keysym based i3 config file (based on +/etc/i3/config.keycodes) in ~/.i3/config.

+

The advantage of using keysyms is that the config file is easy to read, +understand and modify. However, if we shipped with a keysym based default +config file, the key positions would not be consistent across different +keyboard layouts (take for example the homerow for movement). Therefore, we +ship with a keycode based default config and let the wizard transform it +according to your current keyboard layout.

+
+
+
+

SEE ALSO

+
+

i3(1)

+
+
+
+

AUTHOR

+
+

Michael Stapelberg and contributors

+
+
+
+
+ + + diff --git a/docs/i3-dump-log.html b/docs/i3-dump-log.html new file mode 100644 index 0000000..7661fbb --- /dev/null +++ b/docs/i3-dump-log.html @@ -0,0 +1,81 @@ + + + + + + +i3: i3-dump-log(1) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+

NAME

+
+

i3-dump-log - dumps the i3 SHM log

+
+
+
+

SYNOPSIS

+
+

i3-dump-log [-s <socketpath>] [-f]

+
+
+
+

DESCRIPTION

+
+

Debug versions of i3 automatically use 1% of your RAM (but 25 MiB max) to store +full debug log output. This is extremely helpful for bugreports and +figuring out what is going on, without permanently logging to a file.

+

With i3-dump-log, you can dump the SHM log to stdout.

+

The -f flag works like tail -f, i.e. the process does not terminate after +dumping the log, but prints new lines as they appear.

+
+
+
+

EXAMPLE

+
+

i3-dump-log | gzip -9 > /tmp/i3-log.gz

+
+
+
+

SEE ALSO

+
+

i3(1)

+
+
+
+

AUTHOR

+
+

Michael Stapelberg and contributors

+
+
+
+
+ + + diff --git a/docs/i3-input.html b/docs/i3-input.html new file mode 100644 index 0000000..3ce65f6 --- /dev/null +++ b/docs/i3-input.html @@ -0,0 +1,181 @@ + + + + + + +i3: i3-input(1) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+

NAME

+
+

i3-input - interactively take a command for i3 window manager

+
+
+
+

SYNOPSIS

+
+

i3-input [-s <socket>] [-F <format>] [-l <limit>] [-P <prompt>] [-f <font>] [-v]

+
+
+
+

DESCRIPTION

+
+

i3-input is a tool to take commands (or parts of a command) composed by +the user, and send it/them to i3. This is useful, for example, for the +mark/goto command.

+

You can press Escape to close i3-input without sending any commands.

+
+
+
+

OPTIONS

+
+
+
+-s <socket> +
+
+

+Specify the path to the i3 IPC socket (it should not be necessary to use this +option, i3-input will figure out the path on its own). +

+
+
+-F <format> +
+
+

+Every occurrence of "%s" in the <format> string is replaced by the user input, +and the result is sent to i3 as a command. Default value is "%s". +

+
+
+-l <limit> +
+
+

+Set the maximum allowed length of the user input to <limit> characters. +i3-input will automatically issue the command when the user input reaches that +length. +

+
+
+-P <prompt> +
+
+

+Display the <prompt> string in front of user input text field. +The prompt string is not included in the user input/command. +

+
+
+-f <font> +
+
+

+Use the specified X11 core font (use xfontsel to choose a font). +

+
+
+-v +
+
+

+Show version and exit. +

+
+
+
+
+
+

EXAMPLES

+
+

Mark a container with a single character:

+
+
+
i3-input -F 'mark %s' -l 1 -P 'Mark: '
+
+

Go to the container marked with above example:

+
+
+
i3-input -F '[con_mark="%s"] focus' -l 1 -P 'Go to: '
+
+
+
+
+

ENVIRONMENT

+
+
+

I3SOCK

+

i3-input handles the different sources of socket paths in the following order:

+
    +
  • +

    +I3SOCK environment variable +

    +
    • +
  • +

    +I3SOCK gets overwritten by the -s parameter, if specified +

    +
    • +
  • +

    +if neither are available, i3-input reads the socket path from the X11 + property, which is the recommended way +

    +
    • +
  • +

    +if everything fails, i3-input tries /tmp/i3-ipc.sock +

    +
    • +
+

The socket path is necessary to connect to i3 and actually issue the command.

+
+
+
+
+

SEE ALSO

+
+

i3(1)

+
+
+
+

AUTHOR

+
+

Michael Stapelberg and contributors

+
+
+
+
+ + + diff --git a/docs/i3-migrate-config-to-v4.html b/docs/i3-migrate-config-to-v4.html new file mode 100644 index 0000000..c415a87 --- /dev/null +++ b/docs/i3-migrate-config-to-v4.html @@ -0,0 +1,80 @@ + + + + + + +i3: i3-migrate-config-to-v4(1) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+

NAME

+
+

i3-migrate-config-to-v4 - migrates your i3 config file

+
+
+
+

SYNOPSIS

+
+
+
+
mv ~/.i3/config ~/.i3/old.config
+i3-migrate-config-to-v4 ~/.i3/old.config > ~/.i3/config
+
+
+
+
+

DESCRIPTION

+
+

i3-migrate-config-to-v4 is a Perl script which migrates your old (< version 4) +configuration files to a version 4 config file. The most significant changes +are the new commands (see the release notes).

+

This script will automatically be run by i3 when it detects an old config file. +Please migrate your config file as soon as possible. We plan to include this +script in all i3 release until 2012-08-01. Afterwards, old config files will no +longer be supported.

+
+
+
+

SEE ALSO

+
+

i3(1)

+
+
+
+

AUTHOR

+
+

Michael Stapelberg and contributors

+
+
+
+
+ + + diff --git a/docs/i3-msg.html b/docs/i3-msg.html new file mode 100644 index 0000000..6d62cf0 --- /dev/null +++ b/docs/i3-msg.html @@ -0,0 +1,293 @@ + + + + + + +i3: i3-msg(1) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+

NAME

+
+

i3-msg - send messages to i3 window manager

+
+
+
+

SYNOPSIS

+
+

i3-msg [-q] [-v] [-h] [-s socket] [-t type] [-r] [message]

+
+
+
+

OPTIONS

+
+
+
+-q, --quiet +
+
+

+Only send ipc message and suppress the output of the response. +

+
+
+-v, --version +
+
+

+Display version number and exit. +

+
+
+-h, --help +
+
+

+Display a short help-message and exit. +

+
+
+-s, --socket sock_path +
+
+

+i3-msg will use the environment variable I3SOCK or the socket path +given here. If both fail, it will try to get the socket information +from the root window and then try /tmp/i3-ipc.sock before exiting +with an error. +

+
+
+-t type +
+
+

+Send ipc message, see below. This option defaults to "command". +

+
+
+-m, --monitor +
+
+

+Instead of exiting right after receiving the first subscribed event, +wait indefinitely for all of them. Can only be used with "-t subscribe". +See the "subscribe" IPC message type below for details. +

+
+
+-r, --raw +
+
+

+Display the raw JSON reply instead of pretty-printing errors (for commands) or +displaying the top-level config file contents (for GET_CONFIG). +

+
+
+message +
+
+

+Send ipc message, see below. +

+
+
+
+
+
+

IPC MESSAGE TYPES

+
+
+
+command +
+
+

+The payload of the message is a command for i3 (like the commands you can bind +to keys in the configuration file) and will be executed directly after +receiving it. +

+
+
+get_workspaces +
+
+

+Gets the current workspaces. The reply will be a JSON-encoded list of +workspaces. +

+
+
+get_outputs +
+
+

+Gets the current outputs. The reply will be a JSON-encoded list of outputs (see +the reply section of docs/ipc, e.g. at +https://i3wm.org/docs/ipc.html#_receiving_replies_from_i3). +

+
+
+get_tree +
+
+

+Gets the layout tree. i3 uses a tree as data structure which includes every +container. The reply will be the JSON-encoded tree. +

+
+
+get_marks +
+
+

+Gets a list of marks (identifiers for containers to easily jump to them later). +The reply will be a JSON-encoded list of window marks. +

+
+
+get_bar_config +
+
+

+Gets the configuration (as JSON map) of the workspace bar with the given ID. If +no ID is provided, an array with all configured bar IDs is returned instead. +

+
+
+get_binding_modes +
+
+

+Gets a list of configured binding modes. +

+
+
+get_version +
+
+

+Gets the version of i3. The reply will be a JSON-encoded dictionary with the +major, minor, patch and human-readable version. +

+
+
+get_config +
+
+

+Gets the currently loaded i3 configuration. +

+
+
+send_tick +
+
+

+Sends a tick to all IPC connections which subscribe to tick events. +

+
+
+subscribe +
+
+

+The payload of the message describes the events to subscribe to. +Upon reception, each event will be dumped as a JSON-encoded object. +See the -m option for continuous monitoring. +

+
+
+
+
+
+

DESCRIPTION

+
+

i3-msg is a sample implementation for a client using the unix socket IPC +interface to i3.

+
+

Exit status:

+

0: +if OK, +1: +if invalid syntax or unable to connect to ipc-socket +2: +if i3 returned an error processing your command(s)

+
+
+
+
+

EXAMPLES

+
+
+
+
# Use 1-px border for current client
+i3-msg "border 1pixel"
+
+# You can leave out the quotes
+i3-msg border normal
+
+# Dump the layout tree
+i3-msg -t get_tree
+
+# Monitor window changes
+i3-msg -t subscribe -m '[ "window" ]'
+
+
+
+
+

ENVIRONMENT

+
+
+

I3SOCK

+

If no ipc-socket is specified on the commandline, this variable is used +to determine the path, at which the unix domain socket is expected, on which +to connect to i3.

+
+
+
+
+

SEE ALSO

+
+

i3(1)

+
+
+
+

AUTHOR

+
+

Michael Stapelberg and contributors

+
+
+
+
+ + + diff --git a/docs/i3-nagbar.html b/docs/i3-nagbar.html new file mode 100644 index 0000000..a38ac26 --- /dev/null +++ b/docs/i3-nagbar.html @@ -0,0 +1,160 @@ + + + + + + +i3: i3-nagbar(1) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+

NAME

+
+

i3-nagbar - displays an error bar on top of your screen

+
+
+
+

SYNOPSIS

+
+

i3-nagbar [-m <message>] [-b <button> <action>] [-B <button> <action>] [-t warning|error] [-f <font>] [-v] [-p]

+
+
+
+

OPTIONS

+
+
+
+-v, --version +
+
+

+Display version number and exit. +

+
+
+-h, --help +
+
+

+Display a short help-message and exit. +

+
+
+-t, --type type +
+
+

+Display either a warning or error message. This only changes the color scheme +for the i3-nagbar. Default: error. +

+
+
+-m, --message message +
+
+

+Display message as text on the left of the i3-nagbar. +

+
+
+-f, --font font +
+
+

+Select font that is being used. +

+
+
+-b, --button button action +
+
+

+Create a button with text button. The action are the shell commands that +will be executed by this button. Multiple buttons can be defined. +Will launch the shell commands inside a terminal emulator, using +i3-sensible-terminal. +

+
+
+-B, --button-no-terminal button action +
+
+

+Same as above, but will execute the shell commands directly, without launching a +terminal emulator. +

+
+
+-p, --primary +
+
+

+Always opens the i3-nagbar on the primary monitor. By default it opens on the +focused monitor. +

+
+
+
+
+
+

DESCRIPTION

+
+

i3-nagbar is used by i3 to tell you about errors in your configuration file +(for example). While these errors are logged to the logfile (if any), the past +has proven that users are either not aware of their logfile or do not check it +after modifying the configuration file.

+
+
+
+

EXAMPLE

+
+
+
+
i3-nagbar -m 'You have an error in your i3 config file!' \
+-b 'edit config' 'i3-sensible-editor ~/.config/i3/config'
+
+
+
+
+

SEE ALSO

+
+

i3(1)

+
+
+
+

AUTHOR

+
+

Michael Stapelberg and contributors

+
+
+
+
+ + + diff --git a/docs/i3-sensible-editor.html b/docs/i3-sensible-editor.html new file mode 100644 index 0000000..6681695 --- /dev/null +++ b/docs/i3-sensible-editor.html @@ -0,0 +1,145 @@ + + + + + + +i3: i3-sensible-editor(1) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+

NAME

+
+

i3-sensible-editor - launches $EDITOR with fallbacks

+
+
+
+

SYNOPSIS

+
+

i3-sensible-editor [arguments]

+
+
+
+

DESCRIPTION

+
+

i3-sensible-editor is used by i3-nagbar(1) when you click on the edit button.

+

It tries to start one of the following (in that order):

+
    +
  • +

    +$VISUAL +

    +
    • +
  • +

    +$EDITOR +

    +
    • +
  • +

    +nano +

    +
    • +
  • +

    +nvim +

    +
    • +
  • +

    +vim +

    +
    • +
  • +

    +vi +

    +
    • +
  • +

    +emacs +

    +
    • +
  • +

    +pico +

    +
    • +
  • +

    +qe +

    +
    • +
  • +

    +mg +

    +
    • +
  • +

    +jed +

    +
    • +
  • +

    +gedit +

    +
    • +
  • +

    +mcedit +

    +
    • +
  • +

    +gvim +

    +
    • +
+

Please don’t complain about the order: If the user has any preference, they will +have $VISUAL or $EDITOR set.

+
+
+
+

SEE ALSO

+
+

i3(1)

+
+
+
+

AUTHOR

+
+

Michael Stapelberg and contributors

+
+
+
+
+ + + diff --git a/docs/i3-sensible-pager.html b/docs/i3-sensible-pager.html new file mode 100644 index 0000000..24d102b --- /dev/null +++ b/docs/i3-sensible-pager.html @@ -0,0 +1,100 @@ + + + + + + +i3: i3-sensible-pager(1) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+

NAME

+
+

i3-sensible-pager - launches $PAGER with fallbacks

+
+
+
+

SYNOPSIS

+
+

i3-sensible-pager [arguments]

+
+
+
+

DESCRIPTION

+
+

i3-sensible-pager is used by i3-nagbar(1) when you click on the view button.

+

It tries to start one of the following (in that order):

+
    +
  • +

    +$PAGER +

    +
    • +
  • +

    +less +

    +
    • +
  • +

    +most +

    +
    • +
  • +

    +w3m +

    +
    • +
  • +

    +i3-sensible-editor(1) +

    +
    • +
+

Please don’t complain about the order: If the user has any preference, they will +have $PAGER set.

+
+
+
+

SEE ALSO

+
+

i3(1)

+
+
+
+

AUTHOR

+
+

Michael Stapelberg and contributors

+
+
+
+
+ + + diff --git a/docs/i3-sensible-terminal.html b/docs/i3-sensible-terminal.html new file mode 100644 index 0000000..6643a08 --- /dev/null +++ b/docs/i3-sensible-terminal.html @@ -0,0 +1,219 @@ + + + + + + +i3: i3-sensible-terminal(1) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+

NAME

+
+

i3-sensible-terminal - launches $TERMINAL with fallbacks

+
+
+
+

SYNOPSIS

+
+

i3-sensible-terminal [arguments]

+
+
+
+

DESCRIPTION

+
+

i3-sensible-terminal is invoked in the i3 default config to start a terminal. +This wrapper script is necessary since there is no distribution-independent +terminal launcher (but for example Debian has x-terminal-emulator). +Distribution packagers are responsible for shipping this script in a way which +is appropriate for the distribution.

+

It tries to start one of the following (in that order):

+
    +
  • +

    +$TERMINAL (this is a non-standard variable) +

    +
    • +
  • +

    +x-terminal-emulator (only present on Debian and derivatives) +

    +
    • +
  • +

    +mate-terminal +

    +
    • +
  • +

    +gnome-terminal +

    +
    • +
  • +

    +terminator +

    +
    • +
  • +

    +xfce4-terminal +

    +
    • +
  • +

    +urxvt +

    +
    • +
  • +

    +rxvt +

    +
    • +
  • +

    +termit +

    +
    • +
  • +

    +Eterm +

    +
    • +
  • +

    +aterm +

    +
    • +
  • +

    +uxterm +

    +
    • +
  • +

    +xterm +

    +
    • +
  • +

    +roxterm +

    +
    • +
  • +

    +termite +

    +
    • +
  • +

    +lxterminal +

    +
    • +
  • +

    +terminology +

    +
    • +
  • +

    +st +

    +
    • +
  • +

    +qterminal +

    +
    • +
  • +

    +lilyterm +

    +
    • +
  • +

    +tilix +

    +
    • +
  • +

    +terminix +

    +
    • +
  • +

    +konsole +

    +
    • +
  • +

    +kitty +

    +
    • +
  • +

    +guake +

    +
    • +
  • +

    +tilda +

    +
    • +
  • +

    +alacritty +

    +
    • +
  • +

    +hyper +

    +
    • +
+

Please don’t complain about the order: If the user has any preference, they will +have $TERMINAL set or modified their i3 configuration file.

+
+
+
+

SEE ALSO

+
+

i3(1)

+
+
+
+

AUTHOR

+
+

Michael Stapelberg and contributors

+
+
+
+
+ + + diff --git a/docs/i3-sync-working.png b/docs/i3-sync-working.png new file mode 100644 index 0000000..419334d Binary files /dev/null and b/docs/i3-sync-working.png differ diff --git a/docs/i3-sync.png b/docs/i3-sync.png new file mode 100644 index 0000000..c9a5a01 Binary files /dev/null and b/docs/i3-sync.png differ diff --git a/docs/i3.html b/docs/i3.html new file mode 100644 index 0000000..aedaebf --- /dev/null +++ b/docs/i3.html @@ -0,0 +1,581 @@ + + + + + + +i3: i3(1) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+

NAME

+
+

i3 - an improved dynamic, tiling window manager

+
+
+
+

SYNOPSIS

+
+

i3 [-a] [-c configfile] [-C] [-d all] [-v] [-V]

+
+
+
+

OPTIONS

+
+
+
+-a +
+
+

+Disables autostart. +

+
+
+-c +
+
+

+Specifies an alternate configuration file path. +

+
+
+-C +
+
+

+Check the configuration file for validity and exit. +

+
+
+-d all +
+
+

+Enables debug logging. +The all parameter is present for historical reasons. +

+
+
+-v +
+
+

+Display version number (and date of the last commit). +

+
+
+-V +
+
+

+Be verbose. +

+
+
+--force-xinerama +
+
+

+Use Xinerama instead of RandR. This option should only be used if you are stuck +with the old nVidia closed source driver (older than 302.17) which does not +support RandR. +

+
+
+--get-socketpath +
+
+

+Retrieve the i3 IPC socket path from X11, print it, then exit. +

+
+
+--shmlog-size <limit> +
+
+

+Limits the size of the i3 SHM log to <limit> bytes. Setting this to 0 disables +SHM logging entirely. The default is 0 bytes. +

+
+
+--replace +
+
+

+Replace an existing window manager. +

+
+
+
+
+
+

DESCRIPTION

+
+
+

INTRODUCTION

+

i3 was created because wmii, our favorite window manager at the time, didn’t +provide some features we wanted (multi-monitor done right, for example), had +some bugs, didn’t progress since quite some time and wasn’t easy to hack at all +(source code comments/documentation completely lacking). Still, we think the +wmii developers and contributors did a great job. Thank you for inspiring us to +create i3.

+

Please be aware that i3 is primarily targeted at advanced users and developers.

+
+
+

IMPORTANT NOTE TO nVidia BINARY DRIVER USERS

+

If you are using the nVidia binary graphics driver (also known as blob) +before version 302.17, you need to use the --force-xinerama flag (in your +~/.xsession) when starting i3, like so:

+
+
+
exec i3 --force-xinerama -V >>~/.i3/i3log 2>&1
+
+

See also docs/multi-monitor for the full explanation.

+
+
+

TERMINOLOGY

+
+
+Tree +
+
+

+i3 keeps your layout in a tree data structure. +

+
+
+Window +
+
+

+An X11 window, like the Firefox browser window or a terminal emulator. +

+
+
+Floating Window +
+
+

+A window which "floats" on top of other windows. This style is used by i3 to +display X11 windows with type "dialog", such as the "Print" or "Open File" +dialog boxes in many GUI applications. Use of floating windows can be +fine-tuned with the for_window command (see HTML userguide). +

+
+
+Split container +
+
+

+A split container contains multiple other split containers or windows. +

+

Containers can be used in various layouts. The default mode is called "default" +and just resizes each client equally so that it fits.

+
+
+Workspace +
+
+

+A workspace is a set of containers. Other window managers call this "Virtual +Desktops". +

+

In i3, each workspace is assigned to a specific virtual screen. By default, +screen 1 has workspace 1, screen 2 has workspace 2 and so on… However, when you +create a new workspace (by simply switching to it), it’ll be assigned the +screen you are currently on.

+
+
+Output +
+
+

+Using XRandR, you can have an X11 screen spanning multiple real monitors. +Furthermore, you can set them up in cloning mode or with positions (monitor 1 +is left of monitor 2). +

+

i3 uses the RandR API to query which outputs are available and which screens +are connected to these outputs.

+
+
+
+
+
+
+

KEYBINDINGS

+
+

Here is a short overview of the default keybindings:

+
+
+Mod1+Enter +
+
+

+Open a new terminal emulator window. +

+
+
+Mod1+d +
+
+

+Open dmenu for starting any application by typing (part of) its name. +

+
+
+j/k/l/; +
+
+

+Direction keys (left, down, up, right). They are on your homerow (see the mark +on your "j" key). Alternatively, you can use the cursor keys. +

+
+
+Mod1+<direction> +
+
+

+Focus window in <direction>. +

+
+
+Mod1+Shift+<direction> +
+
+

+Move window to <direction>. +

+
+
+Mod1+<number> +
+
+

+Switch to workspace <number>. +

+
+
+Mod1+Shift+<number> +
+
+

+Move window to workspace <number>. +

+
+
+Mod1+f +
+
+

+Toggle fullscreen mode. +

+
+
+Mod1+s +
+
+

+Enable stacking layout for the current container. +

+
+
+Mod1+e +
+
+

+Enable default layout for the current container. +

+
+
+Mod1+w +
+
+

+Enable tabbed layout for the current container. +

+
+
+Mod1+Shift+Space +
+
+

+Toggle tiling/floating for the current container. +

+
+
+Mod1+Space +
+
+

+Select the first tiling container if the current container is floating and +vice-versa. +

+
+
+Mod1+Shift+q +
+
+

+Kills the current window. This is equivalent to "clicking on the close button", +meaning a polite request to the application to close this window. For example, +Firefox will save its session upon such a request. If the application does not +support that, the window will be killed and it depends on the application what +happens. +

+
+
+Mod1+Shift+r +
+
+

+Restarts i3 in place. Your layout will be preserved. +

+
+
+Mod1+Shift+e +
+
+

+Exits i3. +

+
+
+
+
+
+

FILES

+
+
+

~/.config/i3/config (or ~/.i3/config)

+

When starting, i3 looks for configuration files in the following order:

+
    +
  1. +

    +~/.config/i3/config (or $XDG_CONFIG_HOME/i3/config if set) +

    +
    2. +
  2. +

    +~/.i3/config +

    +
    3. +
  3. +

    +/etc/xdg/i3/config (or $XDG_CONFIG_DIRS/i3/config if set) +

    +
    4. +
  4. +

    +/etc/i3/config +

    +
    5. +
+

You can specify a custom path using the -c option.

+
+
Sample configuration
+
+
# i3 config file (v4)
+
+# Font for window titles. Will also be used by the bar unless a different font
+# is used in the bar {} block below.
+# This font is widely installed, provides lots of unicode glyphs, right-to-left
+# text rendering and scalability on retina/hidpi displays (thanks to pango).
+font pango:DejaVu Sans Mono 8
+# Before i3 v4.8, we used to recommend this one as the default:
+# font -misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1
+# The font above is very space-efficient, that is, it looks good, sharp and
+# clear in small sizes. However, its unicode glyph coverage is limited, the old
+# X core fonts rendering does not support right-to-left and this being a bitmap
+# font, it doesn’t scale on retina/hidpi displays.
+
+# use Mouse+Mod1 to drag floating windows to their wanted position
+floating_modifier Mod1
+
+# start a terminal
+bindsym Mod1+Return exec /usr/bin/urxvt
+
+# kill focused window
+bindsym Mod1+Shift+q kill
+
+# start dmenu (a program launcher)
+bindsym Mod1+d exec /usr/bin/dmenu_run
+
+# change focus
+bindsym Mod1+j focus left
+bindsym Mod1+k focus down
+bindsym Mod1+l focus up
+bindsym Mod1+semicolon focus right
+
+# alternatively, you can use the cursor keys:
+bindsym Mod1+Left focus left
+bindsym Mod1+Down focus down
+bindsym Mod1+Up focus up
+bindsym Mod1+Right focus right
+
+# move focused window
+bindsym Mod1+Shift+j move left
+bindsym Mod1+Shift+k move down
+bindsym Mod1+Shift+l move up
+bindsym Mod1+Shift+semicolon move right
+
+# alternatively, you can use the cursor keys:
+bindsym Mod1+Shift+Left move left
+bindsym Mod1+Shift+Down move down
+bindsym Mod1+Shift+Up move up
+bindsym Mod1+Shift+Right move right
+
+# split in horizontal orientation
+bindsym Mod1+h split h
+
+# split in vertical orientation
+bindsym Mod1+v split v
+
+# enter fullscreen mode for the focused container
+bindsym Mod1+f fullscreen toggle
+
+# change container layout (stacked, tabbed, default)
+bindsym Mod1+s layout stacking
+bindsym Mod1+w layout tabbed
+bindsym Mod1+e layout default
+
+# toggle tiling / floating
+bindsym Mod1+Shift+space floating toggle
+
+# change focus between tiling / floating windows
+bindsym Mod1+space focus mode_toggle
+
+# focus the parent container
+bindsym Mod1+a focus parent
+
+# focus the child container
+#bindsym Mod1+d focus child
+
+# switch to workspace
+bindsym Mod1+1 workspace 1
+bindsym Mod1+2 workspace 2
+# ..
+
+# move focused container to workspace
+bindsym Mod1+Shift+1 move workspace 1
+bindsym Mod1+Shift+2 move workspace 2
+# ...
+
+# reload the configuration file
+bindsym Mod1+Shift+c reload
+# restart i3 inplace (preserves your layout/session, can be used to upgrade i3)
+bindsym Mod1+Shift+r restart
+# exit i3 (logs you out of your X session)
+bindsym Mod1+Shift+e exit
+
+# display workspace buttons plus a statusline generated by i3status
+bar {
+    status_command i3status
+}
+
+
+
+

~/.xsession

+

This file is where you should configure your locales and start i3. It is run by +your login manager (xdm, slim, gdm, …) as soon as you login.

+
+
Sample xsession
+
+
# Disable DPMS turning off the screen
+xset -dpms
+xset s off
+
+# Disable bell
+xset -b
+
+# Enable zapping (C-A-<Bksp> kills X)
+setxkbmap -option terminate:ctrl_alt_bksp
+
+# Enforce correct locales from the beginning:
+# LC_ALL is unset since it overwrites everything
+# LANG=de_DE.UTF-8 is used, except for:
+# LC_MESSAGES=C never translates program output
+# LC_TIME=en_DK leads to yyyy-mm-dd hh:mm date/time output
+unset LC_ALL
+export LANG=de_DE.UTF-8
+export LC_MESSAGES=C
+export LC_TIME=en_DK.UTF-8
+
+# Use XToolkit in java applications
+export AWT_TOOLKIT=XToolkit
+
+# Set background color
+xsetroot -solid "#333333"
+
+# Enable core dumps in case something goes wrong
+ulimit -c unlimited
+
+# Start i3 and log to ~/.local/share/i3/log
+mkdir -p ~/.local/share/i3
+echo "Starting at $(date)" >> ~/.local/share/i3/log
+exec /usr/bin/i3 -V -d all >> ~/.local/share/i3/log
+
+
+
+
+
+

ENVIRONMENT

+
+
+

I3SOCK

+

This variable overwrites the IPC socket path (see userguide for default +location). The IPC socket is used by external programs like i3-msg(1), i3bar(1) +or user-made scripts.

+
+
+
+
+

SEE ALSO

+
+

You should have a copy of the userguide (featuring nice screenshots/graphics +which is why this is not integrated into this manpage), the debugging guide, +and the "how to hack" guide.

+

You can also access these documents online at https://i3wm.org/

+

i3-input(1), i3-msg(1), i3bar(1), i3-nagbar(1), i3-config-wizard(1), +i3-migrate-config-to-v4(1)

+
+
+
+

AUTHOR

+
+

Michael Stapelberg and contributors

+
+
+
+
+ + + diff --git a/docs/i3bar-protocol.html b/docs/i3bar-protocol.html new file mode 100644 index 0000000..9885186 --- /dev/null +++ b/docs/i3bar-protocol.html @@ -0,0 +1,511 @@ + + + + + + +i3: i3bar input protocol + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+
+

This document explains the protocol in which i3bar expects its input. It +provides support for colors, urgency, shortening and easy manipulation.

+
+
+
+

Rationale for choosing JSON

+
+

Before describing the protocol, let’s cover why JSON is a building block of +this protocol.

+
    +
  1. +

    +Other bar display programs such as dzen2 or xmobar are using in-band + signaling: they recognize certain sequences (like ^fg(#330000) in your input + text). We would like to avoid that and separate information from + meta-information. By information, we mean the actual output, like the IP + address of your ethernet adapter and by meta-information, we mean in which + color it should be displayed right now. +

    +
    2. +
  2. +

    +It is easy to write a simple script which manipulates part(s) of the input. + Each block of information (like a block for the disk space indicator, a block + for the current IP address, etc.) can be identified specifically and modified + in whichever way you like. +

    +
    3. +
  3. +

    +It remains easy to write a simple script which just suffixes (or prefixes) a + status line input, because tools like i3status will output their JSON in + such a way that each line array will be terminated by a newline. Therefore, + you are not required to use a streaming JSON parser, but you can use any + JSON parser and write your script in any programming language. In fact, you + can decide to not bother with the JSON parsing at all and just inject your + output at a specific position (beginning or end). +

    +
    4. +
  4. +

    +Relying on JSON does not introduce any new dependencies. In fact, the IPC + interface of i3 also uses JSON, therefore i3bar already depends on JSON. +

    +
    5. +
+

The only point against using JSON is computational complexity. If that really +bothers you, just use the plain text input format (which i3bar will continue to +support).

+
+
+
+

The protocol

+
+

The first message of the protocol is a header block, which contains (at least) +the version of the protocol to be used. In case there are significant changes +(not only additions), the version will be incremented. i3bar will still +understand the old protocol version, but in order to use the new one, you need +to provide the correct version. The header block is terminated by a newline and +consists of a single JSON hash:

+

Minimal example:

+
+
+
{ "version": 1 }
+
+

All features example:

+
+
+
{ "version": 1, "stop_signal": 10, "cont_signal": 12, "click_events": true }
+
+

(Note that before i3 v4.3 the precise format had to be {"version":1}, +byte-for-byte.)

+

What follows is an infinite array (so it should be parsed by a streaming JSON +parser, but as described above you can go for a simpler solution), whose +elements are one array per status line. A status line is one unit of +information which should be displayed at a time. i3bar will not display any +input until the status line is complete. In each status line, every block will +be represented by a JSON hash:

+

Example:

+
+
+
[
+
+ [
+  {
+   "full_text": "E: 10.0.0.1 (1000 Mbit/s)",
+   "color": "#00ff00"
+  },
+  {
+   "full_text": "2012-01-05 20:00:01"
+  }
+ ],
+
+ [
+  {
+   "full_text": "E: 10.0.0.1 (1000 Mbit/s)",
+   "color": "#00ff00"
+  },
+  {
+   "full_text": "2012-01-05 20:00:02"
+  }
+ ],
+ …
+
+

Please note that this example was pretty printed for human consumption. +i3status and others will output single statuslines in one line, separated by +\n.

+

You can find an example of a shell script which can be used as your +status_command in the bar configuration at +https://github.com/i3/i3/blob/next/contrib/trivial-bar-script.sh

+
+

Header in detail

+
+
+version +
+
+

+ The version number (as an integer) of the i3bar protocol you will use. +

+
+
+stop_signal +
+
+

+ Specify the signal (as an integer) that i3bar should send to request that you + pause your output. This is used to conserve battery power when the bar is + hidden by not unnecessarily computing bar updates. The default value is SIGSTOP, + which will unconditionally stop your process. If this is an issue, this feature + can be disabled by setting the value to 0. +

+
+
+cont_signal +
+
+

+ Specify to i3bar the signal (as an integer) to send to continue your + processing. + The default value (if none is specified) is SIGCONT. +

+
+
+click_events +
+
+

+ If specified and true i3bar will write an infinite array (same as above) + to your stdin. +

+
+
+
+
+

Blocks in detail

+
+
+full_text +
+
+

+ The full_text will be displayed by i3bar on the status line. This is the + only required key. If full_text is an empty string, the block will be + skipped. +

+
+
+short_text +
+
+

+ Where appropriate, the short_text (string) entry should also be + provided. It will be used in case the status line needs to be shortened + because it uses more space than your screen provides. For example, when + displaying an IPv6 address, the prefix is usually (!) more relevant + than the suffix, because the latter stays constant when using autoconf, + while the prefix changes. When displaying the date, the time is more + important than the date (it is more likely that you know which day it + is than what time it is). +

+
+
+color +
+
+

+ To make the current state of the information easy to spot, colors can + be used. For example, the wireless block could be displayed in red + (using the color (string) entry) if the card is not associated with + any network and in green or yellow (depending on the signal strength) + when it is associated. + Colors are specified in hex (like in HTML), starting with a leading + hash sign. For example, #ff0000 means red. +

+
+
+background +
+
+

+ Overrides the background color for this particular block. +

+
+
+border +
+
+

+ Overrides the border color for this particular block. +

+
+
+border_top +
+
+

+ Defines the width (in pixels) of the top border of this block. Defaults + to 1. +

+
+
+border_right +
+
+

+ Defines the width (in pixels) of the right border of this block. Defaults + to 1. +

+
+
+border_bottom +
+
+

+ Defines the width (in pixels) of the bottom border of this block. Defaults + to 1. +

+
+
+border_left +
+
+

+ Defines the width (in pixels) of the left border of this block. Defaults + to 1. +

+
+
+min_width +
+
+

+ The minimum width (in pixels) of the block. If the content of the + full_text key take less space than the specified min_width, the block + will be padded to the left and/or the right side, according to the align + key. This is useful when you want to prevent the whole status line to shift + when value take more or less space between each iteration. + The value can also be a string. In this case, the width of the text given + by min_width determines the minimum width of the block. This is useful + when you want to set a sensible minimum width regardless of which font you + are using, and at what particular size. +

+
+
+align +
+
+

+ Align text on the center, right or left (default) of the block, when + the minimum width of the latter, specified by the min_width key, is not + reached. +

+
+
+name and instance +
+
+

+ Every block should have a unique name (string) entry so that it can + be easily identified in scripts which process the output. i3bar + completely ignores the name and instance fields. Make sure to also + specify an instance (string) entry where appropriate. For example, + the user can have multiple disk space blocks for multiple mount points. +

+
+
+urgent +
+
+

+ A boolean which specifies whether the current value is urgent. Examples + are battery charge values below 1 percent or no more available disk + space (for non-root users). The presentation of urgency is up to i3bar. +

+
+
+separator +
+
+

+ A boolean which specifies whether a separator line should be drawn + after this block. The default is true, meaning the separator line will + be drawn. Note that if you disable the separator line, there will still + be a gap after the block, unless you also use separator_block_width. +

+
+
+separator_block_width +
+
+

+ The amount of pixels to leave blank after the block. In the middle of + this gap, a separator line will be drawn unless separator is + disabled. Normally, you want to set this to an odd value (the default + is 9 pixels), since the separator line is drawn in the middle. +

+
+
+markup +
+
+

+ A string that indicates how the text of the block should be parsed. Set to + "pango" to use Pango markup. + Set to "none" to not use any markup (default). Pango markup only works + if you use a pango font. +

+
+
+

If you want to put in your own entries into a block, prefix the key with an +underscore (_). i3bar will ignore all keys it doesn’t understand, and prefixing +them with an underscore makes it clear in every script that they are not part +of the i3bar protocol.

+

Example:

+
+
+
{
+ "full_text": "E: 10.0.0.1 (1000 Mbit/s)",
+ "_ethernet_vendor": "Intel"
+}
+
+

In the following example, the longest (widest) possible value of the block is +used to set the minimum width:

+
+
+
{
+ "full_text": "CPU 4%",
+ "min_width": "CPU 100%",
+ "align": "left"
+}
+
+

An example of a block which uses all possible entries follows:

+

Example:

+
+
+
{
+ "full_text": "E: 10.0.0.1 (1000 Mbit/s)",
+ "short_text": "10.0.0.1",
+ "color": "#00ff00",
+ "background": "#1c1c1c",
+ "border": "#ee0000",
+ "border_top": 1,
+ "border_right": 0,
+ "border_bottom": 3,
+ "border_left": 1,
+ "min_width": 300,
+ "align": "right",
+ "urgent": false,
+ "name": "ethernet",
+ "instance": "eth0",
+ "separator": true,
+ "separator_block_width": 9,
+ "markup": "none"
+}
+
+
+
+

Click events

+

If enabled i3bar will send you notifications if the user clicks on a block and +looks like this:

+
+
+name +
+
+

+ Name of the block, if set +

+
+
+instance +
+
+

+ Instance of the block, if set +

+
+
+x, y +
+
+

+ X11 root window coordinates where the click occurred +

+
+
+button +
+
+

+ X11 button ID (for example 1 to 3 for left/middle/right mouse button) +

+
+
+relative_x, relative_y +
+
+

+ Coordinates where the click occurred, with respect to the top left corner + of the block +

+
+
+output_x, output_y +
+
+

+ Coordinates relative to the current output where the click occurred +

+
+
+width, height +
+
+

+ Width and height (in px) of the block +

+
+
+modifiers +
+
+

+ An array of the modifiers active when the click occurred. The order in which + modifiers are listed is not guaranteed. +

+
+
+

Example:

+
+
+
{
+ "name": "ethernet",
+ "instance": "eth0",
+ "button": 1,
+ "modifiers": ["Shift", "Mod1"],
+ "x": 1925,
+ "y": 1400,
+ "relative_x": 12,
+ "relative_y": 8,
+ "output_x": 5,
+ "output_y": 1400,
+ "width": 50,
+ "height": 22
+}
+
+
+
+
+
+
+ + + diff --git a/docs/i3bar-workspace-protocol.html b/docs/i3bar-workspace-protocol.html new file mode 100644 index 0000000..a5e55f4 --- /dev/null +++ b/docs/i3bar-workspace-protocol.html @@ -0,0 +1,272 @@ + + + + + + +i3: i3bar workspace buttons protocol + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+
+

This document explains the protocol in which i3bar expects input for +configuring workspace buttons. This feature is available since i3 version 4.23.

+

The program defined by the workspace_command configuration option for i3bar can +modify the workspace buttons displayed by i3bar. The command should constantly +print in its standard output a stream of messages following the protocol +defined in this page.

+

If you are looking for the status line protocol instead, see https://i3wm.org/docs/i3bar-protocol.html.

+
+
+
+

The protocol

+
+

Each message should be a newline-delimited JSON array. The array is in the same +format as the GET_WORKSPACES ipc event, see +https://i3wm.org/docs/ipc.html#_workspaces_reply.

+

As an example, this is the output of the i3-msg -t get_workspaces command:

+
+
+
[
+  {
+    "id": 94131549984064,
+    "num": 1,
+    "name": "1",
+    "visible": false,
+    "focused": false,
+    "output": "HDMI-A-0",
+    "urgent": false
+  },
+  {
+    "id": 94131550477584,
+    "num": 2,
+    "name": "2",
+    "visible": true,
+    "focused": true,
+    "output": "HDMI-A-0",
+    "urgent": false
+  },
+  {
+    "id": 94131550452704,
+    "num": 3,
+    "name": "3:some workspace",
+    "visible": false,
+    "focused": false,
+    "output": "HDMI-A-0",
+    "urgent": false
+  }
+]
+
+

Please note that this example was pretty printed for human consumption, with +the "rect" field removed. Workspace button commands should output each array +in one line.

+

Each element in the array represents a workspace. i3bar creates one workspace +button for each element in the array. The order of these buttons is the same as +the order of the elements in the array.

+

In general, we recommend subscribing to the workspace and output +events, +fetching the current workspace information with GET_WORKSPACES, modifying the +JSON array in the response according to your needs and then printing it to the +standard output. However, you are free to build a new message from the ground +up.

+
+

Workspace objects in detail

+

The documentation of GET_WORKSPACES should be sufficient to understand the +meaning of each property but here we provide extra notes for each property and +its meaning with respect to i3bar.

+

All properties but name are optional.

+
+
+id (integer) +
+
+

+ If it is included it will be used to switch to that workspace when you + click the corresponding button. If it’s not provided, the name will be + used. You can use the id field to present workspaces under a modified + name. +

+
+
+num (integer) +
+
+

+ The only use of a workspace’s number is if the strip_workspace_numbers + setting is enabled. +

+
+
+name (string) +
+
+

+ The only required property. If an id is provided you can freely change + the name as you wish, effectively renaming the buttons of i3bar. +

+
+
+visible (boolean) +
+
+

+ Defaults to false if not included. focused takes precedence over it, + however visible is important for more than one monitor. +

+
+
+focused (boolean) +
+
+

+ Defaults to false if not included. Generally, exactly one of the + workspaces should be focused. If not, no button will have the + focused_workspace color. +

+
+
+urgent (boolean) +
+
+

+ Defaults to false if not included. +

+
+
+rect (map) +
+
+

+ Not used by i3bar but will be ignored. +

+
+
+output (string) +
+
+

+ Defaults to the primary output if not included. +

+
+
+
+
+
+
+

Examples

+
+

These example scripts require the jq utility to +be installed but otherwise just use the standard i3-msg utility included with +i3. However, you can write your own scripts in your preferred language, with +the help of one of the +pre-existing i3 +libraries

+
+

Base configuration

+
+
+
bar {
+  …
+  workspace_command /path/to/your/script.sh
+  …
+}
+
+
+
+

Re-create the default behaviour of i3bar

+

Not very useful by itself but this will be the basic building block of all the +following scripts. This one does not require jq.

+
+
+
#!/bin/sh
+i3-msg -t subscribe -m '["workspace", "output"]' | {
+    # Initially print the current workspaces before we receive any events. This
+    # avoids having an empty bar when starting up.
+    i3-msg -t get_workspaces;
+    # Then, while we receive events, update the workspace information.
+    while read EVENT; do i3-msg -t get_workspaces; done;
+}
+
+
+
+

Hide workspace named foo unless if it is focused.

+
+
+
#!/bin/sh
+i3-msg -t subscribe -m '["workspace", "output"]' | {
+    i3-msg -t get_workspaces;
+    while read EVENT; do i3-msg -t get_workspaces; done;
+} | jq --unbuffered -c '[ .[] | select(.name != "foo" or .focused) ]'
+
+

Important! Make sure you use the --unbuffered flag with jq, otherwise you +might not get the changes in real-time but whenever they are flushed, which +might mean that you are getting an empty bar until enough events are written.

+
+
+

Show empty workspaces foo and bar on LVDS1 even if they do not exist at the moment.

+
+
+
#!/bin/sh
+i3-msg -t subscribe -m '["workspace", "output"]' | {
+    i3-msg -t get_workspaces;
+    while read EVENT; do i3-msg -t get_workspaces; done;
+} | jq --unbuffered -c '
+    def fake_ws(name): {
+        name: name,
+        output: "LVDS1",
+    };
+    . + [ fake_ws("foo"), fake_ws("bar") ] | unique_by(.name)
+'
+
+
+
+

Sort workspaces in reverse alphanumeric order

+
+
+
#!/bin/sh
+i3-msg -t subscribe -m '["workspace", "output"]' | {
+    i3-msg -t get_workspaces;
+    while read EVENT; do i3-msg -t get_workspaces; done;
+} | jq --unbuffered -c 'sort_by(.name) | reverse'
+
+
+
+

Append "foo" to the name of each workspace

+
+
+
#!/bin/sh
+i3-msg -t subscribe -m '["workspace", "output"]' | {
+    i3-msg -t get_workspaces;
+    while read EVENT; do i3-msg -t get_workspaces; done;
+} | jq --unbuffered -c '[ .[] | .name |= . + " foo" ]'
+
+
+
+
+
+
+ + + diff --git a/docs/i3bar.html b/docs/i3bar.html new file mode 100644 index 0000000..1b8a40e --- /dev/null +++ b/docs/i3bar.html @@ -0,0 +1,159 @@ + + + + + + +i3: i3bar(1) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+

NAME

+
+

i3bar - xcb-based status- and workspace-bar

+
+
+
+

SYNOPSIS

+
+

i3bar [-b bar_id] [-s sock_path] [-t] [-h] [-v] [-V]

+
+
+
+

WARNING

+
+

i3bar will automatically be invoked by i3 for every bar configuration block.

+

Starting it manually is usually not what you want to do.

+

You have been warned!

+
+
+
+

OPTIONS

+
+
+
+-s, --socket sock_path +
+
+

+Overwrites the path to the i3 IPC socket. +

+
+
+-b, --bar_id bar_id +
+
+

+Specifies the bar ID for which to get the configuration from i3. By default, +i3bar will use the first bar block as configured in i3. +

+
+
+-t, --transparency +
+
+

+Enable transparency (RGBA colors) +

+
+
+-h, --help +
+
+

+Display a short help-message and exit +

+
+
+-v, --version +
+
+

+Display version number and exit. +

+
+
+-V +
+
+

+Be verbose. +

+
+
+
+
+
+

DESCRIPTION

+
+

i3bar displays a bar at the bottom (or top) of your monitor(s) containing +workspace switching buttons and a statusline generated by i3status(1) or +similar. It is automatically invoked (and configured through) i3.

+

i3bar supports using a JSON protocol for setting the status line, see +https://i3wm.org/docs/i3bar-protocol.html

+

Since i3 4.23, i3bar supports another JSON protocol for setting workspace +buttons. See https://i3wm.org/docs/i3bar-workspace-protocol.html.

+
+
+
+

ENVIRONMENT

+
+
+

I3SOCK

+

Used as a fallback for the i3 IPC socket path if neither the commandline +contains an argument nor the I3_SOCKET_PATH property is set on the X11 root +window.

+
+
+
+
+

EXAMPLES

+
+

Nothing to see here, move along. As stated above, you should not run i3bar manually.

+

Instead, see the i3 documentation, especially the User’s Guide.

+
+
+
+

SEE ALSO

+
+

i3status(1), j4status(1) or conky(1) for programs generating a statusline.

+

dzen2(1) or xmobar(1) for similar programs to i3bar.

+
+
+
+

AUTHORS

+
+

Axel Wagner and contributors

+
+
+
+
+ + + diff --git a/docs/ipc.html b/docs/ipc.html new file mode 100644 index 0000000..3648813 --- /dev/null +++ b/docs/ipc.html @@ -0,0 +1,2246 @@ + + + + + + +i3: IPC interface (interprocess communication) + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+
+

This document describes how to interface with i3 from a separate process. This +is useful for example to remote-control i3 (to write test cases for example) or +to get various information like the current workspaces to implement an external +workspace bar.

+

The method of choice for IPC in our case is a unix socket because it has very +little overhead on both sides and is usually available without headaches in +most languages. +By default i3 will set the path of the IPC socket based on:

+
    +
  1. +

    +The ipc-socket configuration directive if it is used +

    +
    2. +
  2. +

    +The I3SOCK environmental variable if it is set +

    +
    3. +
  3. +

    +$XDG_RUNTIME_DIR/i3/ipc-socket.%p if the directory is available where %p + is the PID of i3 and XXXXXX is a string of random characters +

    +
    4. +
  4. +

    +/tmp/i3-%u.XXXXXX/ipc-socket.%p where %u is your UNIX username +

    +
    5. +
+

You can get the socketpath from i3 by executing i3 --get-socketpath, which +will print the path to the standard output (plus a newline) or by reading the +I3SOCK environmental variable.

+

All i3 utilities, like i3-msg and i3-input will determine the path of the +IPC socket frome the I3SOCK environmental variable if it is set or the +I3_SOCKET_PATH X11 property, stored on the X11 root window.

+
+ + + +
+
Warning
+		 +
Use an existing library!
There are existing libraries for many languages. You can have a look at +[libraries] or search the web if your language of choice is not mentioned. +Usually, it is not necessary to implement low-level communication with i3 +directly.
+
+
+
+
+

Establishing a connection

+
+

To establish a connection, simply open the IPC socket. The following code +snippet illustrates this in Perl:

+
+
+
use IO::Socket::UNIX;
+chomp(my $path = qx(i3 --get-socketpath));
+my $sock = IO::Socket::UNIX->new(Peer => $path);
+
+
+
+
+

Sending messages to i3

+
+

To send a message to i3, you have to format it in the binary message format +which i3 expects. This format specifies a magic string in the beginning to +ensure the integrity of messages (to prevent follow-up errors). Following the +magic string comes the length of the payload of the message as a 32-bit +integer, and the type of the message as a 32-bit integer (the integers are not +converted, so they are in native byte order).

+

The magic string currently is "i3-ipc" and will only be changed when a change +in the IPC API is done which breaks compatibility (we hope that we don’t need +to do that).

+
+ + +++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Table 1. Currently implemented message types
Type (numeric) Type (name) Reply type Purpose

0

RUN_COMMAND

COMMAND

Run the payload as an i3 command (like the commands you can bind to keys).

1

GET_WORKSPACES

WORKSPACES

Get the list of current workspaces.

2

SUBSCRIBE

SUBSCRIBE

Subscribe this IPC connection to the event types specified in the message payload. See [events].

3

GET_OUTPUTS

OUTPUTS

Get the list of current outputs.

4

GET_TREE

TREE

Get the i3 layout tree.

5

GET_MARKS

MARKS

Gets the names of all currently set marks.

6

GET_BAR_CONFIG

BAR_CONFIG

Gets the specified bar configuration or the names of all bar configurations if payload is empty.

7

GET_VERSION

VERSION

Gets the i3 version.

8

GET_BINDING_MODES

BINDING_MODES

Gets the names of all currently configured binding modes.

9

GET_CONFIG

CONFIG

Returns the last loaded i3 config.

10

SEND_TICK

TICK

Sends a tick event with the specified payload.

11

SYNC

SYNC

Sends an i3 sync event with the specified random value to the specified window.

12

GET_BINDING_STATE

BINDING_STATE

Request the current binding state, i.e. the currently active binding mode name.

+
+

So, a typical message could look like this:

+
+
+
"i3-ipc" <message length> <message type> <payload>
+
+

Or, as a hexdump:

+
+
+
00000000  69 33 2d 69 70 63 04 00  00 00 00 00 00 00 65 78  |i3-ipc........ex|
+00000010  69 74                                             |it|
+
+

To generate and send such a message, you could use the following code in Perl:

+
+
+
sub format_ipc_command {
+    my ($msg) = @_;
+    my $len;
+    # Get the real byte count (vs. amount of characters)
+    { use bytes; $len = length($msg); }
+    return "i3-ipc" . pack("LL", $len, 0) . $msg;
+}
+
+$sock->write(format_ipc_command("exit"));
+
+
+
+
+

Receiving replies from i3

+
+

Each message sent to i3 will cause exactly one reply to be sent in return. The +order of the sent replies will always correspond to the order of the sent +requests. The only exception to this is [events], which (once subscribed to) +may be sent at any time (though never in the middle of another event or reply).

+

It is generally safe to send several messages to i3 without first waiting for a +reply for each one (pipelining) — though, note that depending on the language / +network library you use, writing to the socket without also reading from it may +cause a deadlock due to the socket buffers getting full.

+

The reply format is identical to the normal message format. There also is +the magic string, then the message length, then the message type and the +payload.

+

The payload of replies from i3 usually consists of a simple string (the length +of the string is the message_length, so you can consider them length-prefixed), +which in turn contain the JSON serialization of a data structure. For example, +the GET_WORKSPACES message returns an array of workspaces (each workspace is a +map with certain attributes).

+

Replies currently have a 1:1 correspondence to messages, with the message type +of the reply corresponding to the message type of the message which caused the +reply to be sent.

+

The following reply types are implemented:

+
+
+COMMAND (0) +
+
+

+ Confirmation/Error code for the RUN_COMMAND message. +

+
+
+WORKSPACES (1) +
+
+

+ Reply to the GET_WORKSPACES message. +

+
+
+SUBSCRIBE (2) +
+
+

+ Confirmation/Error code for the SUBSCRIBE message. +

+
+
+OUTPUTS (3) +
+
+

+ Reply to the GET_OUTPUTS message. +

+
+
+TREE (4) +
+
+

+ Reply to the GET_TREE message. +

+
+
+MARKS (5) +
+
+

+ Reply to the GET_MARKS message. +

+
+
+BAR_CONFIG (6) +
+
+

+ Reply to the GET_BAR_CONFIG message. +

+
+
+VERSION (7) +
+
+

+ Reply to the GET_VERSION message. +

+
+
+BINDING_MODES (8) +
+
+

+ Reply to the GET_BINDING_MODES message. +

+
+
+GET_CONFIG (9) +
+
+

+ Reply to the GET_CONFIG message. +

+
+
+TICK (10) +
+
+

+ Reply to the SEND_TICK message. +

+
+
+SYNC (11) +
+
+

+ Reply to the SYNC message. +

+
+
+GET_BINDING_STATE (12) +
+
+

+ Reply to the GET_BINDING_STATE message. +

+
+
+
+
+
+

Messages and replies

+
+
+

RUN_COMMAND / COMMAND

+

Run the payload as an i3 +command (like the commands you can bind to keys).

+

Message:

+

The message payload is the string containing the command to execute. There is +no JSON encoding or trailing newline.

+

Reply:

+

The reply consists of a list of serialized maps for each command that was +parsed. Each has the property success (bool) and may also include a +human-readable error message in the property error (string).

+
+ + + +
+
Note
+		When sending the restart command, you will get a singular reply once the +restart completed. All IPC connection states (e.g. subscriptions) will reset and +all but one socket will be closed. Libraries must be able to cope with this by +aligning their internal states. It is also recommended that libraries close +the last remaining socket(one which replied to restart command) to achieve +the full reset.
+
+
+ + + +
+
Note
+		It is easiest to always send the restart command alone: due to i3’s +state reset, the reply messages of preceding commands are lost, and following +commands will not be executed.
+
+
+ + + +
+
Note
+		When processing the exit command, i3 will immediately exit without +sending a reply. Expect the socket to be shut down.
+
+

Example:

+
+
+
[{ "success": true }]
+
+

When the specified command cannot be parsed, success will be false and +parse_error will be true:

+

Example:

+
+
+
[{ "success": false, "parse_error": true }]
+
+
+
+

GET_WORKSPACES / WORKSPACES

+

Get the list of current workspaces.

+

Message:

+

No payload.

+

Reply:

+

The reply consists of a serialized list of workspaces. Each workspace has the +following properties:

+
+
+id (integer) +
+
+

+ The internal ID (actually a C pointer value) of this container. Do not + make any assumptions about it. You can use it to (re-)identify and + address containers when talking to i3. +

+
+
+num (integer) +
+
+

+ The logical number of the workspace. Corresponds to the command + to switch to this workspace. For named workspaces, this will be -1. +

+
+
+name (string) +
+
+

+ The name of this workspace if changed by the user, otherwise defaults + to the string representation of the num field). Encoded in UTF-8. +

+
+
+visible (boolean) +
+
+

+ Whether this workspace is currently visible on an output (multiple + workspaces can be visible at the same time). +

+
+
+focused (boolean) +
+
+

+ Whether this workspace currently has the focus (only one workspace + can have the focus at the same time). +

+
+
+urgent (boolean) +
+
+

+ Whether a window on this workspace has the "urgent" flag set. +

+
+
+rect (map) +
+
+

+ The rectangle of this workspace (equals the rect of the output it + is on), consists of x, y, width, height. +

+
+
+output (string) +
+
+

+ The video output this workspace is on (LVDS1, VGA1, …). +

+
+
+

Example:

+
+
+
[
+ {
+  "num": 0,
+  "name": "1",
+  "visible": true,
+  "focused": true,
+  "urgent": false,
+  "rect": {
+   "x": 0,
+   "y": 0,
+   "width": 1280,
+   "height": 800
+  },
+  "output": "LVDS1"
+ },
+ {
+  "num": 1,
+  "name": "2",
+  "visible": false,
+  "focused": false,
+  "urgent": false,
+  "rect": {
+   "x": 0,
+   "y": 0,
+   "width": 1280,
+   "height": 800
+  },
+  "output": "LVDS1"
+ }
+]
+
+
+
+

SUBSCRIBE

+

Subscribe this IPC connection to the event types specified in the message +payload. See [events].

+

Message:

+

A JSON-encoded array of event types to subscribe to.

+

Reply:

+

The reply consists of a single serialized map. The only property is +success (bool), indicating whether the subscription was successful (the +default) or whether a JSON parse error occurred.

+

Example:

+
+
+
{ "success": true }
+
+
+
+

GET_OUTPUTS / OUTPUTS

+

Get the list of current outputs.

+

Message:

+

No payload.

+

Reply:

+

The reply consists of a serialized list of outputs. Each output has the +following properties:

+
+
+name (string) +
+
+

+ The name of this output (as seen in xrandr(1)). Encoded in UTF-8. +

+
+
+active (boolean) +
+
+

+ Whether this output is currently active (has a valid mode). +

+
+
+primary (boolean) +
+
+

+ Whether this output is currently the primary output. +

+
+
+current_workspace (string or null) +
+
+

+ The name of the current workspace that is visible on this output. null if + the output is not active. +

+
+
+rect (map) +
+
+

+ The rectangle of this output (equals the rect of the output it + is on), consists of x, y, width, height. +

+
+
+

Example:

+
+
+
[
+ {
+  "name": "LVDS1",
+  "active": true,
+  "current_workspace": "4",
+  "rect": {
+   "x": 0,
+   "y": 0,
+   "width": 1280,
+   "height": 800
+  }
+ },
+ {
+  "name": "VGA1",
+  "active": true,
+  "current_workspace": "1",
+  "rect": {
+   "x": 1280,
+   "y": 0,
+   "width": 1280,
+   "height": 1024
+  }
+ }
+]
+
+
+
+

GET_TREE / TREE

+

Get the i3 layout tree.

+

Message:

+

No payload.

+

Reply:

+

The reply consists of a serialized tree. Each node in the tree (representing +one container) has at least the properties listed below. While the nodes might +have more properties, please do not use any properties which are not documented +here. They are not yet finalized and will probably change!

+
+
+id (integer) +
+
+

+ The internal ID (actually a C pointer value) of this container. Do not + make any assumptions about it. You can use it to (re-)identify and + address containers when talking to i3. +

+
+
+name (string) +
+
+

+ The internal name of this container. For all containers which are part + of the tree structure down to the workspace contents, this is set to a + nice human-readable name of the container. + For containers that have an X11 window, the content is the title + (_NET_WM_NAME property) of that window. + For all other containers, the content is not defined (yet). +

+
+
+type (string) +
+
+

+ Type of this container. Can be one of "root", "output", "con", + "floating_con", "workspace" or "dockarea". +

+
+
+border (string) +
+
+

+ Can be either "normal", "none" or "pixel", depending on the + container’s border style. +

+
+
+current_border_width (integer) +
+
+

+ Number of pixels of the border width. +

+
+
+layout (string) +
+
+

+ Can be either "splith", "splitv", "stacked", "tabbed", "dockarea" or + "output". + Other values might be possible in the future, should we add new + layouts. +

+
+
+orientation (string) +
+
+

+ Can be either "none" (for non-split containers), "horizontal" or + "vertical". + THIS FIELD IS OBSOLETE. It is still present, but your code should not + use it. Instead, rely on the layout field. +

+
+
+percent (float or null) +
+
+

+ The percentage which this container takes in its parent. A value of + null means that the percent property does not make sense for this + container, for example for the root container. +

+
+
+rect (map) +
+
+

+ The absolute display coordinates for this container. Display + coordinates means that when you have two 1600x1200 monitors on a single + X11 Display (the standard way), the coordinates of the first window on + the second monitor are { "x": 1600, "y": 0, "width": 1600, "height": + 1200 }. +

+
+
+window_rect (map) +
+
+

+ The coordinates of the actual client window inside its container. + These coordinates are relative to the container and do not include the + window decoration (which is actually rendered on the parent container). + So, when using the default layout, you will have a 2 pixel border on + each side, making the window_rect { "x": 2, "y": 0, "width": 632, + "height": 366 } (for example). +

+
+
+deco_rect (map) +
+
+

+ The coordinates of the window decoration inside its container. These + coordinates are relative to the container and do not include the actual + client window. +

+
+
+actual_deco_rect (map) +
+
+

+ See deco_rect. i3 v4.22 changed the way title bars are rendered. Before + i3 v4.22, the deco_rect was always relative to the parent coordinates. + Starting with i3 v4.22, this remains true for tabbed/stacked containers + (actual_deco_rect is identical to deco_rect), but for normal-border leaf + containers within vertical/horizontal split containers, actual_deco_rect + is relative to the container itself. For more background, see + https://github.com/i3/i3/issues/1966 +

+
+
+geometry (map) +
+
+

+ The original geometry the window specified when i3 mapped it. Used when + switching a window to floating mode, for example. +

+
+
+window (integer or null) +
+
+

+ The X11 window ID of the actual client window inside this container. + This field is set to null for split containers or otherwise empty + containers. This ID corresponds to what xwininfo(1) and other + X11-related tools display (usually in hex). +

+
+
+window_properties (map) +
+
+

+ This optional field contains all available X11 window properties from the + following list: title, instance, class, window_role, machine + and transient_for. +

+
+
+window_type (string) +
+
+

+ The window type (_NET_WM_WINDOW_TYPE). Possible values are undefined, + unknown, normal, dialog, utility, toolbar, splash, menu, dropdown_menu, + popup_menu, tooltip and notification. +

+
+
+urgent (bool) +
+
+

+ Whether this container (window, split container, floating container or + workspace) has the urgency hint set, directly or indirectly. All parent + containers up until the workspace container will be marked urgent if they + have at least one urgent child. +

+
+
+marks (array of string) +
+
+

+ List of marks assigned to container +

+
+
+focused (bool) +
+
+

+ Whether this container is currently focused. +

+
+
+focus (array of integer) +
+
+

+ List of child node IDs (see nodes, floating_nodes and id) in focus + order. Traversing the tree by following the first entry in this array + will result in eventually reaching the one node with focused set to + true. +

+
+
+sticky (bool) +
+
+

+ Whether this window is "sticky". If it is also floating, this window will + be present on all workspaces on the same output. +

+
+
+fullscreen_mode (integer) +
+
+

+ Whether this container is in fullscreen state or not. + Possible values are + 0 (no fullscreen), + 1 (fullscreened on output) or + 2 (fullscreened globally). + Note that all workspaces are considered fullscreened on their respective output. +

+
+
+floating (string) +
+
+

+ Floating state of container. + Can be either "auto_on", "auto_off", "user_on" or "user_off" +

+
+
+nodes (array of node) +
+
+

+ The tiling (i.e. non-floating) child containers of this node. +

+
+
+floating_nodes (array of node) +
+
+

+ The floating child containers of this node. Only non-empty on nodes with + type workspace. +

+
+
+scratchpad_state (string) +
+
+

+ Whether the window is not in the scratchpad ("none"), freshly moved to + the scratchpad but not yet resized ("fresh") or moved to the scratchpad + and resized ("changed"). +

+
+
+

Please note that in the following example, I have left out some keys/values +which are not relevant for the type of the node. Otherwise, the example would +be by far too long (it already is quite long, despite showing only 1 window and +one dock window).

+

It is useful to have an overview of the structure before taking a look at the +JSON dump:

+
    +
  • +

    +root +

    +
      +
    • +

      +LVDS1 +

      +
        +
      • +

        +topdock +

        +
        • +
      • +

        +content +

        +
          +
        • +

          +workspace 1 +

          +
            +
          • +

            +window 1 +

            +
            • +
          +
          • +
        +
        • +
      • +

        +bottomdock +

        +
          +
        • +

          +dock window 1 +

          +
          • +
        +
        • +
      +
      • +
    • +

      +VGA1 +

      +
      • +
    +
    • +
+

Example:

+
+
+
{
+ "id": 6875648,
+ "name": "root",
+ "rect": {
+   "x": 0,
+   "y": 0,
+   "width": 1280,
+   "height": 800
+ },
+ "nodes": [
+
+   {
+    "id": 6878320,
+    "name": "LVDS1",
+    "layout": "output",
+    "rect": {
+      "x": 0,
+      "y": 0,
+      "width": 1280,
+      "height": 800
+    },
+    "nodes": [
+
+      {
+       "id": 6878784,
+       "name": "topdock",
+       "layout": "dockarea",
+       "orientation": "vertical",
+       "rect": {
+         "x": 0,
+         "y": 0,
+         "width": 1280,
+         "height": 0
+       }
+      },
+
+      {
+       "id": 6879344,
+       "name": "content",
+       "rect": {
+         "x": 0,
+         "y": 0,
+         "width": 1280,
+         "height": 782
+       },
+       "nodes": [
+
+         {
+          "id": 6880464,
+          "name": "1",
+          "orientation": "horizontal",
+          "rect": {
+            "x": 0,
+            "y": 0,
+            "width": 1280,
+            "height": 782
+          },
+          "window_properties": {
+            "class": "Evince",
+            "instance": "evince",
+            "title": "Properties",
+            "transient_for": 52428808
+          },
+          "floating_nodes": [],
+          "nodes": [
+
+            {
+             "id": 6929968,
+             "name": "#aa0000",
+             "border": "normal",
+             "percent": 1,
+             "rect": {
+               "x": 0,
+               "y": 18,
+               "width": 1280,
+               "height": 782
+             }
+            }
+
+          ]
+         }
+
+       ]
+      },
+
+      {
+       "id": 6880208,
+       "name": "bottomdock",
+       "layout": "dockarea",
+       "orientation": "vertical",
+       "rect": {
+         "x": 0,
+         "y": 782,
+         "width": 1280,
+         "height": 18
+       },
+       "nodes": [
+
+         {
+          "id": 6931312,
+          "name": "#00aa00",
+          "percent": 1,
+          "rect": {
+            "x": 0,
+            "y": 782,
+            "width": 1280,
+            "height": 18
+          }
+         }
+
+       ]
+      }
+    ]
+   }
+ ]
+}
+
+
+
+

GET_MARKS / MARKS

+

Gets the names of all currently set marks.

+

Message:

+

No payload.

+

Reply:

+

The reply consists of a single array of strings for each container that has a +mark. A mark can only be set on one container, so the array is unique. +The order of that array is undefined.

+

If no window has a mark the response will be the empty array [].

+
+
+

GET_BAR_CONFIG / BAR_CONFIG

+

Gets the specified bar configuration or the names of all bar configurations if payload is empty.

+

Message:

+

No payload, or the ID of the bar whose configuration to retrieve.

+

Reply:

+

This can be used by third-party workspace bars (especially i3bar, but others +are free to implement compatible alternatives) to get the bar block +configuration from i3.

+

Depending on the input, the reply is either:

+
+
+empty input +
+
+

+ An array of configured bar IDs +

+
+
+Bar ID +
+
+

+ A JSON map containing the configuration for the specified bar. +

+
+
+

Each bar configuration has the following properties:

+
+
+id (string) +
+
+

+ The ID for this bar. Included in case you request multiple + configurations and want to differentiate the different replies. +

+
+
+mode (string) +
+
+

+ Either dock (the bar sets the dock window type) or hide (the bar + does not show unless a specific key is pressed). +

+
+
+position (string) +
+
+

+ Either bottom or top at the moment. +

+
+
+status_command (string) +
+
+

+ Command which will be run to generate a statusline. Each line on stdout + of this command will be displayed in the bar. At the moment, no + formatting is supported. +

+
+
+font (string) +
+
+

+ The font to use for text on the bar. +

+
+
+workspace_buttons (boolean) +
+
+

+ Display workspace buttons or not? Defaults to true. +

+
+
+binding_mode_indicator (boolean) +
+
+

+ Display the mode indicator or not? Defaults to true. +

+
+
+verbose (boolean) +
+
+

+ Should the bar enable verbose output for debugging? Defaults to false. +

+
+
+colors (map) +
+
+

+ Contains key/value pairs of colors. Each value is a color code in hex, + formatted #rrggbb (like in HTML). +

+
+
+

The following colors can be configured at the moment:

+
+
+background +
+
+

+ Background color of the bar. +

+
+
+statusline +
+
+

+ Text color to be used for the statusline. +

+
+
+separator +
+
+

+ Text color to be used for the separator. +

+
+
+focused_background +
+
+

+ Background color of the bar on the currently focused monitor output. +

+
+
+focused_statusline +
+
+

+ Text color to be used for the statusline on the currently focused + monitor output. +

+
+
+focused_separator +
+
+

+ Text color to be used for the separator on the currently focused + monitor output. +

+
+
+focused_workspace_text/focused_workspace_bg/focused_workspace_border +
+
+

+ Text/background/border color for a workspace button when the workspace + has focus. +

+
+
+active_workspace_text/active_workspace_bg/active_workspace_border +
+
+

+ Text/background/border color for a workspace button when the workspace + is active (visible) on some output, but the focus is on another one. + You can only tell this apart from the focused workspace when you are + using multiple monitors. +

+
+
+inactive_workspace_text/inactive_workspace_bg/inactive_workspace_border +
+
+

+ Text/background/border color for a workspace button when the workspace + does not have focus and is not active (visible) on any output. This + will be the case for most workspaces. +

+
+
+urgent_workspace_text/urgent_workspace_bg/urgent_workspace_border +
+
+

+ Text/background/border color for workspaces which contain at least one + window with the urgency hint set. +

+
+
+binding_mode_text/binding_mode_bg/binding_mode_border +
+
+

+ Text/background/border color for the binding mode indicator. +

+
+
+

Example of configured bars:

+
+
+
["bar-bxuqzf"]
+
+

Example of bar configuration:

+
+
+
{
+ "id": "bar-bxuqzf",
+ "mode": "dock",
+ "position": "bottom",
+ "status_command": "i3status",
+ "font": "-misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1",
+ "workspace_buttons": true,
+ "binding_mode_indicator": true,
+ "verbose": false,
+ "colors": {
+   "background": "#c0c0c0",
+   "statusline": "#00ff00",
+   "focused_workspace_text": "#ffffff",
+   "focused_workspace_bg": "#000000"
+ }
+}
+
+
+
+

GET_VERSION / VERSION

+

Gets the i3 version.

+

Message:

+

No payload.

+

Reply:

+

The reply consists of a single JSON dictionary with the following keys:

+
+
+major (integer) +
+
+

+ The major version of i3, such as 4. +

+
+
+minor (integer) +
+
+

+ The minor version of i3, such as 2. Changes in the IPC interface (new + features) will only occur with new minor (or major) releases. However, + bugfixes might be introduced in patch releases, too. +

+
+
+patch (integer) +
+
+

+ The patch version of i3, such as 1 (when the complete version is + 4.2.1). For versions such as 4.2, patch will be set to 0. +

+
+
+human_readable (string) +
+
+

+ A human-readable version of i3 containing the precise git version, + build date and branch name. When you need to display the i3 version to + your users, use the human-readable version whenever possible (since + this is what i3 --version displays, too). +

+
+
+loaded_config_file_name (string) +
+
+

+ The current config path. +

+
+
+

Example:

+
+
+
{
+   "human_readable" : "4.2-169-gf80b877 (2012-08-05, branch \"next\")",
+   "loaded_config_file_name" : "/home/hwangcc23/.i3/config",
+   "minor" : 2,
+   "patch" : 0,
+   "major" : 4
+}
+
+
+
+

GET_BINDING_MODES / BINDING_MODES

+

Gets the names of all currently configured binding modes.

+

Message:

+

No payload.

+

Reply:

+

The reply consists of an array of all currently configured binding modes.

+

Example:

+
+
+
["default", "resize"]
+
+
+
+

GET_CONFIG / CONFIG

+

Returns the last loaded i3 config.

+

Message:

+

No payload.

+

Reply:

+

The config reply is a map which contains the following fields:

+
+
+config (string) +
+
+

+ The top-level config file contents that i3 has loaded most recently. + This field is kept for backwards compatibility. See included_configs + instead. +

+
+
+included_configs (array of maps) +
+
+

+ i3 adds one entry to this array for each config file it loads, in + order. The first entry’s raw_contents are identical to the config + field. +

+
+
+

Each included_configs entry contains the following fields

+
+
+path (string) +
+
+

+ Absolute path name to the config file that i3 loaded. +

+
+
+raw_contents (string) +
+
+

+ The raw contents of the file as i3 read them. +

+
+
+variable_replaced_contents (string) +
+
+

+ The contents of the file after i3 replaced all variables. This is useful + for debugging variable replacement. +

+
+
+

Example:

+
+
+
{
+  "config": "include font.cfg\n",
+  "included_configs": [
+    {
+      "path": "/home/michael/configfiles/i3/config",
+      "raw_contents": "include font.cfg\n",
+      "variable_replaced_contents": "include font.cfg\n"
+    },
+    {
+      "path": "/home/michael/configfiles/i3/font.cfg",
+      "raw_contents": "set $font pango:monospace 8\nfont $font",
+      "variable_replaced_contents": "set pango:monospace 8 pango:monospace 8\nfont pango:monospace 8\n"
+    }
+  ],
+}
+
+
+
+

SEND_TICK / TICK

+

Sends a tick event with the specified payload.

+

Message:

+

The payload of the tick event to send to IPC event listeners.

+

Reply:

+

The reply is a map containing the "success" member. After the reply was +received, the tick event has been written to all IPC connections which subscribe +to tick events. UNIX sockets are usually buffered, but you can be certain that +once you receive the tick event you just triggered, you must have received all +events generated prior to the SEND_TICK message (happened-before relation).

+

Example:

+
+
+
{ "success": true }
+
+
+
+

SYNC

+

Sends an i3 sync event with the specified random value to the specified window.

+

Message:

+

A JSON-encoded map with the properties "rnd" and "window" (both integer).

+

Reply:

+

The reply is a map containing the "success" member. After the reply was +received, the i3 sync message was +responded to.

+

Example:

+
+
+
{ "success": true }
+
+
+
+

GET_BINDING_STATE

+

Request the current binding state, i.e. the currently active binding mode name.

+

Message:

+

No payload.

+

Reply:

+

The binding_state reply is a map which currently only contains the "name" +member, which is the name of the currently active binding mode as a string.

+

Example:

+
+
+
{ "name": "default" }
+
+
+
+
+
+

Events

+
+

To get informed when certain things happen in i3, clients can subscribe to +events. Events consist of a name (like "workspace") and an event reply type +(like I3_IPC_EVENT_WORKSPACE). Events sent by i3 follow a format similar to +replies but with the highest bit of the message type set to 1 to indicate an +event reply instead of a normal reply. Note that event types and reply types +do not follow the same enumeration scheme (e.g. event type 0 corresponds to the +workspace event however reply type 0 corresponds to the COMMAND reply).

+

Caveat: As soon as you subscribe to an event, it is not guaranteed any longer +that the requests to i3 are processed in order. This means, the following +situation can happen: You send a GET_WORKSPACES request but you receive a +"workspace" event before receiving the reply to GET_WORKSPACES. If your +program does not want to cope which such kinds of race conditions (an +event based library may not have a problem here), I suggest you create a +separate connection to receive events.

+

If an event message needs to be sent and the socket is not writeable (write +returns EAGAIN, happens when the socket doesn’t have enough buffer space for +writing new data) then i3 uses a queue system to store outgoing messages for +each client. This is combined with a timer: if the message queue for a client is +not empty and no data where successfully written in the past 10 seconds, the +connection is killed. Practically, this means that your client should try to +always read events from the socket to avoid having its connection closed.

+
+

Subscribing to events

+

By sending a message of type SUBSCRIBE with a JSON-encoded array as payload +you can register to an event.

+

Example:

+
+
+
type: SUBSCRIBE
+payload: [ "workspace", "output" ]
+
+
+
+

Available events

+

The numbers in parenthesis is the event type (keep in mind that you need to +strip the highest bit first).

+
+
+workspace (0) +
+
+

+ Sent when the user switches to a different workspace, when a new + workspace is initialized or when a workspace is removed (because the + last client vanished). +

+
+
+output (1) +
+
+

+ Sent when RandR issues a change notification (of either screens, + outputs, CRTCs or output properties). +

+
+
+mode (2) +
+
+

+ Sent whenever i3 changes its binding mode. +

+
+
+window (3) +
+
+

+ Sent when a client’s window is successfully reparented (that is when i3 + has finished fitting it into a container), when a window received input + focus or when certain properties of the window have changed. +

+
+
+barconfig_update (4) +
+
+

+ Sent when the hidden_state or mode field in the barconfig of any bar + instance was updated and when the config is reloaded. +

+
+
+binding (5) +
+
+

+ Sent when a configured command binding is triggered with the keyboard or + mouse +

+
+
+shutdown (6) +
+
+

+ Sent when the ipc shuts down because of a restart or exit by user command +

+
+
+tick (7) +
+
+

+ Sent when the ipc client subscribes to the tick event (with "first": + true) or when any ipc client sends a SEND_TICK message (with "first": + false). +

+
+
+

Example:

+
+
+
# the appropriate 4 bytes read from the socket are stored in $input
+
+# unpack a 32-bit unsigned integer
+my $message_type = unpack("L", $input);
+
+# check if the highest bit is 1
+my $is_event = (($message_type >> 31) == 1);
+
+# use the other bits
+my $event_type = ($message_type & 0x7F);
+
+if ($is_event) {
+  say "Received event of type $event_type";
+}
+
+
+
+

workspace event

+

This event consists of a single serialized map containing a property +change (string) which indicates the type of the change.

+
    +
  • +

    +empty – the workspace has become empty +

    +
    • +
  • +

    +focus – the workspace has received input focus +

    +
    • +
  • +

    +init – the workspace has been created +

    +
    • +
  • +

    +move – the workspace has been moved to a different output +

    +
    • +
  • +

    +reload – i3 config has been reloaded +

    +
    • +
  • +

    +rename – the workspace’s name has changed +

    +
    • +
  • +

    +restored – the workspace’s layout has changed to a previously saved layout +

    +
    • +
  • +

    +urgent – the workspace has become urgent or lost its urgent status +

    +
    • +
+

A current (object) property will be present with the affected workspace +whenever the type of event affects a workspace (otherwise, it will be null).

+

When the change is "focus", an old (object) property will be present with the +previous workspace. When the first switch occurs (when i3 focuses the +workspace visible at the beginning) there is no previous workspace, and the +old property will be set to null. Also note that if the previous is empty +it will get destroyed when switching, but will still be present in the "old" +property.

+

Example:

+
+
+
{
+ "change": "focus",
+ "current": {
+  "id": 28489712,
+  "type": "workspace",
+  ...
+ }
+ "old": {
+  "id": 28489715,
+  "type": "workspace",
+  ...
+ }
+}
+
+
+
+

output event

+

This event consists of a single serialized map containing a property +change (string) which indicates the type of the change (currently only +"unspecified").

+

Example:

+
+
+
{ "change": "unspecified" }
+
+
+
+

mode event

+

This event consists of a single serialized map containing a property +change (string) which holds the name of current mode in use. The name +is the same as specified in config when creating a mode. The default +mode is simply named default. It contains a second property, pango_markup, which +defines whether pango markup shall be used for displaying this mode.

+

Example:

+
+
+
{
+  "change": "default",
+  "pango_markup": true
+}
+
+
+
+

window event

+

This event consists of a single serialized map containing a property +change (string) which indicates the type of the change

+
    +
  • +

    +new – the window has become managed by i3 +

    +
    • +
  • +

    +close – the window has closed +

    +
    • +
  • +

    +focus – the window has received input focus +

    +
    • +
  • +

    +title – the window’s title has changed +

    +
    • +
  • +

    +fullscreen_mode – the window has entered or exited fullscreen mode +

    +
    • +
  • +

    +move – the window has changed its position in the tree +

    +
    • +
  • +

    +floating – the window has transitioned to or from floating +

    +
    • +
  • +

    +urgent – the window has become urgent or lost its urgent status +

    +
    • +
  • +

    +mark – a mark has been added to or removed from the window +

    +
    • +
+

Additionally a container (object) field will be present, which consists +of the window’s parent container. Be aware that for the "new" event, the +container will hold the initial name of the newly reparented window (e.g. +if you run urxvt with a shell that changes the title, you will still at +this point get the window title as "urxvt").

+

Example:

+
+
+
{
+ "change": "new",
+ "container": {
+  "id": 35569536,
+  "type": "con",
+  ...
+ }
+}
+
+
+
+

barconfig_update event

+

This event consists of a single serialized map reporting on options from the +barconfig of the specified bar_id that were updated in i3. This event is the +same as a GET_BAR_CONFIG reply for the bar with the given id.

+
+
+

binding event

+

This event consists of a single serialized map reporting on the details of a +binding that ran a command because of user input. The change (string) field +indicates what sort of binding event was triggered (right now it will always be +"run" but may be expanded in the future).

+

The mode (string) field contains the name of the mode the binding was run in.

+

The binding (object) field contains details about the binding that was run:

+
+
+command (string) +
+
+

+ The i3 command that is configured to run for this binding. +

+
+
+event_state_mask (array of strings) +
+
+

+ The group and modifier keys that were configured with this binding. +

+
+
+input_code (integer) +
+
+

+ If the binding was configured with bindcode, this will be the key code + that was given for the binding. If the binding is a mouse binding, it will be + the number of the mouse button that was pressed. Otherwise it will be 0. +

+
+
+symbol (string or null) +
+
+

+ If this is a keyboard binding that was configured with bindsym, this + field will contain the given symbol. Otherwise it will be null. +

+
+
+input_type (string) +
+
+

+ This will be "keyboard" or "mouse" depending on whether or not this was + a keyboard or a mouse binding. +

+
+
+

Example:

+
+
+
{
+ "change": "run",
+ "binding": {
+  "command": "nop",
+  "event_state_mask": [
+    "shift",
+    "ctrl"
+  ],
+  "input_code": 0,
+  "symbol": "t",
+  "input_type": "keyboard"
+ }
+}
+
+
+
+

shutdown event

+

This event is triggered when the connection to the ipc is about to shutdown +because of a user action such as a restart or exit command. The change +(string) field indicates why the ipc is shutting down. It can be either +"restart" or "exit".

+

Example:

+
+
+
{
+ "change": "restart"
+}
+
+
+
+

tick event

+

This event is triggered by a subscription to tick events or by a SEND_TICK +message.

+

Example (upon subscription):

+
+
+
{
+ "first": true,
+ "payload": ""
+}
+
+

Example (upon SEND_TICK with a payload of arbitrary string):

+
+
+
{
+ "first": false,
+ "payload": "arbitrary string"
+}
+
+
+
+
+
+

See also (existing libraries)

+
+

For some languages, libraries are available (so you don’t have to implement +all this on your own). This list names some (if you wrote one, please let me +know):

+
+
+C +
+
+
+
+
+C++ +
+
+
+
+
+Go +
+
+
+
+
+JavaScript +
+
+
+
+
+Lua +
+
+
+
+
+Perl +
+
+
+
+
+Python +
+
+
+
+
+Ruby +
+
+
+
+
+Rust +
+
+
+
+
+OCaml +
+
+
+
+
+
+
+
+

Appendix A: Detecting byte order in memory-safe languages

+
+

Some programming languages such as Go don’t offer a way to serialize data in the +native byte order of the machine they’re running on without resorting to tricks +involving the unsafe package.

+

The following technique can be used (and will not be broken by changes to i3) to +detect the byte order i3 is using:

+
    +
  1. +

    +The byte order dependent fields of an IPC message are message type and + payload length. +

    +
      +
    • +

      +The message type RUN_COMMAND (0) is the same in big and little endian, so + we can use it in either byte order to elicit a reply from i3. +

      +
      • +
    • +

      +The payload length 65536 + 256 (0x00 01 01 00) is the same in big and + little endian, and also small enough to not worry about memory allocations + of that size. We must use payloads of length 65536 + 256 in every message + we send, so that i3 will be able to read the entire message regardless of + the byte order it uses. +

      +
      • +
    +
    2. +
  2. +

    +Send a big endian encoded message of type SUBSCRIBE (2) with payload [] + followed by 65536 + 256 - 2 SPACE (ASCII 0x20) bytes. +

    +
      +
    • +

      +If i3 is running in big endian, this message is treated as a noop, + resulting in a SUBSCRIBE reply with payload {"success":true} +
      [A small payload is important: that way, we circumvent dealing + with UNIX domain socket buffer sizes, whose size depends on the + implementation/operating system. Exhausting such a buffer results in an i3 + deadlock unless you concurrently read and write, which — depending on the + programming language — makes the technique much more complicated.]
      . +

      +
      • +
    • +

      +If i3 is running in little endian, this message is read in its entirety due + to the byte order independent payload length, then + silently + discarded due to the unknown message type. +

      +
      • +
    +
    3. +
  3. +

    +Send a byte order independent message, i.e. type RUN_COMMAND (0) with + payload nop byte order detection. padding:, padded to 65536 + 256 bytes + with a (ASCII 0x61) bytes. i3 will reply to this message with a reply of + type COMMAND (0). +

    +
      +
    • +

      +The human-readable prefix is in there to not confuse readers of the i3 log. +

      +
      • +
    • +

      +This messages serves as a synchronization primitive so that we know whether + i3 discarded the SUBSCRIBE message or didn’t answer it yet. +

      +
      • +
    +
    4. +
  4. +

    +Receive a message header from i3, decoding the message type as big endian. +

    +
      +
    • +

      +If the message’s reply type is COMMAND (0), i3 is running in little + endian (because the SUBSCRIBE message was discarded). Decode the message + payload length as little endian, receive the message payload. +

      +
      • +
    • +

      +If the message’s reply type is anything else, i3 is running in big endian + (because our big endian encoded SUBSCRIBE message was answered). Decode + the message payload length in big endian, receive the message + payload. Then, receive the pending COMMAND message reply in big endian. +

      +
      • +
    +
    5. +
  5. +

    +From here on out, send/receive all messages using the detected byte order. +

    +
    6. +
+

Find an example implementation of this technique in +https://github.com/i3/go-i3/blob/master/byteorder.go

+
+
+
+
+ + + diff --git a/docs/keyboard-layer1.png b/docs/keyboard-layer1.png new file mode 100644 index 0000000..52ffae0 Binary files /dev/null and b/docs/keyboard-layer1.png differ diff --git a/docs/keyboard-layer2.png b/docs/keyboard-layer2.png new file mode 100644 index 0000000..83616d9 Binary files /dev/null and b/docs/keyboard-layer2.png differ diff --git a/docs/layout-saving-1.png b/docs/layout-saving-1.png new file mode 100644 index 0000000..a49f042 Binary files /dev/null and b/docs/layout-saving-1.png differ diff --git a/docs/layout-saving.html b/docs/layout-saving.html new file mode 100644 index 0000000..329caa1 --- /dev/null +++ b/docs/layout-saving.html @@ -0,0 +1,306 @@ + + + + + + +i3: Layout saving in i3 + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+
+

Layout saving/restoring is a feature that was introduced in i3 v4.8.

+

Layout saving/restoring allows you to load a JSON layout file so that you can +have a base layout to start working with after powering on your computer. +Dynamic use-cases also come to mind: if you frequently (but not always!) need a +grid layout of terminals with ping/traceroute commands to diagnose network +issues, you can easily automate opening these windows in just the right layout.

+
+
+
+

Saving the layout

+
+

You can save the layout of either a single workspace or an entire output (e.g. +LVDS1). Of course, you can repeat this step multiple times if you want to +save/restore multiple workspaces/outputs.

+

i3-save-tree(1) is a tool to save the layout. It will print a JSON +representation of i3’s internal layout data structures to stdout. Typically, +you may want to take a quick look at the output, then save it to a file and +tweak it a little bit:

+
+
+
i3-save-tree --workspace 1 > ~/.i3/workspace-1.json
+
+

Please note that the output of i3-save-tree(1) is NOT useful until you +manually modify it — you need to tell i3 how to match/distinguish windows (for +example based on their WM_CLASS, title, etc.). By default, all the different +window properties are included in the output, but commented out. This is partly +to avoid relying on heuristics and partly to make you aware how i3 works so +that you can easily solve layout restoring problems.

+

How to modify the file manually is described in [EditingLayoutFiles].

+
+
+
+

Restoring the layout

+
+

After restoring the example layout from [EditingLayoutFiles], i3 will open +placeholder windows for all the windows that were specified in the layout file. +You can recognize the placeholder windows by the watch symbol +
[Depending on the font you are using, a placeholder symbol may show up +instead of the watch symbol.]
 in the center of the window, and by the swallow +criteria specification at the top of the window:

+

+ +Restored layout + +

+

When an application opens a window that matches the specified swallow criteria, +it will be placed in the corresponding placeholder window. We say it gets +swallowed by the placeholder container, hence the term.

+

Note: Swallowing windows into unsatisfied placeholder windows takes precedence +over +assignment +rules. For example, if you assign all Emacs windows to workspace 1 in your i3 +configuration file, but there is a placeholder window on workspace 2 which +matches Emacs as well, your newly started Emacs window will end up in the +placeholder window on workspace 2.

+

The placeholder windows are just regular windows, so feel free to move them +around or close them, for example.

+
+

append_layout command

+

The append_layout command is used to load a layout file into i3. It accepts a +path (relative to i3’s current working directory or absolute) to a JSON file.

+

Syntax:

+
+
+
append_layout <path>
+
+

Examples:

+
+
+
# From a terminal or script:
+i3-msg "workspace 1; append_layout /home/michael/.i3/workspace-1.json"
+
+# In your i3 configuration file, you can autostart i3-msg like this:
+# (Note that those lines will quickly become long, so typically you would store
+#  them in a script with proper indentation.)
+exec --no-startup-id "i3-msg 'workspace 1; append_layout /home/michael/.i3/workspace-1.json'"
+
+
+
+
+
+

Editing layout files

+
+
+

Anatomy of a layout file

+

Here is an example layout file that we’ll discuss:

+
+
+
{
+    // splitv split container with 2 children
+    "layout": "splitv",
+    "percent": 0.4,
+    "type": "con",
+    "nodes": [
+        {
+            "border": "none",
+            "name": "irssi",
+            "percent": 0.5,
+            "type": "con",
+            "swallows": [
+                {
+                    "class": "^URxvt$",
+                    "instance": "^irssi$"
+                }
+            ]
+        },
+        {
+            // stacked split container with 2 children
+            "layout": "stacked",
+            "percent": 0.5,
+            "type": "con",
+            "nodes": [
+                {
+                    "name": "notmuch",
+                    "percent": 0.5,
+                    "type": "con",
+                    "swallows": [
+                        {
+                            "class": "^Emacs$",
+                            "instance": "^notmuch$"
+                        }
+                    ]
+                },
+                {
+                    "name": "midna: ~",
+                    "percent": 0.5,
+                    "type": "con"
+                }
+            ]
+        }
+    ]
+}
+
+{
+    // stacked split container with 1 children
+    "layout": "stacked",
+    "percent": 0.6,
+    "type": "con",
+    "nodes": [
+        {
+            "name": "chrome",
+            "type": "con",
+            "swallows": [
+                {
+                    "class": "^Google-chrome$"
+                }
+            ]
+        }
+    ]
+}
+
+

In this layout, the screen is divided into two columns. In the left column, +which covers 40% of the screen, there is a terminal emulator running irssi on +the top, and a stacked split container with an Emacs window and a terminal +emulator on the bottom. In the right column, there is a stacked container with +a Chrome window:

+

+ +Restored layout + +

+

The structure of this JSON file looks a lot like the TREE reply, see +https://build.i3wm.org/docs/ipc.html#_tree_reply for documentation on that. Some +properties are excluded because they are not relevant when restoring a layout.

+

Most importantly, look at the "swallows" section of each window. This is where +you need to be more or less specific. As an example, remember the section about +the Emacs window:

+
+
+
"swallows": [
+    {
+        "class": "^Emacs$",
+        "instance": "^notmuch$"
+    }
+]
+
+

Here you can see that i3 will require both the class and the instance to match. +Therefore, if you just start Emacs via dmenu, it will not get swallowed by that +container. Only if you start Emacs with the proper instance name (emacs24 +--name notmuch), it will get swallowed.

+

You can match on "class", "instance", "window_role", "title" and "machine". All +values are case-sensitive regular expressions (PCRE). Use xprop(1) and click +into a window to see its properties:

+
+
+
$ xprop
+WM_WINDOW_ROLE(STRING) = "gimp-toolbox-color-dialog"
+WM_CLASS(STRING) = "gimp-2.8", "Gimp-2.8"
+_NET_WM_NAME(UTF8_STRING) = "Change Foreground Color"
+
+

The first part of WM_CLASS is the "instance" (gimp-2.8 in this case), the +second part is the "class" (Gimp-2.8 in this case). "title" matches against +_NET_WM_NAME and "window_role" matches against WM_WINDOW_ROLE.

+

In general, you should try to be as specific as possible in your swallow +criteria. Try to use criteria that match one window and only one window, to +have a reliable startup procedure.

+

If you specify multiple swallow criteria, the placeholder will be replaced by +the window which matches any of the criteria. As an example:

+
+
+
// Matches either Emacs or Gvim, whichever one is started first.
+"swallows": [
+    {"class": "^Emacs$"},
+    {"class": "^Gvim$"}
+]
+
+
+
+

JSON standard non-compliance

+

A layout file as generated by i3-save-tree(1) is not strictly valid JSON:

+
    +
  1. +

    +Layout files contain multiple “JSON texts” at the top level. The JSON + standard doesn’t prohibit this, but in practice most JSON parsers only + allow precisely one “text” per document/file, and will mark multiple texts + as invalid JSON. +

    +
    2. +
  2. +

    +Layout files contain comments which are not allowed by the JSON standard, + but are understood by many parsers. +

    +
    3. +
+

Both of these deviations from the norm are to make manual editing by humans +easier. In case you are writing a more elaborate tool for manipulating these +layouts, you can either use a JSON parser that supports these deviations (for +example libyajl), transform the layout file to a JSON-conforming file, or +submit a patch +to make i3-save-tree(1) optionally output standard-conforming JSON.

+
+
+
+
+

Troubleshooting

+
+
+

Restoring a vertically split workspace

+

When using i3-save-tree with the --workspace switch, only the contents of +the workspace will be dumped. This means that properties of the workspace +itself will be lost.

+

This is relevant for, e.g., a vertically split container as the base container of +a workspace. Since the split mode is a property of the workspace, it will not be +stored. In this case, you will have to manually wrap your layout in such a +container:

+
+
+
// vim:ts=4:sw=4:et
+{
+    // this is a manually added container to restore the vertical split
+    "layout": "splitv",
+    "percent": 0.5,
+    "type": "con",
+    "nodes": [
+
+        // the dumped workspace layout goes here
+
+    ]
+}
+
+
+
+
+
+
+ + + diff --git a/docs/logo-30.png b/docs/logo-30.png new file mode 100644 index 0000000..207b888 Binary files /dev/null and b/docs/logo-30.png differ diff --git a/docs/modes.png b/docs/modes.png new file mode 100644 index 0000000..656a6db Binary files /dev/null and b/docs/modes.png differ diff --git a/docs/multi-monitor.html b/docs/multi-monitor.html new file mode 100644 index 0000000..5572d7f --- /dev/null +++ b/docs/multi-monitor.html @@ -0,0 +1,106 @@ + + + + + + +i3: The multi-monitor situation + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+
+

Please upgrade your nVidia driver to version 302.17 or newer and i3 will just +work. This document is kept around for historic reasons only.

+
+
+
+

The quick fix

+
+

If you are using the nVidia binary graphics driver (also known as blob) +before version 302.17, you need to use the --force-xinerama flag (in your +.xsession) when starting i3, like so:

+
+
Example:
+
+
exec i3 --force-xinerama -V >>~/.i3/i3log 2>&1
+
+

…or use force_xinerama yes in your configuration file.

+
+
+
+

The explanation

+
+

Starting with version 3.ε, i3 uses the RandR (Rotate and Resize) API instead +of Xinerama. The reason for this, is that RandR provides more information +about your outputs and connected screens than Xinerama does. To be specific, +the code which handled on-the-fly screen reconfiguration (meaning without +restarting the X server) was a very messy heuristic and most of the time did +not work correctly — that is just not possible with the little information +Xinerama offers (just a list of screen resolutions, no identifiers for the +screens or any additional information). Xinerama simply was not designed +for dynamic configuration.

+

So RandR came along, as a more powerful alternative (RandR 1.2 to be specific). +It offers all of Xinerama’s possibilities and lots more. Using the RandR API +made our code much more robust and clean. Also, you can now reliably assign +workspaces to output names instead of some rather unreliable screen identifier +(position inside the list of screens, which could change, and so on…).

+

As RandR has been around for about three years as of this writing, it seemed +like a very good idea to us, and it still is a very good one. What we did not +expect, however, was the nVidia binary driver. It still does not support RandR +(as of March 2010), even though nVidia has announced that it will support RandR +eventually. What does this mean for you, if you are stuck with the binary +driver for some reason (say the free drivers don’t work with your card)? First +of all, you are stuck with TwinView and cannot use xrandr. While this ruins +the user experience, the more grave problem is that the nVidia driver not only +does not support dynamic configuration using RandR, it also does not expose +correct multi-monitor information via the RandR API. So, in some setups, i3 +will not find any screens; in others, it will find one large screen which +actually contains both of your physical screens (but it will not know that +these are two screens).

+

For this very reason, we decided to implement the following workaround: As +long as the nVidia driver does not support RandR, an option called +--force-xinerama is available in i3 (alternatively, you can use the +force_xinerama configuration file directive). This option gets the list of +screens once when starting, and never updates it. As the nVidia driver cannot +do dynamic configuration anyways, this is not a big deal.

+

Also note that your output names are not descriptive (like HDMI1) when using +Xinerama, instead they are counted up, starting at 0: xinerama-0, xinerama-1, …

+
+
+
+

See also

+
+

For more information on how to use multi-monitor setups, see the i3 User’s +Guide.

+
+
+
+
+ + + diff --git a/docs/refcard.html b/docs/refcard.html new file mode 100644 index 0000000..0e3a412 --- /dev/null +++ b/docs/refcard.html @@ -0,0 +1,198 @@ + + + + + i3 Reference Card + + + + +
+
+ +

i3 Reference Card

+ https://i3wm.org/docs/userguide.html +

+ Throughout this guide, the i3 logo will be used to refer to the configured modifier. + This is the key (Mod1) by default, + with super/ (Mod4) being a popular alternative. +

+
+ + +
+

Basics

+ + + + + + + +
+ + open new terminal +
+ j + focus left + +
+ k + focus down + +
+ l + focus up + +
+ ; + focus right +
+ + toggle focus mode +
+
+ +
+

Moving windows

+ + + + + +
+ + j + move window left +
+ + k + move window down +
+ + l + move window up +
+ + ; + move window right +
+
+ +
+ +
+

Modifying windows

+ + + + + +
+ f + toggle fullscreen +
+ v + split a window vertically +
+ h + split a window horizontally +
+ r + resize mode +
+

Look at the “Resizing containers / windows” section of the user guide.

+
+ +
+

Changing the container layout

+ + + + +
+ e + default + +
+ s + stacking + +
+ w + tabbed +
+
+ +
+

Floating

+ + + +
+ + + toggle floating +
+ + drag floating +
+
+ + +
+

Using workspaces

+ + + +
+ 0-9 + switch to another workspace +
+ + 0-9 + move a window to another workspace +
+
+ +
+ +
+

Opening applications / Closing windows

+ + + +
+ d + open application launcher (dmenu) +
+ + q + kill a window +
+
+ +
+

Restart / Exit

+ + + + +
+ + c + reload the configuration file +
+ + r + restart i3 inplace + +
+ + e + exit i3 + +
+ + + + +

+ Permission is granted to copy, distribute and/or modify this document provided + the copyright notice and this permission notice are preserved on all copies. +

+
+ diff --git a/docs/refcard_style.css b/docs/refcard_style.css new file mode 100644 index 0000000..361cac6 --- /dev/null +++ b/docs/refcard_style.css @@ -0,0 +1,45 @@ +/* Generated by Font Squirrel (http://www.fontsquirrel.com) on April 12, 2012 */ + + + +@font-face { + /* This declaration targets Internet Explorer */ + font-family: 'LinuxLibertine'; + src: url('linlibertine_r-webfont.eot'); +} + +@font-face { + /* This declaration targets everything else */ + font-family: 'LinuxLibertine'; + src: url(//:) format('no404'), url(data:font/woff;charset=utf-8;base64,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) format('woff'), url(data:font/truetype;charset=utf-8;base64,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) format('truetype'), url('linlibertine_r-webfont.svg#LinuxLibertineRegular') format('svg'); + font-weight: normal; + font-style: normal; +} + +@font-face { + /* This declaration targets Internet Explorer */ + font-family: 'LinuxBiolinumKeyboard'; + src: url('linbiolinum_k-webfont.eot'); +} + +@font-face { + /* This declaration targets everything else */ + font-family: 'LinuxBiolinumKeyboard'; + src: url(//:) format('no404'), url(data:font/woff;charset=utf-8;base64,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) format('woff'), url(data:font/truetype;charset=utf-8;base64,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) format('truetype'), url('linbiolinum_k-webfont.svg#LinuxBiolinumKeyboardRegular') format('svg'); + font-weight: normal; + font-style: normal; +} + +@font-face { + /* This declaration targets Internet Explorer */ + font-family: 'LinuxBiolinum'; + src: url('linbiolinum_r-webfont.eot'); +} + +@font-face { + /* This declaration targets everything else */ + font-family: 'LinuxBiolinum'; + src: url(//:) format('no404'), url(data:font/woff;charset=utf-8;base64,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) format('woff'), url(data:font/truetype;charset=utf-8;base64,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) format('truetype'), url('linbiolinum_r-webfont.svg#LinuxBiolinumRegular') format('svg'); + font-weight: normal; + font-style: normal; +} diff --git a/docs/single_terminal.png b/docs/single_terminal.png new file mode 100644 index 0000000..4fe918c Binary files /dev/null and b/docs/single_terminal.png differ diff --git a/docs/snapping.png b/docs/snapping.png new file mode 100644 index 0000000..65fe6e4 Binary files /dev/null and b/docs/snapping.png differ diff --git a/docs/testsuite.html b/docs/testsuite.html new file mode 100644 index 0000000..b24e811 --- /dev/null +++ b/docs/testsuite.html @@ -0,0 +1,757 @@ + + + + + + +i3: i3 testsuite + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+
+

This document explains how the i3 testsuite works, how to use it and extend it. +It is targeted at developers who haven’t necessarily done testing before, +or have not used Perl for testing before. In general, the testsuite is not of +interest for end users.

+
+
+
+

Introduction

+
+

The i3 testsuite is a collection of files which contain testcases for various +i3 features. Some of them test if a certain workflow works correctly (moving +windows, focus behaviour, …). Others are regression tests and contain code +which previously made i3 crash or lead to unexpected behaviour. They then check +if i3 still runs (meaning it did not crash) and if it handled everything +correctly.

+

The goal of having these tests is to automatically find problems and to +automatically get a feel for whether a change in the source code breaks any +existing feature. After every modification of the i3 sourcecode, the developer +should run the full testsuite. If one of the tests fails, the corresponding +problem should be fixed (or, in some cases, the testcase has to be modified). +For every bugreport, a testcase should be written to test the correct +behaviour. Initially, it will fail, but after fixing the bug, it will pass. +This ensures (or increases the chance) that bugs which have been fixed once +will never be found again.

+

Also, when implementing a new feature, a testcase might be a good way to be +able to easily test if the feature is working correctly. Many developers will +test manually if everything works. Having a testcase not only helps you with +that, but it will also be useful for every future change.

+
+
+
+

Relevant documentation

+
+

Apart from this document, you should also have a look at:

+
    +
  1. +

    +The "Modern Perl" book: + https://i3wm.org/downloads/modern_perl_a4.pdf +

    +
    2. +
  2. +

    +The latest Perl documentation of the "i3test" (general testcase setup) and + "i3test::Test" (additional test instructions) modules: + https://build.i3wm.org/docs/lib-i3test.html respectively + https://build.i3wm.org/docs/lib-i3test-test.html +

    +
    3. +
  3. +

    +The latest documentation on i3’s IPC interface: + https://build.i3wm.org/docs/ipc.html +

    +
    4. +
+
+
+
+

Implementation

+
+

For several reasons, the i3 testsuite has been implemented in Perl:

+
    +
  1. +

    +Perl has a long tradition of testing. Every popular/bigger Perl module which + you can find on CPAN will not only come with documentation, but also with + tests. Therefore, the available infrastructure for tests is comprehensive. + See for example the excellent http://search.cpan.org/perldoc?Test::More + and the referenced http://search.cpan.org/perldoc?Test::Tutorial. +

    +
    2. +
  2. +

    +Perl is widely available and has a well-working package infrastructure. +

    +
    3. +
  3. +

    +The author is familiar with Perl :). +

    +
    4. +
  4. +

    +It is a good idea to use a different language for the tests than the + implementation itself. +

    +
    5. +
+

Please do not start programming language flamewars at this point.

+
+

Installing the dependencies

+

As usual with Perl programs, the testsuite ships with a Makefile.PL. +This file specifies which Perl modules the testsuite depends on and can be used +to install all of them.

+

Perl modules are distributed via CPAN, and there is the official, standard CPAN +client, simply called cpan. It comes with every Perl installation and can be +used to install the testsuite. Many users prefer to use the more modern +cpanminus instead, though (because it asks no questions and just works):

+

The tests additionally require Xephyr(1) to run a nested X server. Install +xserver-xephyr on Debian or xorg-server-xephyr on Arch Linux.

+
+
Installing testsuite dependencies using cpanminus
+
+
# Install testsuite system-level dependencies. Xvfb is optional but recommended.
+$ sudo apt-get install xcb-proto cpanminus xvfb xserver-xephyr
+# Install dependencies in ~/perl5 local library
+$ cpanm --local-lib=~/perl5 local::lib App::cpanminus Module::Install
+# Activate the local library
+$ eval $(perl -I ~/perl5/lib/perl5/ -Mlocal::lib)
+$ cd ~/i3/testcases/
+$ cpanm .
+$ cd ~/i3/AnyEvent-I3
+$ cpanm .
+
+
+
+

Mechanisms

+
+

Script: complete-run

+

The testcases are run by a script called complete-run.pl. It runs all +testcases by default, but you can be more specific and let it only run one or +more testcases. Also, it takes care of starting up a separate instance of i3 +with an appropriate configuration file and creates a folder for each run +containing the appropriate i3 logfile for each testcase. The latest folder can +always be found under the symlink latest/. Unless told differently, it will +run the tests on a separate X server instance (using Xephyr).

+

Xephyr will open a window where you can inspect the running test. By default, +tests are run under Xvfb.

+
+
Example invocation of complete-run.pl
+
+
$ cd ~/i3
+
+$ mkdir -p build
+
+$ meson setup build
+$ cd build
+
+$ meson compile
+# output omitted because it is very long
+
+$ ./complete-run.pl
+# output omitted because it is very long
+All tests successful.
+Files=78, Tests=734, 27 wallclock secs ( 0.38 usr  0.48 sys + 17.65 cusr  3.21 csys = 21.72 CPU)
+Result: PASS
+
+$ ./complete-run.pl t/005-floating.t
+Running tests under Xvfb display :99
+Starting 1 Xephyr instances, starting at :100...
+
+Rough time estimate for this run: 9.65 seconds
+
+Writing logfile to 'testsuite-2024-05-01-21-33-45-4.23-28-g5834b7e8/complete-run.log'...
+[:100] i3/testcases/t/005-floating.t: finished
+completed 0 of 1 tests
+
+All tests successful.
+Files=1, Tests=13,  0 wallclock secs ( 0.00 usr +  0.00 sys =  0.00 CPU)
+Result: PASS
+
+The slowest tests are:
+        i3/testcases/t/005-floating.t with 0.07 seconds
+
+Test output:
+[:100] i3/testcases/t/005-floating.t: starting
+[:100] i3/testcases/t/005-floating.t: finished
+output for i3/testcases/t/005-floating.t:
+ok 1 - An object of class 'X11::XCB::Window' isa 'X11::XCB::Window'
+ok 2 - Window is mapped
+ok 3 - i3 raised the width to 75
+ok 4 - i3 raised the height to 50
+ok 5 - i3 did not map it to (0x0)
+ok 6 - An object of class 'X11::XCB::Window' isa 'X11::XCB::Window'
+ok 7 - i3 let the width at 80
+ok 8 - i3 let the height at 90
+ok 9 - i3 mapped it to x=20
+ok 10 - i3 mapped it to y=20
+ok 11 - An object of class 'X11::XCB::Window' isa 'X11::XCB::Window'
+ok 12 - i3 let the width at 80
+ok 13 - i3 let the height at 90
+1..13
+
+$ less latest/i3-log-for-005-floating.t
+
+

If your attempt to run the tests with a bare call to ./complete-run.pl fails, try this:

+
+
+
$ ./complete-run.pl --parallel=1 --keep-xserver-output
+
+

This will show the output of Xephyr, which is the X server implementation we +use for testing.

+
+
ninja command: ninja test
+

ninja test runs the i3 testsuite. +You can still use ./complete-run.pl to get the interactive progress output.

+
+
Example invocation of ninja test
+
+
$ cd ~/i3
+
+$ mkdir -p build
+
+$ meson setup build
+$ cd build
+
+$ ninja test
+[1/102] Generating config.h with a custom command
+[1/2] Running all tests.
+1/1 complete-run OK              34.39s
+
+Ok:                 1
+Expected Fail:      0
+Fail:               0
+Unexpected Pass:    0
+Skipped:            0
+Timeout:            0
+
+Full log written to i3/build/meson-logs/testlog.txt
+
+$ less latest/complete-run.log
+
+
+
+
+

Coverage testing

+

Coverage testing is possible with lcov, the front-end for GCC’s coverage +testing tool gcov. The testcases can generate a nice html report that tells +you which functions and lines were covered during a run of the tests. You can +use this tool to judge how effective your tests are.

+

To use test coverage tools, first compile with coverage enabled.

+
+
+
COVERAGE=1 make
+
+

Then run the tests with the --coverage-testing flag.

+
+
+
./complete-run.pl --coverage-testing
+
+

Then open latest/i3-coverage/index.html in your web browser.

+
+
+

IPC interface

+

The testsuite makes extensive use of the IPC (Inter-Process Communication) +interface which i3 provides. It is used for the startup process of i3, for +terminating it cleanly and (most importantly) for modifying and getting the +current state (layout tree).

+

See [https://i3wm.org/docs/ipc.html] for documentation on the IPC interface.

+
+
+

X11::XCB

+

In order to open new windows, change attributes, get events, etc., the +testsuite uses X11::XCB, a new (and quite specific to i3 at the moment) Perl +module which uses the XCB protocol description to generate Perl bindings to +X11. They work in a very similar way to libxcb (which i3 uses) and provide +relatively high-level interfaces (objects such as X11::XCB::Window) as well as +access to the low-level interface, which is very useful when testing a window +manager.

+
+
+
+

Filesystem structure

+

In the git root of i3, the testcases live in the folder testcases. This +folder contains the complete-run.pl and a base configuration file which will +be used for the tests. The different testcases (their file extension is .t, not +.pl) themselves can be found in the conventionally named subfolder t:

+
+
Filesystem structure
+
+
├── testcases
+│   ├── complete-run.pl
+│   ├── i3-test.config
+│   ├── lib
+│   │   ├── i3test.pm
+│   │   ├── SocketActivation.pm
+│   │   └── StartXDummy.pm
+│   ├── t
+│   │   ├── 00-load.t
+│   │   ├── 01-tile.t
+│   │   ├── 02-fullscreen.t
+│   │   ├── ...
+│   │   ├── omitted for brevity
+│   │   ├── ...
+│   │   └── 74-regress-focus-toggle.t
+
+
+
+
+
+

Anatomy of a testcase

+
+

Learning by example is definitely a good strategy when you are wondering how to +write a testcase. Let’s take t/11-goto.t as an easy example and go through it +step by step:

+
+
t/11-goto.t: Boilerplate
+
+
#!perl
+# vim:ts=4:sw=4:expandtab
+
+use i3test;
+use File::Temp;
+
+my $x = X11::XCB::Connection->new;
+
+

This is what we call boilerplate. It exists at the top of every test file (to +some extent). The first line is the shebang, which specifies that this file is +a Perl script. The second line contains VIM specific settings on how to +edit/format this file (use spaces instead of tabs, indent using 4 spaces). +Afterwards, the i3test module is used. This module contains i3 testsuite +specific functions which you are strongly encouraged to use. They make writing +testcases a lot easier and will make it easier for other people to read your +tests.

+

The next line uses the File::Temp module. This is specific to this testcase, +because it needs to generate a temporary name during the test. Many testcases +use only the i3test module.

+

The last line opens a connection to X11. You might or might not need this in +your testcase, depending on whether you are going to open windows (etc.) or +only use i3 commands.

+
+
t/11-goto.t: Setup
+
+
my $tmp = fresh_workspace;
+
+cmd 'split h';
+
+

The first line calls i3test’s fresh_workspace function which looks for a +currently unused workspace, switches to it, and returns its name. The variable +$tmp will end up having a value such as "/tmp/87kBVcHbA9". Note that this +is not (necessarily) a valid path, it’s just a random workspace name.

+

So, now that we are on a new workspace, we ensure that the workspace uses +horizontal orientation by issuing the split h command (see the i3 User’s +Guide for a list of commands). This is not strictly necessary, but good style. +In general, the cmd function executes the specified i3 command by using the +IPC interface and returns once i3 acknowledged the command.

+
+
t/11-goto.t: Setup
+
+
#####################################################################
+# Create two windows and make sure focus switching works
+#####################################################################
+
+my $top = open_window($x);
+my $mid = open_window($x);
+my $bottom = open_window($x);
+
+

In every major section of a testcase, you should put a comment like the one +above. This makes it immediately clear how the file is structured.

+

The open_window function opens a standard window, which will then be put into +tiling mode by i3. If you want a floating window, use the +open_floating_window function. These functions accept the same parameters as +X11::XCB::Window→new, see the i3test documentation at TODO.

+
+
t/11-goto.t: Helper function
+
+
#
+# Returns the input focus after sending the given command to i3 via IPC
+# and syncing with i3
+#
+sub focus_after {
+    my $msg = shift;
+
+    cmd $msg;
+    sync_with_i3 $x;
+    return $x->input_focus;
+}
+
+

This section defines a helper function which will be used over and over in this +testcase. If you have code which gets executed more than once or twice +(depending on the length of your test, use your best judgement), please put it +in a function. Tests should be short, concise and clear.

+

The focus_after function executes a command and returns the X11 focus after +the command was executed. The sync_with_i3 command makes sure that i3 could +push its state to X11. See [i3_sync] to learn how this works exactly.

+
+
t/11-goto.t: Test assumptions
+
+
$focus = $x->input_focus;
+is($focus, $bottom->id, "Latest window focused");
+
+$focus = focus_after('focus left');
+is($focus, $mid->id, "Middle window focused");
+
+

Now, we run the first two real tests. They use Test::More's is function, +which compares two values and prints the differences if they are not the same. +After the arguments, we supply a short comment to indicate what we are testing +here. This makes it vastly more easy for the developer to spot which testcase +is the problem in case one fails.

+

The first test checks that the most recently opened window is focused. +Afterwards, the command focus left is issued and it is verified that the +middle window now has focus.

+

Note that this is not a comprehensive test of the focus command — we would +have to test wrapping, focus when using a more complex layout, focusing the +parent/child containers, etc. But that is not the point of this testcase. +Instead, we just want to know if $x→input_focus corresponds with what we are +expecting. If not, something is completely wrong with the test environment and +this trivial test will fail.

+
+
t/11-goto.t: Test that the feature does not work (yet)
+
+
#####################################################################
+# Now goto a mark which does not exist
+#####################################################################
+
+my $random_mark = mktemp('mark.XXXXXX');
+
+$focus = focus_after(qq|[con_mark="$random_mark"] focus|);
+is($focus, $mid->id, "focus unchanged");
+
+

Syntax hint: The qq keyword is the interpolating quote operator. It lets you +chose a quote character (in this case the | character, a pipe). This makes +having double quotes in our string easy.

+

In this new major section, a random mark (mark is an identifier for a window, +see "VIM-like marks" in the i3 User’s Guide) will be generated. Afterwards, we +test that trying to focus that mark will not do anything. This is important: Do +not only test that using a feature has the expected outcome, but also test that +using it without properly initializing it does no harm. This command could for +example have changed focus anyways (a bug) or crash i3 (obviously a bug).

+
+
t/11-goto.t: Test that the feature does work
+
+
cmd "mark $random_mark";
+
+$focus = focus_after('focus left');
+is($focus, $top->id, "Top window focused");
+
+$focus = focus_after(qq|[con_mark="$random_mark"] focus|);
+is($focus, $mid->id, "goto worked");
+
+

Remember: Focus was on the middle window (we verified that earlier in "Test +assumptions"). We now mark the middle window with our randomly generated mark. +Afterwards, we switch focus away from the middle window to be able to tell if +focusing it via its mark will work. If the test works, the goto command seems +to be working.

+
+
t/11-goto.t: Test corner case
+
+
# check that we can specify multiple criteria
+
+$focus = focus_after('focus left');
+is($focus, $top->id, "Top window focused");
+
+$focus = focus_after(qq|[con_mark="$random_mark" con_mark="$random_mark"] focus|);
+is($focus, $mid->id, "goto worked");
+
+

Now we test the same feature, but specifying the mark twice in the command. +This should have no effect, but let’s be sure: test it and see if things go +wrong.

+
+
t/11-goto.t: Test second code path
+
+
#####################################################################
+# Check whether the focus command will switch to a different
+# workspace if necessary
+#####################################################################
+
+my $tmp2 = fresh_workspace;
+
+is(focused_ws(), $tmp2, 'tmp2 now focused');
+
+cmd qq|[con_mark="$random_mark"] focus|;
+
+is(focused_ws(), $tmp, 'tmp now focused');
+
+

This part of the test checks that focusing windows by mark works across +workspaces. It uses i3test’s focused_ws function to get the current +workspace.

+
+
t/11-goto.t: Test second code path
+
+
done_testing;
+
+

The end of every testcase has to contain the done_testing line. This tells +complete-run.pl that the test was finished successfully. If it does not +occur, the test might have crashed during execution — some of the reasons why +that could happen are bugs in the used modules, bugs in the testcase itself or +an i3 crash resulting in the testcase being unable to communicate with i3 via +IPC anymore.

+
+
+
+

Appendix A: The I3_SYNC protocol

+
+

Consider the following situation: You open two windows in your testcase, then +you use focus left and want to verify that the X11 focus has been updated +properly. Sounds simple, right? Let’s assume you use this straight-forward +implementation:

+
+
Racey focus testcase
+
+
my $left = open_window($x);
+my $right = open_window($x);
+cmd 'focus left';
+is($x->input_focus, $left->id, 'left window focused');
+
+

However, the test fails. Sometimes. Apparently, there is a race condition in +your test. If you think about it, this is because you are using two different +pieces of software: You tell i3 to update focus, i3 confirms that, and then you +ask X11 to give you the current focus. There is a certain time that the X11 +server needs to process the requests from i3. If the testcase’s request for the +input focus is processed before i3’s requests, the test will fail.

+
+
+Diagram of the race condition +
+
Figure 1. Diagram of the race condition
+
+

One way to "solve" this would be to add sleep 0.5; after the cmd call. +After 0.5 seconds it should be safe to assume that focus has been updated, +right?

+

In practice, this usually works. However, it has several problems:

+
    +
  1. +

    +This is obviously not a clean solution, but a workaround. Ugly. +

    +
    2. +
  2. +

    +On very slow machines, this might not work. Unlikely, but in different + situations (a delay to wait for i3 to startup) the necessary time is much + harder to guess, even for fast machines. +

    +
    3. +
  3. +

    +This wastes a lot of time. Usually, your computer is much faster than 0.5s + to update the status. However, sometimes, it might take 0.4s, so we can’t + make it sleep 0.1. +

    +
    4. +
+

To illustrate how grave the problem with wasting time actually is: Before +removing all sleeps from the testsuite, a typical run using 4 separate X +servers took around 50 seconds on my machine. After removing all the sleeps, +we achieved times of about 25 seconds. This is very significant and influences +the way you think about tests — the faster they are, the more likely you are +to check whether everything still works quite often (which you should).

+

What I am trying to say is: Delays adds up quickly and make the test suite +less robust.

+

The real solution for this problem is a mechanism which I call "the i3 sync +protocol". The idea is to send a request (which does not modify state) via X11 +to i3 which will then be answered, again via X11. Because this answer is +generated via an X11 request, it will be sent to the X11 server after all +previous requests. Thus, you can be sure that by the time you receive the reply, +all other events have been dealt with by i3 (and, more importantly, X11).

+
+
+Diagram of the i3 sync solution +
+
Figure 2. Diagram of the i3 sync solution
+
+
+

Implementation details

+

The client which wants to sync with i3 initiates the protocol by sending a +ClientMessage to the X11 root window:

+
+
Send ClientMessage
+
+
# Generate a ClientMessage, see xcb_client_message_t
+my $msg = pack "CCSLLLLLLL",
+    CLIENT_MESSAGE, # response_type
+    32,     # format
+    0,      # sequence
+    $root,  # destination window
+    $x->atom(name => 'I3_SYNC')->id,
+
+    $_sync_window->id,    # data[0]: our own window id
+    $myrnd, # data[1]: a random value to identify the request
+    0,
+    0,
+    0;
+
+# Send it to the root window -- since i3 uses the SubstructureRedirect
+# event mask, it will get the ClientMessage.
+$x->send_event(0, $root, EVENT_MASK_SUBSTRUCTURE_REDIRECT, $msg);
+
+

i3 will then reply with the same ClientMessage, sent to the window specified in +data[0]. In the reply, data[0] and data[1] are exactly the same as in the +request. You should use a random value in data[1] and check that you received +the same one when getting the reply.

+
+
+
+
+

Appendix B: The sync IPC command

+
+

The above I3_SYNC protocol allows to synchronise with i3. However, it is not +enough for tests that also involve i3bar: There might still be messages from +i3bar in-flight even after synchronising with i3. Thus, there also exists a sync +IPC command, that is however not meant to be used directly. Instead, i3bar uses +it for implementing the I3_SYNC protocol.

+

The intended usage works like this:

+
    +
  1. +

    +You send an I3_SYNC message to i3bar’s window. See [i3_sync]. +

    +
    2. +
  2. +

    +i3bar sends a SYNC IPC command to i3 with payload + {"window":your-window-here,"rnd":your-random-value}. +

    +
    3. +
  3. +

    +i3 reacts to this IPC command as if it received an I3_SYNC request via X11. +

    +
    4. +
+

This protocol is used, for example, in t/525-i3bar-mouse-bindings.t: A mouse +button press on i3bar is triggered. i3bar reacts to this by sending IPC commands +to i3.

+

The necessary synchronisation is achieved by sending an I3_SYNC event to i3bar: +Because i3bar reacts with a sync IPC command to i3, all previous IPC commands from +i3bar will be handled first. Because i3 reacts via X11, all previous X11 +requests from i3 will be handled by the X11 server first.

+

The actual test also has to sync with i3 first due to how X11 handling works. +For more details, refer to the documentation for XAllowEvents with mode +ReplayPointer.

+
+
+
+

Appendix C: Socket activation

+
+

Socket activation is a mechanism which was made popular by systemd, an init +replacement. It basically describes creating a listening socket before starting +a program. systemd will invoke the program only when an actual connection to +the socket is made, hence the term socket activation.

+

The interesting part of this (in the i3 context) is that you can very precisely +detect when the program is ready (finished its initialization).

+
+

Preparing the listening socket

+

complete-run.pl will create a listening UNIX socket which it will then pass +to i3. This socket will be used by i3 as an additional IPC socket, just like +the one it will create on its own. Passing the socket happens implicitly +because children will inherit the parent’s sockets when fork()ing and sockets +will continue to exist after an exec() call (unless CLOEXEC is set of course).

+

The only explicit things complete-run.pl has to do is setting the LISTEN_FDS +environment variable to the number of sockets which exist (1 in our case) and +setting the LISTEN_PID environment variable to the current process ID. Both +variables are necessary so that the program (i3) knows how many sockets it +should use and if the environment variable is actually intended for it. i3 will +then start looking for sockets at file descriptor 3 (since 0, 1 and 2 are used +for stdin, stdout and stderr, respectively).

+

The actual Perl code which sets up the socket, fork()s, makes sure the socket +has file descriptor 3 and sets up the environment variables follows (shortened +a bit):

+
+
Setup socket and environment
+
+
my $socket = IO::Socket::UNIX->new(
+    Listen => 1,
+    Local => $args{unix_socket_path},
+);
+
+my $pid = fork;
+if ($pid == 0) {
+    $ENV{LISTEN_PID} = $$;
+    $ENV{LISTEN_FDS} = 1;
+
+    # Only pass file descriptors 0 (stdin), 1 (stdout),
+    # 2 (stderr) and 3 (socket) to the child.
+    $^F = 3;
+
+    # If the socket does not use file descriptor 3 by chance
+    # already, we close fd 3 and dup2() the socket to 3.
+    if (fileno($socket) != 3) {
+        POSIX::close(3);
+        POSIX::dup2(fileno($socket), 3);
+    }
+
+    exec "/usr/bin/i3";
+}
+
+
+
+

Waiting for a reply

+

In the parent process, we want to know when i3 is ready to answer our IPC +requests and handle our windows. Therefore, after forking, we immediately close +the listening socket (i3 will handle this side of the socket) and connect to it +(remember, we are talking about a named UNIX socket) as a client. This connect +call will immediately succeed because the kernel buffers it. Then, we send a +request (of type GET_TREE, but that is not really relevant). Writing data to +the socket will also succeed immediately because, again, the kernel buffers it +(only up to a certain amount of data of course).

+

Afterwards, we just blockingly wait until we get an answer. In the child +process, i3 will setup the listening socket in its event loop. Immediately +after actually starting the event loop, it will notice a new client connecting +(the parent process) and handle its request. Since all initialization has been +completed successfully by the time the event loop is entered, we can now assume +that i3 is ready.

+
+
+

Timing and conclusion

+

A beautiful feature of this mechanism is that it does not depend on timing. It +does not matter when the child process gets CPU time or when the parent process +gets CPU time. On heavily loaded machines (or machines with multiple CPUs, +cores or unreliable schedulers), this makes waiting for i3 much more robust.

+

Before using socket activation, we typically used a sleep(1) and hoped that +i3 was initialized by that time. Of course, this breaks on some (slow) +computers and wastes a lot of time on faster computers. By using socket +activation, we decreased the total amount of time necessary to run all tests +(72 files at the time of writing) from > 100 seconds to 16 seconds. This makes +it significantly more attractive to run the test suite more often (or at all) +during development.

+

An alternative approach to using socket activation is polling for the existence +of the IPC socket and connecting to it. While this might be slightly easier to +implement, it wastes CPU time and is considerably uglier than this solution +:). After all, lib/SocketActivation.pm contains only 54 SLOC.

+
+
+
+
+
+ + + diff --git a/docs/tree-layout1.png b/docs/tree-layout1.png new file mode 100644 index 0000000..ee69f1a Binary files /dev/null and b/docs/tree-layout1.png differ diff --git a/docs/tree-layout2.png b/docs/tree-layout2.png new file mode 100644 index 0000000..5cbadde Binary files /dev/null and b/docs/tree-layout2.png differ diff --git a/docs/tree-shot1.png b/docs/tree-shot1.png new file mode 100644 index 0000000..3bbeae1 Binary files /dev/null and b/docs/tree-shot1.png differ diff --git a/docs/tree-shot2.png b/docs/tree-shot2.png new file mode 100644 index 0000000..f003264 Binary files /dev/null and b/docs/tree-shot2.png differ diff --git a/docs/tree-shot3.png b/docs/tree-shot3.png new file mode 100644 index 0000000..fe4c11e Binary files /dev/null and b/docs/tree-shot3.png differ diff --git a/docs/tree-shot4.png b/docs/tree-shot4.png new file mode 100644 index 0000000..61e8c91 Binary files /dev/null and b/docs/tree-shot4.png differ diff --git a/docs/two_columns.png b/docs/two_columns.png new file mode 100644 index 0000000..6dc8c40 Binary files /dev/null and b/docs/two_columns.png differ diff --git a/docs/two_terminals.png b/docs/two_terminals.png new file mode 100644 index 0000000..20b45ac Binary files /dev/null and b/docs/two_terminals.png differ diff --git a/docs/userguide.html b/docs/userguide.html new file mode 100644 index 0000000..94e07ae --- /dev/null +++ b/docs/userguide.html @@ -0,0 +1,3800 @@ + + + + + + +i3: i3 User’s Guide + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+
+

This document contains all the information you need to configure and use the i3 +window manager. If it does not you can contact us on +GitHub Discussions, IRC, or the mailing +list.

+
+
+
+

Default keybindings

+
+

For the "too long; didn’t read" people, here is an overview of the default +keybindings (click to see the full-size image):

+

Keys to use with $mod (Alt):

+

+ +Keys to use with $mod (Alt) + +

+

Keys to use with Shift+$mod:

+

+ +Keys to use with Shift+$mod + +

+

The red keys are the modifiers you need to press (by default), the blue keys +are your homerow.

+

Note that when starting i3 without a config file, i3-config-wizard will offer +you to create a config file in which the key positions (!) match what you see +in the image above, regardless of the keyboard layout you are using. If you +prefer to use a config file where the key letters match what you are seeing +above, just decline i3-config-wizard’s offer and base your config on +/etc/i3/config.

+
+
+
+

Using i3

+
+

Throughout this guide, the keyword $mod will be used to refer to the +configured modifier. This is the Alt key (Mod1) by default, with the Windows +key (Mod4) being a popular alternative that largely prevents conflicts with +application-defined shortcuts.

+
+

Opening terminals and moving around

+

One very basic operation is opening a new terminal. By default, the keybinding +for this is $mod+Enter, that is Alt+Enter (Mod1+Enter) in the default +configuration. By pressing $mod+Enter, a new terminal will be opened. It +will fill the whole space available on your screen.

+

+Single terminal +

+

If you now open another terminal, i3 will place it next to the current one, +splitting the screen size in half. Depending on your monitor, i3 will put the +created window beside the existing window (on wide displays) or below the +existing window (rotated displays).

+

+Two terminals +

+

To move the focus between the two terminals, you can use the arrow keys. For +convenience, the arrows are also available directly on the +keyboard’s home row underneath your +right hand:

+
+ +++ + + + + + + + + + + + + + + + + + +

$mod+j

left

$mod+k

down

$mod+l

up

$mod+;

right

+
+

Note that this differs by one key from the popular text editor vi, which was +developed on an +ADM-3A terminal and therefore uses hjkl instead of jkl; — i3’s default is +meant to require minimal finger movement, but some vi users change their i3 +config for consistency.

+

At the moment, your workspace is split (it contains two terminals) in a +specific direction (horizontal by default). Every window can be split +horizontally or vertically again, just like the workspace. The terminology is +"window" for a container that actually contains an X11 window (like a terminal +or browser) and "split container" for containers that consist of one or more +windows.

+

To split a window vertically, press $mod+v before you create the new window. +To split it horizontally, press $mod+h.

+
+
+

Changing the container layout

+

A split container can have one of the following layouts:

+
+
+splith/splitv +
+
+

+Windows are sized so that every window gets an equal amount of space in the +container. splith distributes the windows horizontally (windows are right next +to each other), splitv distributes them vertically (windows are on top of each +other). +

+
+
+stacking +
+
+

+Only the focused window in the container is displayed. You get a list of +windows at the top of the container. +

+
+
+tabbed +
+
+

+The same principle as stacking, but the list of windows at the top is only +a single line which is vertically split. +

+
+
+

To switch modes, press $mod+e for splith/splitv (it toggles), $mod+s for +stacking and $mod+w for tabbed.

+

+Container modes +

+
+
+

Toggling fullscreen mode for a window

+

To display a window in fullscreen mode or to go out of fullscreen mode again, +press $mod+f.

+

There is also a global fullscreen mode in i3 in which the client will span all +available outputs (the command is fullscreen toggle global).

+
+
+

Opening other applications

+

Aside from opening applications from a terminal, you can also use the handy +dmenu which is opened by pressing $mod+d by default. Just type the name +(or a part of it) of the application which you want to open. The corresponding +application has to be in your $PATH for this to work.

+

Additionally, if you have applications you open very frequently, you can +create a keybinding for starting the application directly. See the section +[configuring] for details.

+
+
+

Closing windows

+

If an application does not provide a mechanism for closing (most applications +provide a menu, the escape key or a shortcut like Control+w to close), you +can press $mod+Shift+q to kill a window. For applications which support +the WM_DELETE protocol, this will correctly close the application (saving +any modifications or doing other cleanup). If the application doesn’t support +the WM_DELETE protocol your X server will kill the window and the behaviour +depends on the application.

+
+
+

Using workspaces

+

Workspaces are an easy way to group a set of windows. By default, you are on +the first workspace, as the bar on the bottom left indicates. To switch to +another workspace, press $mod+num where num is the number of the workspace +you want to use. If the workspace does not exist yet, it will be created.

+

A common paradigm is to put the web browser on one workspace, communication +applications (mutt, irssi, …) on another one, and the ones with which you +work, on the third one. Of course, there is no need to follow this approach.

+

If you have multiple screens, a workspace will be created on each screen at +startup. If you open a new workspace, it will be bound to the screen you +created it on. When you switch to a workspace on another screen, i3 will set +focus to that screen.

+
+
+

Moving windows to workspaces

+

To move a window to another workspace, simply press $mod+Shift+num where +num is (like when switching workspaces) the number of the target workspace. +Similarly to switching workspaces, the target workspace will be created if +it does not yet exist.

+
+
+

Resizing

+

The easiest way to resize a container is by using the mouse: Grab the border +and move it to the wanted size.

+

You can also use [binding_modes] to define a mode for resizing via the +keyboard. To see an example for this, look at the +default config provided +by i3.

+
+
+

Restarting i3 inplace

+

To restart i3 in place (and thus get into a clean state if there is a bug, or +to upgrade to a newer version of i3) you can use $mod+Shift+r.

+
+
+

Exiting i3

+

To cleanly exit i3 without killing your X server, you can use $mod+Shift+e. +By default, a dialog will ask you to confirm if you really want to quit.

+
+
+

Floating

+

Floating mode is the opposite of tiling mode. The position and size of +a window are not managed automatically by i3, but manually by +you. Using this mode violates the tiling paradigm but can be useful +for some corner cases like "Save as" dialog windows, or toolbar +windows (GIMP or similar). Those windows usually set the appropriate +hint and are opened in floating mode by default.

+

You can toggle floating mode for a window by pressing $mod+Shift+Space. By +dragging the window’s titlebar with your mouse you can move the window +around. By grabbing the borders and moving them you can resize the window. You +can also do that by using the [floating_modifier]. Another way to resize +floating windows using the mouse is to right-click on the titlebar and drag.

+

For resizing floating windows with your keyboard, see the resizing binding mode +provided by the i3 default config.

+

Floating windows are always on top of tiling windows.

+
+
+

Moving tiling containers with the mouse

+

Since i3 4.21, it’s possible to drag tiling containers using the mouse. The +drag can be initiated either by dragging the window’s titlebar or by pressing +the [floating_modifier] and dragging the container while holding the +left-click button. See the [config_tiling_drag] option for configuring which +action triggers the tiling drag.

+

Once the drag is initiated and the cursor has left the original container, drop +indicators are created according to the position of the cursor relatively to +the target container. These indicators help you understand what the resulting +[tree] layout is going to be after you release the mouse button.

+

The possible drop positions are:

+
+
+Drop on container +
+
+

+ This happens when the mouse is relatively near the center of a container. + If the mouse is released, the result is exactly as if you had run the + move container to mark command. See [move_to_mark]. + If the swap modifier is pressed before initiating the drag (tiling_drag + swap_modifier set to Shift by default), the containers are swapped + instead. In that case, the result is exactly as if you had run the swap + container with mark command. See [swapping_containers]. +

+
+
+Drop as sibling +
+
+

+ This happens when the mouse is relatively near the edge of a container. If + the mouse is released, the dragged container will become a sibling of the + target container, placed left/right/up/down according to the position of + the indicator. + This might or might not create a new v-split or h-split according to the + previous layout of the target container. For example, if the target + container is in an h-split and you drop the dragged container below it, the + new layout will have to be a v-split. +

+
+
+Drop to parent +
+
+

+ This happens when the mouse is relatively near the edge of a container (but + even closer to the border in comparison to the sibling case above) and if + that edge is also the parent container’s edge. For example, if three + containers are in a horizontal layout then edges where this can happen is + the left edge of the left container, the right edge of the right container + and all bottom and top edges of all three containers. + If the mouse is released, the container is first dropped as a sibling to + the target container, like in the case above, and then is moved + directionally like with the move left|right|down|up command. See + [move_direction]. +

+
+
+

The color of the indicator matches the client.focused setting. See [client_colors].

+
+
+
+
+

Tree

+
+

i3 stores all information about the X11 outputs, workspaces and layout of the +windows on them in a tree. The root node is the X11 root window, followed by +the X11 outputs, then dock areas and a content container, then workspaces and +finally the windows themselves. In previous versions of i3 we had multiple lists +(of outputs, workspaces) and a table for each workspace. That approach turned +out to be complicated to use (snapping), understand and implement.

+
+

The tree consists of Containers

+

The building blocks of our tree are so-called Containers. A Container can +host a window (meaning an X11 window, one that you can actually see and use, +like a browser). Alternatively, it could contain one or more Containers. A +simple example is the workspace: When you start i3 with a single monitor, a +single workspace and you open two terminal windows, you will end up with a tree +like this:

+
+
+layout2 +
+
+
+
+shot4 +
+
Figure 1. Two terminals on standard workspace
+
+
+
+

Orientation and Split Containers

+

It is only natural to use so-called Split Containers in order to build a +layout when using a tree as data structure. In i3, every Container has an +orientation (horizontal, vertical or unspecified) and the orientation depends +on the layout the container is in (vertical for splitv and stacking, horizontal +for splith and tabbed). So, in our example with the workspace, the default +layout of the workspace Container is splith (most monitors are widescreen +nowadays). If you change the layout to splitv ($mod+v in the default config) +and then open two terminals, i3 will configure your windows like this:

+
+
+shot2 +
+
Figure 2. Vertical Workspace Orientation
+
+

An interesting new feature of i3 since version 4 is the ability to split anything: +Let’s assume you have two terminals on a workspace (with splith layout, that is +horizontal orientation), focus is on the right terminal. Now you want to open +another terminal window below the current one. If you would just open a new +terminal window, it would show up to the right due to the splith layout. +Instead, press $mod+v to split the container with the splitv layout (to +open a Horizontal Split Container, use $mod+h). Now you can open a new +terminal and it will open below the current one:

+
+
+Layout +
+
+
+
+shot +
+
Figure 3. Vertical Split Container
+
+
+

You probably guessed it already: There is no limit on how deep your hierarchy +of splits can be.

+
+
+

Focus parent

+

Let’s stay with our example from above. We have a terminal on the left and two +vertically split terminals on the right, focus is on the bottom right one. When +you open a new terminal, it will open below the current one.

+

So, how can you open a new terminal window to the right of the current one? +The solution is to use focus parent, which will focus the Parent Container of +the current Container. In default configuration, use $mod+a to navigate one +Container up the tree (you can repeat this multiple times until you get to the +Workspace Container). In this case, you would focus the Vertical Split Container +which is inside the horizontally oriented workspace. Thus, now new windows will be +opened to the right of the Vertical Split Container:

+
+
+shot3 +
+
Figure 4. Focus parent, then open new terminal
+
+
+
+

Implicit containers

+

In some cases, i3 needs to implicitly create a container to fulfill your +command.

+

One example is the following scenario: You start i3 with a single monitor and a +single workspace on which you open three terminal windows. All these terminal +windows are directly attached to one node inside i3’s layout tree, the +workspace node. By default, the workspace node’s orientation is horizontal.

+

Now you move one of these terminals down ($mod+Shift+k by default). The +workspace node’s orientation will be changed to vertical. The terminal window +you moved down is directly attached to the workspace and appears on the bottom +of the screen. A new (horizontal) container was created to accommodate the +other two terminal windows. You will notice this when switching to tabbed mode +(for example). You would end up having one tab with a representation of the split +container (e.g., "H[urxvt firefox]") and the other one being the terminal window +you moved down.

+
+
+
+
+

Configuring i3

+
+

This is where the real fun begins ;-). Most things are very dependent on your +ideal working environment so we can’t make reasonable defaults for them.

+

While not using a programming language for the configuration, i3 stays +quite flexible in regards to the things you usually want your window manager +to do.

+

For example, you can configure bindings to jump to specific windows, +you can set specific applications to start on specific workspaces, you can +automatically start applications, you can change the colors of i3, and you +can bind your keys to do useful things.

+

To change the configuration of i3, copy /etc/i3/config to ~/.i3/config +(or ~/.config/i3/config if you like the XDG directory scheme) and edit it +with a text editor.

+

On first start (and on all following starts, unless you have a configuration +file), i3 will offer you to create a configuration file. You can tell the +wizard to use either Alt (Mod1) or Windows (Mod4) as modifier in the config +file. Also, the created config file will use the key symbols of your current +keyboard layout. To start the wizard, use the command i3-config-wizard. +Please note that you must not have ~/.i3/config, otherwise the wizard will +exit.

+
+

Include directive

+

Since i3 v4.20, it is possible to include other configuration files from your i3 +configuration.

+

Syntax:

+
+
+
include <pattern>
+
+

i3 expands pattern using shell-like word expansion, specifically using the +wordexp(3) C standard library function.

+

Examples:

+
+
+
# Tilde expands to the user’s home directory:
+include ~/.config/i3/assignments.conf
+
+# Environment variables are expanded:
+include $HOME/.config/i3/assignments.conf
+
+# Wildcards are expanded:
+include ~/.config/i3/config.d/*.conf
+
+# Command substitution:
+include ~/.config/i3/`hostname`.conf
+
+# i3 loads each path only once, so including the i3 config will not result
+# in an endless loop, but in an error:
+include ~/.config/i3/config
+
+# i3 changes the working directory while parsing a config file
+# so that relative paths are interpreted relative to the directory
+# of the config file that contains the path:
+include assignments.conf
+
+

If a specified file cannot be read, for example because of a lack of file +permissions, or because of a dangling symlink, i3 will report an error and +continue processing your remaining configuration.

+

To list all loaded configuration files, run i3 --moreversion:

+
+
+
% i3 --moreversion
+Binary i3 version:  4.19.2-87-gfcae64f7+ © 2009 Michael Stapelberg and contributors
+Running i3 version: 4.19.2-87-gfcae64f7+ (pid 963940)
+Loaded i3 config:
+  /tmp/i3.cfg (main) (last modified: 2021-05-13T16:42:31 CEST, 463 seconds ago)
+  /tmp/included.cfg (included) (last modified: 2021-05-13T16:42:43 CEST, 451 seconds ago)
+  /tmp/another.cfg (included) (last modified: 2021-05-13T16:42:46 CEST, 448 seconds ago)
+
+

Variables are shared between all config files, but beware of the following limitation:

+
    +
  • +

    +You can define a variable and use it within an included file. +

    +
    • +
  • +

    +You cannot use (in the parent file) a variable that was defined within an included file. +

    +
    • +
+

This is a technical limitation: variable expansion happens in a separate stage +before parsing include directives.

+

Conceptually, included files can only add to the configuration, not undo the +effects of already-processed configuration. For example, you can only add new +key bindings, not overwrite or remove existing key bindings. This means:

+
    +
  • +

    +The include directive is suitable for organizing large configurations into + separate files, possibly selecting files based on conditionals. +

    +
    • +
  • +

    +The include directive is not suitable for expressing “use the default + configuration with the following changes”. For that case, we still recommend + copying and modifying the default config. +

    +
    • +
+
+ + + +
+
Note
+		 +

Implementation-wise, i3 does not currently construct one big configuration from +all include directives. Instead, i3’s config file parser interprets all +configuration directives in its parse_file() function. When processing an +include configuration directive, the parser recursively calls parse_file().

+

This means the evaluation order of files forms a tree, or one could say i3 uses +depth-first traversal.

+
+
+
+
+

Comments

+

It is possible and recommended to use comments in your configuration file to +properly document your setup for later reference. Comments are started with +a # and can only be used at the beginning of a line:

+

Examples:

+
+
+
# This is a comment
+
+
+
+

Fonts

+

i3 has support for both X core fonts and FreeType fonts (through Pango) to +render window titles.

+

To generate an X core font description, you can use xfontsel(1). To see +special characters (Unicode), you need to use a font which supports the +ISO-10646 encoding.

+

A FreeType font description is composed by a font family, a style, a weight, +a variant, a stretch and a size. +FreeType fonts support right-to-left rendering and contain often more +Unicode glyphs than X core fonts.

+

If i3 cannot open the configured font, it will output an error in the logfile +and fall back to a working font.

+

Syntax:

+
+
+
font <X core font description>
+font pango:<family list> [<style options>] <size>
+
+

Examples:

+
+
+
font -misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1
+font pango:DejaVu Sans Mono 10
+font pango:DejaVu Sans Mono, Terminus Bold Semi-Condensed 11
+font pango:Terminus 11px
+
+
+
+

Keyboard bindings

+

A keyboard binding makes i3 execute a command (see below) upon pressing a +specific key. i3 allows you to bind either on keycodes or on keysyms (you can +also mix your bindings, though i3 will not protect you from overlapping ones).

+
    +
  • +

    +A keysym (key symbol) is a description for a specific symbol, like "a" + or "b", but also more strange ones like "underscore" instead of "_". These + are the ones you use in Xmodmap to remap your keys. To get the current + mapping of your keys, use xmodmap -pke. To interactively enter a key and + see what keysym it is configured to, use xev. +

    +
    • +
  • +

    +Keycodes do not need to have a symbol assigned (handy for custom vendor + hotkeys on some notebooks) and they will not change their meaning as you + switch to a different keyboard layout (when using xmodmap). +

    +
    • +
+

My recommendation is: If you often switch keyboard layouts but you want to keep +your bindings in the same physical location on the keyboard, use keycodes. +If you don’t switch layouts, and want a clean and simple config file, use +keysyms.

+

Some tools (such as xdotool) might be unable to run upon a +KeyPress event, because the keyboard is still grabbed. For these +situations, the --release flag can be used, which will execute the command +after the keys have been released.

+

Syntax:

+
+
+
bindsym [--release] [<Group>+][<Modifiers>+]<keysym> command
+bindcode [--release] [<Group>+][<Modifiers>+]<keycode> command
+
+

Examples:

+
+
+
# Fullscreen
+bindsym $mod+f fullscreen toggle
+
+# Restart
+bindsym $mod+Shift+r restart
+
+# Notebook-specific hotkeys
+bindcode 214 exec --no-startup-id /home/michael/toggle_beamer.sh
+
+# Simulate ctrl+v upon pressing $mod+x
+bindsym --release $mod+x exec --no-startup-id xdotool key --clearmodifiers ctrl+v
+
+# Take a screenshot upon pressing $mod+x (select an area)
+bindsym --release $mod+x exec --no-startup-id import /tmp/latest-screenshot.png
+
+

Available Modifiers:

+
+
+Mod1-Mod5, Shift, Control +
+
+

+Standard modifiers, see xmodmap(1) +

+
+
+Group1, Group2, Group3, Group4 +
+
+

+When using multiple keyboard layouts (e.g. with setxkbmap -layout us,ru), you +can specify in which XKB group (also called “layout”) a keybinding should be +active. By default, keybindings are translated in Group1 and are active in all +groups. If you want to override keybindings in one of your layouts, specify the +corresponding group. For backwards compatibility, the group “Mode_switch” is an +alias for Group2. +

+
+
+
+
+

Mouse bindings

+

A mouse binding makes i3 execute a command upon pressing a specific mouse +button in the scope of the clicked container (see [command_criteria]). You +can configure mouse bindings in a similar way to key bindings.

+

Syntax:

+
+
+
bindsym [--release] [--border] [--whole-window] [--exclude-titlebar] [<Modifiers>+]button<n> command
+
+

By default, the binding will only run when you click on the titlebar of the +window. If the --release flag is given, it will run when the mouse button +is released.

+

If the --whole-window flag is given, the binding will also run when any part +of the window is clicked, with the exception of the border. To have a bind run +when the border is clicked, specify the --border flag.

+

If the --exclude-titlebar flag is given, the titlebar will not be considered +for the keybinding.

+

Examples:

+
+
+
# The middle button over a titlebar kills the window
+bindsym --release button2 kill
+
+# The middle button and a modifier over any part of the window kills the window
+bindsym --whole-window $mod+button2 kill
+
+# The right button toggles floating
+bindsym button3 floating toggle
+bindsym $mod+button3 floating toggle
+
+# The side buttons move the window around
+bindsym button9 move left
+bindsym button8 move right
+
+
+
+

Binding modes

+

You can have multiple sets of bindings by using different binding modes. When +you switch to another binding mode, all bindings from the current mode are +released and only the bindings defined in the new mode are valid for as long as +you stay in that binding mode. The only predefined binding mode is default, +which is the mode i3 starts out with and to which all bindings not defined in a +specific binding mode belong.

+

Working with binding modes consists of two parts: defining a binding mode and +switching to it. For these purposes, there are one config directive and one +command, both of which are called mode. The directive is used to define the +bindings belonging to a certain binding mode, while the command will switch to +the specified mode.

+

It is recommended to use binding modes in combination with [variables] in +order to make maintenance easier. Below is an example of how to use a binding +mode.

+

Note that it is advisable to define bindings for switching back to the default +mode.

+

Note that it is possible to use [pango_markup] for binding modes, but you +need to enable it explicitly by passing the --pango_markup flag to the mode +definition.

+

Syntax:

+
+
+
# config directive
+mode [--pango_markup] <name>
+
+# command
+mode <name>
+
+

Example:

+
+
+
# Press $mod+o followed by either f, t, Escape or Return to launch firefox,
+# thunderbird or return to the default mode, respectively.
+set $mode_launcher Launch: [f]irefox [t]hunderbird
+bindsym $mod+o mode "$mode_launcher"
+
+mode "$mode_launcher" {
+    bindsym f exec firefox
+    bindsym t exec thunderbird
+
+    bindsym Escape mode "default"
+    bindsym Return mode "default"
+}
+
+
+
+

The floating modifier

+

To move floating windows with your mouse, you can either grab their titlebar +or configure the so-called floating modifier which you can then press and +click anywhere in the window itself to move it. The most common setup is to +use the same key you use for managing windows (Mod1 for example). Then +you can press Mod1, click into a window using your left mouse button, and drag +it to the position you want.

+

When holding the floating modifier, you can resize a floating window by +pressing the right mouse button on it and moving around while holding it. If +you hold the shift button as well, the resize will be proportional (the aspect +ratio will be preserved).

+

Syntax:

+
+
+
floating_modifier <Modifier>
+
+

Example:

+
+
+
floating_modifier Mod1
+
+
+
+

Constraining floating window size

+

The maximum and minimum dimensions of floating windows can be specified. If +either dimension of floating_maximum_size is specified as -1, that dimension +will be unconstrained with respect to its maximum value. If either dimension of +floating_maximum_size is undefined, or specified as 0, i3 will use a default +value to constrain the maximum size. floating_minimum_size is treated in a +manner analogous to floating_maximum_size.

+

Syntax:

+
+
+
floating_minimum_size <width> x <height>
+floating_maximum_size <width> x <height>
+
+

Example:

+
+
+
floating_minimum_size 75 x 50
+floating_maximum_size -1 x -1
+
+
+
+

Orientation for new workspaces

+

New workspaces get a reasonable default orientation: Wide-screen monitors +(anything wider than high) get horizontal orientation, rotated monitors +(anything higher than wide) get vertical orientation.

+

With the default_orientation configuration directive, you can override that +behavior.

+

Syntax:

+
+
+
default_orientation horizontal|vertical|auto
+
+

Example:

+
+
+
default_orientation vertical
+
+
+
+

Layout mode for new containers

+

This option determines in which mode new containers on workspace level will +start.

+

Syntax:

+
+
+
workspace_layout default|stacking|tabbed
+
+

Example:

+
+
+
workspace_layout tabbed
+
+
+
+

Window title alignment

+

This option determines the window title’s text alignment. +Default is left

+

Syntax:

+
+
+
title_align left|center|right
+
+
+
+

Default border style for new windows

+

This option determines which border style new windows will have. The default is +normal. Note that default_floating_border applies only to windows which are starting out as +floating windows, e.g., dialog windows, but not windows that are floated later on.

+

Setting border style to pixel eliminates title bars in split layouts. The border style +normal allows you to adjust edge border width while keeping your title bar.

+

The title bar is always visible in stacking and tabbed layouts, and this cannot be changed +through configuration.

+

Syntax:

+
+
+
default_border normal|none|pixel
+default_border normal|pixel <px>
+default_floating_border normal|none|pixel
+default_floating_border normal|pixel <px>
+
+

Please note that new_window and new_float have been deprecated in favor of the above options +and will be removed in a future release. We strongly recommend using the new options instead.

+

Example:

+
+
+
default_border pixel
+
+

The "normal" and "pixel" border styles support an optional border width in +pixels:

+

Example:

+
+
+
# The same as default_border none
+default_border pixel 0
+
+# A 3 px border
+default_border pixel 3
+
+
+
+

Hiding borders adjacent to the screen edges

+

You can hide container borders adjacent to the screen edges using +hide_edge_borders (the default is none). Hiding borders is useful if you are +using scrollbars, or do not want to waste even two pixels in displayspace.

+

The "smart" setting hides borders on workspaces with only one window visible, +but keeps them on workspaces with multiple windows visible.

+

The "smart_no_gaps" setting hides edge-specific borders of a container if the +container is the only container on its workspace and the gaps to the screen edge +are 0.

+

hide_edge_borders has replaced the old smart_borders syntax. Use the former +instead of the latter.

+

Syntax:

+
+
+
hide_edge_borders none|vertical|horizontal|both|smart|smart_no_gaps
+
+

Example:

+
+
+
hide_edge_borders vertical
+
+
+
+

Arbitrary commands for specific windows (for_window)

+

With the for_window directive, you can let i3 execute any command when it +encounters a specific window. This can be used to set windows to floating or to +change their border style, for example.

+

Syntax:

+
+
+
for_window <criteria> <command>
+
+

Examples:

+
+
+
# enable floating mode for all XTerm windows
+for_window [class="XTerm"] floating enable
+
+# Make all urxvts use a 1-pixel border:
+for_window [class="urxvt"] border pixel 1
+
+# A less useful, but rather funny example:
+# makes the window floating as soon as I change
+# directory to ~/work
+for_window [title="x200: ~/work"] floating enable
+
+

The valid criteria are the same as those for commands, see [command_criteria]. Only +commands can be executed at runtime, not config directives, see [list_of_commands].

+
+
+

Don’t focus window upon opening

+

When a new window appears, it will be focused. The no_focus directive allows preventing +this from happening and must be used in combination with [command_criteria].

+

Note that this does not apply to all cases, e.g., when feeding data into a running application +causing it to request being focused. To configure the behavior in such cases, refer to +[focus_on_window_activation].

+

no_focus will also be ignored for the first window on a workspace as there shouldn’t be +a reason to not focus the window in this case. This allows for better usability in +combination with workspace_layout.

+

Syntax:

+
+
+
no_focus <criteria>
+
+

Example:

+
+
+
no_focus [window_role="pop-up"]
+
+
+
+

Variables

+

As you learned in the section about keyboard bindings, you will have +to configure lots of bindings containing modifier keys. If you want to save +yourself some typing and be able to change the modifier you use later, +variables can be handy.

+

Syntax:

+
+
+
set $<name> <value>
+
+

Example:

+
+
+
set $m Mod1
+bindsym $m+Shift+r restart
+
+

Variables are directly replaced in the file when parsing. Variables expansion +is not recursive so it is not possible to define a variable with a value +containing another variable. There is no fancy handling and there are +absolutely no plans to change this. If you need a more dynamic configuration +you should create a little script which generates a configuration file and run +it before starting i3 (for example in your ~/.xsession file).

+

Also see [xresources] to learn how to create variables based on resources +loaded from the X resource database.

+
+
+

X resources

+

[variables] can also be created using a value configured in the X resource +database. This is useful, for example, to avoid configuring color values within +the i3 configuration. Instead, the values can be configured, once, in the X +resource database to achieve an easily maintainable, consistent color theme +across many X applications.

+

Defining a resource will load this resource from the resource database and +assign its value to the specified variable. This is done verbatim and the value +must therefore be in the format that i3 uses. A fallback must be specified in +case the resource cannot be loaded from the database.

+

Syntax:

+
+
+
set_from_resource $<name> <resource_name> <fallback>
+
+

Example:

+
+
+
# The ~/.Xresources should contain a line such as
+#     *color0: #121212
+# and must be loaded properly, e.g., by using
+#     xrdb ~/.Xresources
+# This value is picked up on by other applications (e.g., the URxvt terminal
+# emulator) and can be used in i3 like this:
+set_from_resource $black i3wm.color0 #000000
+
+
+
+

Automatically putting clients on specific workspaces

+

To automatically make a specific window show up on a specific workspace, you +can use an assignment. You can match windows by using any criteria, +see [command_criteria]. The difference between assign and +for_window <criteria> move to workspace is that the former will only be +executed when the application maps the window (mapping means actually displaying +it on the screen) but the latter will be executed whenever a window changes its +properties to something that matches the specified criteria.

+

Thus, it is recommended that you match on window classes (and instances, when +appropriate) instead of window titles whenever possible because some +applications first create their window, and then worry about setting the correct +title. Firefox with Vimperator comes to mind. The window starts up being named +Firefox, and only when Vimperator is loaded does the title change. As i3 will +get the title as soon as the application maps the window, you’d need to have to +match on Firefox in this case. +Another known issue is with Spotify, which doesn’t set the class hints when +mapping the window, meaning you’ll have to use a for_window rule to assign +Spotify to a specific workspace. +Finally, using assign [tiling] and assign [floating] is not supported.

+

You can also assign a window to show up on a specific output. You can use RandR +names such as VGA1 or names relative to the output with the currently focused +workspace such as left and down.

+

Assignments are processed by i3 in the order in which they appear in the config +file. The first one which matches the window wins and later assignments are not +considered.

+

Syntax:

+
+
+
assign <criteria> [→] [workspace] [number] <workspace>
+assign <criteria> [→] output left|right|up|down|primary|nonprimary|<output>
+
+

Examples:

+
+
+
# Assign URxvt terminals to workspace 2
+assign [class="URxvt"] 2
+
+# Same thing, but more precise (exact match instead of substring)
+assign [class="^URxvt$"] 2
+
+# Same thing, but with a beautiful arrow :)
+assign [class="^URxvt$"] → 2
+
+# Assignment to a named workspace
+assign [class="^URxvt$"] → work
+
+# Assign to the workspace with number 2, regardless of name
+assign [class="^URxvt$"] → number 2
+
+# You can also specify a number + name. If the workspace with number 2 exists,
+# assign will skip the text part.
+assign [class="^URxvt$"] → number "2: work"
+
+# Start urxvt -name irssi
+assign [class="^URxvt$" instance="^irssi$"] → 3
+
+# Assign urxvt to the output right of the current one
+assign [class="^URxvt$"] → output right
+
+# Assign urxvt to the primary output
+assign [class="^URxvt$"] → output primary
+
+# Assign urxvt to the first non-primary output
+assign [class="^URxvt$"] → output nonprimary
+
+

Note that you might not have a primary output configured yet. To do so, run:

+
+
+
xrandr --output <output> --primary
+
+

Also, the arrow is not required, it just looks good :-). If you decide to +use it, it has to be a UTF-8 encoded arrow, not -> or something like that.

+

To get the class and instance, you can use xprop. After clicking on the +window, you will see the following output:

+

xprop:

+
+
+
WM_CLASS(STRING) = "irssi", "URxvt"
+
+

The first part of the WM_CLASS is the instance ("irssi" in this example), the +second part is the class ("URxvt" in this example).

+

Should you have any problems with assignments, make sure to check the i3 +logfile first (see https://i3wm.org/docs/debugging.html). It includes more +details about the matching process and the window’s actual class, instance and +title when starting up.

+

Note that if you want to start an application just once on a specific +workspace, but you don’t want to assign all instances of it permanently, you +can make use of i3’s startup-notification support (see [exec]) in your config +file in the following way:

+

Start iceweasel on workspace 3 (once):

+
+
+
# Start iceweasel on workspace 3, then switch back to workspace 1
+# (Being a command-line utility, i3-msg does not support startup notifications,
+#  hence the exec --no-startup-id.)
+# (Starting iceweasel with i3’s exec command is important in order to make i3
+#  create a startup notification context, without which the iceweasel window(s)
+#  cannot be matched onto the workspace on which the command was started.)
+exec --no-startup-id i3-msg 'workspace 3; exec iceweasel; workspace 1'
+
+
+
+

Automatically starting applications on i3 startup

+

By using the exec keyword outside a keybinding, you can configure +which commands will be performed by i3 on initial startup. exec +commands will not run when restarting i3, if you need a command to run +also when restarting i3 you should use the exec_always +keyword. These commands will be run in order.

+

See [command_chaining] for details on the special meaning of ; (semicolon) +and , (comma): they chain commands together in i3, so you need to use quoted +strings (as shown in [exec_quoting]) if they appear in your command.

+

Syntax:

+
+
+
exec [--no-startup-id] <command>
+exec_always [--no-startup-id] <command>
+
+

Examples:

+
+
+
exec chromium
+exec_always ~/my_script.sh
+
+# Execute the terminal emulator urxvt, which is not yet startup-notification aware.
+exec --no-startup-id urxvt
+
+

The flag --no-startup-id is explained in [exec].

+
+
+

Automatically putting workspaces on specific screens

+

If you assign clients to workspaces, it might be handy to put the +workspaces on specific screens. Also, the assignment of workspaces to screens +will determine which workspace i3 uses for a new screen when adding screens +or when starting (e.g., by default it will use 1 for the first screen, 2 for +the second screen and so on).

+

Syntax:

+
+
+
workspace <workspace> output <output1> [output2]…
+
+

The output is the name of the RandR output you attach your screen to. On a +laptop, you might have VGA1 and LVDS1 as output names. You can see the +available outputs by running xrandr --current.

+

If your X server supports RandR 1.5 or newer, i3 will use RandR monitor objects +instead of output objects. Run xrandr --listmonitors to see a list. Usually, +a monitor object contains exactly one output, and has the same name as the +output; but should that not be the case, you can specify the name of either the +monitor or the output in i3’s configuration. For example, the Dell UP2414Q uses +two scalers internally, so its output names might be “DP1” and “DP2”, but the +monitor name is “Dell UP2414Q”.

+

(Note that even if you specify the name of an output which doesn’t span the +entire monitor, i3 will still use the entire area of the containing monitor +rather than that of just the output’s.)

+

You can specify multiple outputs. The first available will be used.

+

If you use named workspaces, they must be quoted:

+

Examples:

+
+
+
workspace 1 output LVDS1
+workspace 2 output primary
+workspace 5 output VGA1 LVDS1
+workspace "2: vim" output VGA1
+
+
+
+

Changing colors

+

You can change all colors which i3 uses to draw the window decorations.

+

Syntax:

+
+
+
<colorclass> <border> <background> <text> <indicator> <child_border>
+
+

Where colorclass can be one of:

+
+
+client.focused +
+
+

+ A client which currently has the focus. +

+
+
+client.focused_inactive +
+
+

+ A client which is the focused one of its container, but it does not have + the focus at the moment. +

+
+
+client.focused_tab_title +
+
+

+ Tab or stack container title that is the parent of the focused container + but not directly focused. Defaults to focused_inactive if not specified and + does not use the indicator and child_border colors. +

+
+
+client.unfocused +
+
+

+ A client which is not the focused one of its container. +

+
+
+client.urgent +
+
+

+ A client which has its urgency hint activated. +

+
+
+client.placeholder +
+
+

+ Background and text color are used to draw placeholder window contents + (when restoring layouts). Border and indicator are ignored. +

+
+
+client.background +
+
+

+ Background color which will be used to paint the background of the + client window on top of which the client will be rendered. Only clients + which do not cover the whole area of this window expose the color. Note + that this colorclass only takes a single color. +

+
+
+

Colors are in HTML hex format (#rrggbb, optionally #rrggbbaa), see the following +example:

+

Examples (default colors):

+
+
+
# class                 border  backgr. text    indicator child_border
+client.focused          #4c7899 #285577 #ffffff #2e9ef4   #285577
+client.focused_inactive #333333 #5f676a #ffffff #484e50   #5f676a
+client.unfocused        #333333 #222222 #888888 #292d2e   #222222
+client.urgent           #2f343a #900000 #ffffff #900000   #900000
+client.placeholder      #000000 #0c0c0c #ffffff #000000   #0c0c0c
+
+client.background       #ffffff
+
+

Note that for the window decorations, the color around the child window is the +"child_border", and "border" color is only the two thin lines around the +titlebar.

+

The indicator color is used for indicating where a new window will be opened. +For horizontal split containers, the right border will be painted in indicator +color, for vertical split containers, the bottom border. This only applies to +single windows within a split container, which are otherwise indistinguishable +from single windows outside of a split container.

+
+
+

Interprocess communication

+

i3 uses Unix sockets to provide an IPC interface. This allows third-party +programs to get information from i3, such as the current workspaces +(to display a workspace bar), and to control i3.

+

By default, an IPC socket will be created in +$XDG_RUNTIME_DIR/i3/ipc-socket.%p if the directory is available, falling back +to /tmp/i3-%u.XXXXXX/ipc-socket.%p, where %u is your UNIX username, %p is +the PID of i3 and XXXXXX is a string of random characters from the portable +filename character set (see mkdtemp(3)).

+

You can override the default path through the environment-variable I3SOCK or +by specifying the ipc-socket directive. This is discouraged, though, since i3 +does the right thing by default. If you decide to change it, it is strongly +recommended to set this to a location in your home directory so that no other +user can create that directory.

+

Examples:

+
+
+
ipc-socket ~/.i3/i3-ipc.sock
+
+

You can then use the i3-msg application to perform any command listed in +[list_of_commands].

+
+
+

Focus follows mouse

+

By default, window focus follows your mouse movements as the mouse crosses +window borders. However, if you have a setup where your mouse usually is in your +way (like a touchpad on your laptop which you do not want to disable +completely), you might want to disable focus follows mouse and control focus +only by using your keyboard. The mouse will still be useful inside the +currently active window (for example to click on links in your browser window).

+

Syntax:

+
+
+
focus_follows_mouse yes|no
+
+

Example:

+
+
+
focus_follows_mouse no
+
+
+
+

Mouse warping

+

By default, when switching focus to a window on a different output (e.g. +focusing a window on workspace 3 on output VGA-1, coming from workspace 2 on +LVDS-1), the mouse cursor is warped to the center of that window.

+

With the mouse_warping option, you can control when the mouse cursor should +be warped. none disables warping entirely, whereas output is the default +behavior described above.

+

Syntax:

+
+
+
mouse_warping output|none
+
+

Example:

+
+
+
mouse_warping none
+
+
+
+

Popups during fullscreen mode

+

When you are in fullscreen mode, some applications still open popup windows +(take Xpdf for example). This is because these applications might not be aware +that they are in fullscreen mode (they do not check the corresponding hint). +i3 supports four options for this situation:

+
    +
  1. +

    +smart: Display the popup if it belongs to the fullscreen application only. + This is the default and should be reasonable behavior for most users. +

    +
    2. +
  2. +

    +ignore: Just ignore the popup (don’t map it). This won’t interrupt you + while you are in fullscreen. However, some apps might react badly to this + (deadlock until you go out of fullscreen). +

    +
    3. +
  3. +

    +leave_fullscreen: Leave fullscreen mode. +

    +
    4. +
  4. +

    +all: Since i3 4.24: Display all floating windows regardless to which + application they belong to. +

    +
    5. +
+

Syntax:

+
+
+
popup_during_fullscreen smart|ignore|leave_fullscreen|all
+
+

Example:

+
+
+
popup_during_fullscreen smart
+
+
+
+

Focus wrapping

+

By default, when in a container with several windows or child containers, the +opposite window will be focused when trying to move the focus over the edge of +a container (and there are no other containers in that direction) — the focus +wraps.

+

If desired, you can disable this behavior by setting the focus_wrapping +configuration directive to the value no.

+

When enabled, focus wrapping does not occur by default if there is another +window or container in the specified direction, and focus will instead be set +on that window or container. This is the default behavior so you can navigate +to all your windows without having to use focus parent.

+

If you want the focus to always wrap and you are aware of using focus +parent to switch to different containers, you can instead set focus_wrapping +to the value force.

+

To restrict focus inside the current workspace set focus_wrapping to the +value workspace. You will need to use focus parent until a workspace is +selected to switch to a different workspace using the focus commands (the +workspace command will still work as expected).

+

Syntax:

+
+
+
focus_wrapping yes|no|force|workspace
+
+# Legacy syntax, equivalent to "focus_wrapping force"
+force_focus_wrapping yes
+
+

Examples:

+
+
+
# Disable focus wrapping
+focus_wrapping no
+
+# Force focus wrapping
+focus_wrapping force
+
+
+
+

Forcing Xinerama

+

As explained in-depth in https://i3wm.org/docs/multi-monitor.html, some X11 +video drivers (especially the nVidia binary driver) only provide support for +Xinerama instead of RandR. In such a situation, i3 must be told to use the +inferior Xinerama API explicitly and therefore don’t provide support for +reconfiguring your screens on the fly (they are read only once on startup and +that’s it).

+

For people who cannot modify their ~/.xsession to add the +--force-xinerama commandline parameter, a configuration option is provided:

+

Syntax:

+
+
+
force_xinerama yes|no
+
+

Example:

+
+
+
force_xinerama yes
+
+

Also note that your output names are not descriptive (like HDMI1) when using +Xinerama, instead they are counted up, starting at 0: xinerama-0, xinerama-1, …

+
+
+

Automatic back-and-forth when switching to the current workspace

+

This configuration directive enables automatic workspace back_and_forth (see +[back_and_forth]) when switching to the workspace that is currently focused.

+

For instance: Assume you are on workspace "1: www" and switch to "2: IM" using +mod+2 because somebody sent you a message. You don’t need to remember where you +came from now, you can just press $mod+2 again to switch back to "1: www".

+

Syntax:

+
+
+
workspace_auto_back_and_forth yes|no
+
+

Example:

+
+
+
workspace_auto_back_and_forth yes
+
+
+
+

Delaying urgency hint reset on workspace change

+

If an application on another workspace sets an urgency hint, switching to this +workspace might lead to immediate focus of the application, which also means the +window decoration color would be immediately reset to client.focused. This +might make it unnecessarily hard to tell which window originally raised the +event.

+

In order to prevent this, you can tell i3 to delay resetting the urgency state +by a certain time using the force_display_urgency_hint directive. Setting the +value to 0 disables this feature.

+

The default is 500ms.

+

Syntax:

+
+
+
force_display_urgency_hint <timeout> ms
+
+

Example:

+
+
+
force_display_urgency_hint 500 ms
+
+
+
+

Focus on window activation

+

If a window is activated, e.g., via google-chrome www.google.com, it may request +to take focus. Since this might not be preferable, different reactions can be configured.

+

Note that this might not affect windows that are being opened. To prevent new windows +from being focused, see [no_focus].

+

Syntax:

+
+
+
focus_on_window_activation smart|urgent|focus|none
+
+

The different modes will act as follows:

+
+
+smart +
+
+

+ This is the default behavior. If the window requesting focus is on an active + workspace, it will receive the focus. Otherwise, the urgency hint will be set. +

+
+
+urgent +
+
+

+ The window will always be marked urgent, but the focus will not be stolen. +

+
+
+focus +
+
+

+ The window will always be focused and not be marked urgent. +

+
+
+none +
+
+

+ The window will neither be focused, nor be marked urgent. +

+
+
+
+
+

Drawing marks on window decoration

+

If activated, marks (see [vim_like_marks]) on windows are drawn in their window +decoration. However, any mark starting with an underscore in its name (_) will +not be drawn even if this option is activated.

+

The default for this option is yes.

+

Syntax:

+
+
+
show_marks yes|no
+
+

Example:

+
+
+
show_marks yes
+
+
+
+

Line continuation

+

Config files support line continuation, meaning when you end a line in a +backslash character (\), the line-break will be ignored by the parser. This +feature can be used to create more readable configuration files. +Commented lines are not continued.

+

Examples:

+
+
+
bindsym Mod1+f \
+fullscreen toggle
+
+# this line is not continued \
+bindsym Mod1+F fullscreen toggle
+
+
+
+

Tiling drag

+

You can configure how to initiate the tiling drag feature (see [tiling_drag]).

+

The default is modifier.

+

Since i3 4.24, you can configure a modifier key which, when pressed, will swap +instead of moving containers when dropping directly onto another container. +Defaults to Shift. Note that you have to be pressing both the floating +modifer and the swap modifier before the drag is initiated.

+

Syntax:

+
+
+
tiling_drag off
+tiling_drag modifier|titlebar [modifier|titlebar]
+tiling_drag swap_modifier <modifier>
+
+

Examples:

+
+
+
# Only initiate a tiling drag when the modifier is held:
+tiling_drag modifier
+
+# Initiate a tiling drag on either titlebar click or held modifier:
+tiling_drag modifier titlebar
+
+# Disable tiling drag altogether
+tiling_drag off
+
+# Use Control to swap containers
+tiling_drag swap_modifier Control
+
+# Setting the swap_modifier to be the same key as the floating modifier will
+# always swap without the need to hold two keys
+floating_modifier Mod4
+tiling_drag swap_modifier Mod4
+
+
+
+

Gaps

+

Since i3 4.22, you can configure window gaps. +“Gaps” are added spacing between windows (or split containers) and to the screen edges:

+
+
+Screenshot of i3 with gaps enabled (10 px inner gaps, 20 px outer gaps) +
+
Figure 5. Gaps enabled (10 px inner gaps, 20 px outer gaps)
+
+

You can configure two different kind of gaps:

+
    +
  1. +

    +Inner gaps are space between two adjacent windows (or split containers). +

    +
    2. +
  2. +

    +Outer gaps are space along the screen edges. You can configure each side + (left, right, top, bottom) separately. +

    +
    3. +
+

If you are familiar with HTML and CSS, you can think of inner gaps as padding, +and of outer gaps as margin, applied to a <div> around your window or split +container.

+

Note that outer gaps are added to the inner gaps, meaning the total gap size +between a screen edge and a window (or split container) will be the sum of outer +and inner gaps.

+

You can define gaps either globally or per workspace using the following +syntax.

+

Syntax:

+
+
+
# Inner gaps for all windows: space between two adjacent windows (or split containers).
+gaps inner <gap_size>[px]
+
+# Outer gaps for all windows: space along the screen edges.
+gaps outer|horizontal|vertical|top|left|bottom|right <gap_size>[px]
+
+# Inner and outer gaps for all windows on a specific workspace.
+# <ws> can be a workspace number or name.
+workspace <ws> gaps inner <gap_size>[px]
+workspace <ws> gaps outer|horizontal|vertical|top|left|bottom|right <gap_size>[px]
+
+# Enabling “Smart Gaps” means no gaps will be shown when there is
+# precisely one window or split container on the workspace.
+#
+# inverse_outer only enables outer gaps when there is exactly one
+# window or split container on the workspace.
+smart_gaps on|off|inverse_outer
+
+

Outer gaps can be configured for each side individually with the top, left, +bottom and right directive. horizontal and vertical are shortcuts for +left/right and top/bottom, respectively.

+

Example:

+
+
+
# Configure 5px of space between windows and to the screen edges.
+gaps inner 5px
+
+# Configure an additional 5px of extra space to the screen edges,
+# for a total gap of 10px to the screen edges, and 5px between windows.
+gaps outer 5px
+
+# Overwrite gaps to 0, I need all the space I can get on workspace 3.
+workspace 3 gaps inner 0
+workspace 3 gaps outer 0
+
+# Only enable outer gaps when there is exactly one window or split container on the workspace.
+smart_gaps inverse_outer
+
+

Tip: Gaps can additionally be changed at runtime with the gaps command, see +[changing_gaps].

+

Tip: You can find an +example +configuration that uses modes to illustrate various gap configurations.

+
+
+
+
+

Configuring i3bar

+
+

The bar at the bottom of your monitor is drawn by a separate process called +i3bar. Having this part of "the i3 user interface" in a separate process has +several advantages:

+
    +
  1. +

    +It is a modular approach. If you don’t need a workspace bar at all, or if + you prefer a different one (dzen2, xmobar, maybe even gnome-panel?), you can + just remove the i3bar configuration and start your favorite bar instead. +

    +
    2. +
  2. +

    +It follows the UNIX philosophy of "Make each program do one thing well". + While i3 manages your windows well, i3bar is good at displaying a bar on + each monitor (unless you configure it otherwise). +

    +
    3. +
  3. +

    +It leads to two separate, clean codebases. If you want to understand i3, you + don’t need to bother with the details of i3bar and vice versa. +

    +
    4. +
+

That said, i3bar is configured in the same configuration file as i3. This is +because it is tightly coupled with i3 (in contrary to i3lock or i3status which +are useful for people using other window managers). Therefore, it makes no +sense to use a different configuration place when we already have a good +configuration infrastructure in place.

+

Configuring your workspace bar starts with opening a bar block. You can have +multiple bar blocks to use different settings for different outputs (monitors):

+

Example:

+
+
+
bar {
+    status_command i3status
+}
+
+
+

i3bar command

+

By default i3 will just pass i3bar and let your shell handle the execution, +searching your $PATH for a correct version. +If you have a different i3bar somewhere or the binary is not in your $PATH you can +tell i3 what to execute.

+

The specified command will be passed to sh -c, so you can use globbing and +have to have correct quoting etc.

+

Syntax:

+
+
+
i3bar_command <command>
+
+

Example:

+
+
+
bar {
+    i3bar_command /home/user/bin/i3bar
+}
+
+
+
+

Statusline command

+

i3bar can run a program and display every line of its stdout output on the +right hand side of the bar. This is useful to display system information like +your current IP address, battery status or date/time.

+

The specified command will be passed to sh -c, so you can use globbing and +have to have correct quoting etc. Note that for signal handling, depending on +your shell (users of dash(1) are known to be affected), you have to use the +shell’s exec command so that signals are passed to your program, not to the +shell.

+

Syntax:

+
+
+
status_command <command>
+
+

Example:

+
+
+
bar {
+    status_command i3status --config ~/.i3status.conf
+
+    # For dash(1) users who want signal handling to work:
+    status_command exec ~/.bin/my_status_command
+}
+
+
+
+

Workspace buttons command

+

Since i3 4.23, i3bar can run a program and use its stdout output to define +the workspace buttons displayed on the left hand side of the bar. With this +feature, you can, for example, rename the buttons of workspaces, hide specific +workspaces, always show a workspace button even if the workspace does not exist +or change the order of the buttons.

+

Also see [status_command] for the statusline option and +https://i3wm.org/docs/i3bar-workspace-protocol.html for the detailed protocol.

+

Syntax:

+
+
+
workspace_command <command>
+
+

Example:

+
+
+
bar {
+    workspace_command /path/to/script.sh
+}
+
+
+
+

Display mode

+

You can either have i3bar be visible permanently at one edge of the screen +(dock mode) or make it show up when you press your modifier key (hide mode). +It is also possible to force i3bar to always stay hidden (invisible +mode). The modifier key can be configured using the modifier option.

+

The mode option can be changed during runtime through the bar mode command. +On reload the mode will be reverted to its configured value.

+

The hide mode maximizes screen space that can be used for actual windows. When +the bar is hidden, i3bar sends the SIGSTOP and SIGCONT signals to the +status_command process in order to conserve battery power. This feature can +be disabled by the status_command process by setting the appropriate values +in its JSON header message.

+

Invisible mode allows to permanently maximize screen space, as the bar is never +shown. Thus, you can configure i3bar to not disturb you by popping up because +of an urgency hint or because the modifier key is pressed.

+

In order to control whether i3bar is hidden or shown in hide mode, there exists +the hidden_state option, which has no effect in dock mode or invisible mode. It +indicates the current hidden_state of the bar: (1) The bar acts like in normal +hide mode, it is hidden and is only unhidden in case of urgency hints or by +pressing the modifier key (hide state), or (2) it is drawn on top of the +currently visible workspace (show state).

+

Like the mode, the hidden_state can also be controlled through i3, this can be +done by using the bar hidden_state command.

+

The default mode is dock mode; in hide mode, the default modifier is Mod4 (usually +the windows key). The default value for the hidden_state is hide.

+

Syntax:

+
+
+
mode dock|hide|invisible
+hidden_state hide|show
+modifier <Modifier>|none
+
+

Example:

+
+
+
bar {
+    mode hide
+    hidden_state hide
+    modifier Mod1
+}
+
+

Available modifiers are Mod1-Mod5, Shift, Control (see xmodmap(1)). You can +also use "none" if you don’t want any modifier to trigger this behavior.

+
+
+

Mouse button commands

+

Specifies a command to run when a button was pressed on i3bar to override the +default behavior. This is useful, e.g., for disabling the scroll wheel action +or running scripts that implement custom behavior for these buttons.

+

A button is always named button<n>, where 1 to 5 are default buttons as follows and higher +numbers can be special buttons on devices offering more buttons:

+
+
+button1 +
+
+

+ Left mouse button. +

+
+
+button2 +
+
+

+ Middle mouse button. +

+
+
+button3 +
+
+

+ Right mouse button. +

+
+
+button4 +
+
+

+ Scroll wheel up. +

+
+
+button5 +
+
+

+ Scroll wheel down. +

+
+
+button6 +
+
+

+ Scroll wheel right. +

+
+
+button7 +
+
+

+ Scroll wheel left. +

+
+
+

Please note that the old wheel_up_cmd and wheel_down_cmd commands are deprecated +and will be removed in a future release. We strongly recommend using the more general +bindsym with button4 and button5 instead.

+

Syntax:

+
+
+
bindsym [--release] button<n> <command>
+
+

Example:

+
+
+
bar {
+    # disable clicking on workspace buttons
+    bindsym button1 nop
+    # Take a screenshot by right clicking on the bar
+    bindsym --release button3 exec --no-startup-id import /tmp/latest-screenshot.png
+    # execute custom script when scrolling downwards
+    bindsym button5 exec ~/.i3/scripts/custom_wheel_down
+}
+
+
+
+

Bar ID

+

Specifies the bar ID for the configured bar instance. If this option is missing, +the ID is set to bar-x, where x corresponds to the position of the embedding +bar block in the config file (bar-0, bar-1, …).

+

Syntax:

+
+
+
id <bar_id>
+
+

Example:

+
+
+
bar {
+    id bar-1
+}
+
+
+
+

Position

+

This option determines in which edge of the screen i3bar should show up.

+

The default is bottom.

+

Syntax:

+
+
+
position top|bottom
+
+

Example:

+
+
+
bar {
+    position top
+}
+
+
+
+

Output(s)

+

You can restrict i3bar to one or more outputs (monitors). The default is to +handle all outputs. Restricting the outputs is useful for using different +options for different outputs by using multiple bar blocks.

+

To make a particular i3bar instance handle multiple outputs, specify the output +directive multiple times.

+

These output names have a special meaning:

+
+
+primary +
+
+

+ Selects the output that is configured as primary in the X server. +

+
+
+nonprimary +
+
+

+ Selects every output that is not configured as primary in the X server. +

+
+
+

Syntax:

+
+
+
output primary|nonprimary|<output>
+
+

Example:

+
+
+
# big monitor: everything
+bar {
+    # The display is connected either via HDMI or via DisplayPort
+    output HDMI2
+    output DP2
+    status_command i3status
+}
+
+# laptop monitor: bright colors and i3status with less modules.
+bar {
+    output LVDS1
+    status_command i3status --config ~/.i3status-small.conf
+    colors {
+        background #000000
+        statusline #ffffff
+    }
+}
+
+# show bar on the primary monitor and on HDMI2
+bar {
+    output primary
+    output HDMI2
+    status_command i3status
+}
+
+

Note that you might not have a primary output configured yet. To do so, run:

+
+
+
xrandr --output <output> --primary
+
+
+
+

Tray output

+

i3bar by default provides a system tray area where programs such as +NetworkManager, VLC, Pidgin, etc. can place little icons.

+

You can configure on which output (monitor) the icons should be displayed or +you can turn off the functionality entirely.

+

You can use multiple tray_output directives in your config to specify a list +of outputs on which you want the tray to appear. The first available output in +that list as defined by the order of the directives will be used for the tray +output.

+

Syntax:

+
+
+
tray_output none|primary|<output>
+
+

Example:

+
+
+
# disable system tray
+bar {
+    tray_output none
+}
+
+# show tray icons on the primary monitor
+bar {
+    tray_output primary
+}
+
+# show tray icons on the big monitor
+bar {
+    tray_output HDMI2
+}
+
+

Note that you might not have a primary output configured yet. To do so, run:

+
+
+
xrandr --output <output> --primary
+
+

Note that when you use multiple bar configuration blocks, either specify +tray_output primary in all of them or explicitly specify tray_output none +in bars which should not display the tray, otherwise the different instances +might race each other in trying to display tray icons.

+
+
+

Tray padding

+

The tray is shown on the right-hand side of the bar. By default, a padding of 2 +pixels is used for the upper, lower and right-hand side of the tray area and +between the individual icons.

+

Syntax:

+
+
+
tray_padding <px> [px]
+
+

Example:

+
+
+
# Obey Fitts's law
+tray_padding 0
+
+
+
+

Font

+

Specifies the font to be used in the bar. See [fonts].

+

Syntax:

+
+
+
font <font>
+
+

Example:

+
+
+
bar {
+    font -misc-fixed-medium-r-normal--13-120-75-75-C-70-iso10646-1
+    font pango:DejaVu Sans Mono 10
+}
+
+
+
+

Custom separator symbol

+

Specifies a custom symbol to be used for the separator as opposed to the vertical, +one pixel thick separator.

+

Syntax:

+
+
+
separator_symbol <symbol>
+
+

Example:

+
+
+
bar {
+    separator_symbol ":|:"
+}
+
+
+
+

Workspace buttons

+

Specifies whether workspace buttons should be shown or not. This is useful if +you want to display a statusline-only bar containing additional information.

+

The default is to show workspace buttons.

+

Syntax:

+
+
+
workspace_buttons yes|no
+
+

Example:

+
+
+
bar {
+    workspace_buttons no
+}
+
+
+
+

Minimal width for workspace buttons

+

By default, the width a workspace button is determined by the width of the text +showing the workspace name. If the name is too short (say, one letter), then the +workspace button might look too small.

+

This option specifies the minimum width for workspace buttons. If the name of +a workspace is too short to cover the button, an additional padding is added on +both sides of the button so that the text is centered.

+

The default value of zero means that no additional padding is added.

+

The setting also applies to the current binding mode indicator.

+

Note that the specified pixels refer to logical pixels, which might translate +into more pixels on HiDPI displays.

+

Syntax:

+
+
+
workspace_min_width <px> [px]
+
+

Example:

+
+
+
bar {
+    workspace_min_width 40
+}
+
+
+
+

Strip workspace numbers/name

+

Specifies whether workspace numbers should be displayed within the workspace +buttons. This is useful if you want to have a named workspace that stays in +order on the bar according to its number without displaying the number prefix.

+

When strip_workspace_numbers is set to yes, any workspace that has a name of +the form "[n][:][NAME]" will display only the name. You could use this, for +instance, to display Roman numerals rather than digits by naming your +workspaces to "1:I", "2:II", "3:III", "4:IV", …

+

When strip_workspace_name is set to yes, any workspace that has a name of +the form "[n][:][NAME]" will display only the number.

+

The default is to display the full name within the workspace button. Be aware +that the colon in the workspace name is optional, so [n][NAME] will also +have the workspace name and number stripped correctly.

+

Syntax:

+
+
+
strip_workspace_numbers yes|no
+strip_workspace_name yes|no
+
+

Example:

+
+
+
bar {
+    strip_workspace_numbers yes
+}
+
+
+
+

Binding Mode indicator

+

Specifies whether the current binding mode indicator should be shown or not. +This is useful if you want to hide the workspace buttons but still be able +to see the current binding mode indicator. See [binding_modes] to learn what +modes are and how to use them.

+

The default is to show the mode indicator.

+

Syntax:

+
+
+
binding_mode_indicator yes|no
+
+

Example:

+
+
+
bar {
+    binding_mode_indicator no
+}
+
+
+
+

Colors

+

As with i3, colors are in HTML hex format (#rrggbb, optionally #rrggbbaa). The +following colors can be configured at the moment:

+
+
+background +
+
+

+ Background color of the bar. +

+
+
+statusline +
+
+

+ Text color to be used for the statusline. +

+
+
+separator +
+
+

+ Text color to be used for the separator. +

+
+
+focused_background +
+
+

+ Background color of the bar on the currently focused monitor output. If + not used, the color will be taken from background. +

+
+
+focused_statusline +
+
+

+ Text color to be used for the statusline on the currently focused + monitor output. If not used, the color will be taken from statusline. +

+
+
+focused_separator +
+
+

+ Text color to be used for the separator on the currently focused + monitor output. If not used, the color will be taken from separator. +

+
+
+focused_workspace +
+
+

+ Border, background and text color for a workspace button when the workspace + has focus. +

+
+
+active_workspace +
+
+

+ Border, background and text color for a workspace button when the workspace + is active (visible) on some output, but the focus is on another one. + You can only tell this apart from the focused workspace when you are + using multiple monitors. +

+
+
+inactive_workspace +
+
+

+ Border, background and text color for a workspace button when the workspace + does not have focus and is not active (visible) on any output. This + will be the case for most workspaces. +

+
+
+urgent_workspace +
+
+

+ Border, background and text color for a workspace button when the workspace + contains a window with the urgency hint set. +

+
+
+binding_mode +
+
+

+ Border, background and text color for the binding mode indicator. If not used, + the colors will be taken from urgent_workspace. +

+
+
+

Syntax:

+
+
+
colors {
+    background <color>
+    statusline <color>
+    separator <color>
+
+    <colorclass> <border> <background> <text>
+}
+
+

Example (default colors):

+
+
+
bar {
+    colors {
+        background #000000
+        statusline #ffffff
+        separator #666666
+
+        focused_workspace  #4c7899 #285577 #ffffff
+        active_workspace   #333333 #5f676a #ffffff
+        inactive_workspace #333333 #222222 #888888
+        urgent_workspace   #2f343a #900000 #ffffff
+        binding_mode       #2f343a #900000 #ffffff
+    }
+}
+
+
+
+

Transparency

+

i3bar can support transparency by passing the --transparency flag in the +configuration:

+

Syntax:

+
+
+
bar {
+    i3bar_command i3bar --transparency
+}
+
+

In the i3bar color configuration and i3bar status block color attribute you can +then use colors in the RGBA format, i.e. the last two (hexadecimal) digits +specify the opacity. For example, #00000000 will be completely transparent, +while #000000FF will be a fully opaque black (the same as #000000).

+

Please note that due to the way the tray specification works, enabling this +flag will cause all tray icons to have a transparent background.

+
+
+

Padding

+

To make i3bar higher (without increasing the font size), and/or add padding to +the left and right side of i3bar, you can use the padding directive:

+

Syntax:

+
+
+
bar {
+    # 2px left/right and 2px top/bottom padding
+    padding 2px
+
+    # 2px top/bottom padding, no left/right padding
+    padding 2px 0
+
+    # 2px top padding, no left/right padding, 4px bottom padding
+    padding 2px 0 4px
+
+    # four value syntax
+    padding top[px] right[px] bottom[px] left[px]
+}
+
+

Examples:

+
+
+
bar {
+    # 2px left/right and 2px top/bottom padding
+    padding 2px
+
+    # 2px top/bottom padding, no left/right padding
+    padding 2px 0
+
+    # 2px top padding, no left/right padding, 4px bottom padding
+    padding 2px 0 4px
+
+    # 2px top padding, 6px right padding, 4px bottom padding, 1px left padding
+    padding 2px 6px 4px 1px
+}
+
+

Note: As a convenience for users who migrate from i3-gaps to i3, the height +directive from i3-gaps is supported by i3, but should be changed to padding.

+
+
+
+
+

List of commands

+
+

Commands are what you bind to specific keypresses. You can also issue commands +at runtime without pressing a key by using the IPC interface. An easy way to +do this is to use the i3-msg utility:

+

Example:

+
+
+
# execute this on your shell to make the current container borderless
+i3-msg border none
+
+

Commands can be chained by using ; (a semicolon). So, to move a window to a +specific workspace and immediately switch to that workspace, you can configure +the following keybinding:

+

Example:

+
+
+
bindsym $mod+x move container to workspace 3; workspace 3
+
+

Furthermore, you can change the scope of a command - that is, which containers +should be affected by that command, by using various criteria. The criteria +are specified before any command in a pair of square brackets and are separated +by space.

+

When using multiple commands, separate them by using a , (a comma) instead of +a semicolon. Criteria apply only until the next semicolon, so if you use a +semicolon to separate commands, only the first one will be executed for the +matched window(s).

+

Example:

+
+
+
# if you want to kill all windows which have the class Firefox, use:
+bindsym $mod+x [class="Firefox"] kill
+
+# same thing, but case-insensitive
+bindsym $mod+x [class="(?i)firefox"] kill
+
+# kill only the About dialog from Firefox
+bindsym $mod+x [class="Firefox" window_role="About"] kill
+
+# kill all windows except for Firefox and Gnome Terminal.
+# case-insensitive and uses negative lookaheads, supported by PCRE
+bindsym $mod+x [class="^(?i)(?!firefox)(?!gnome-terminal).*"] kill
+
+# enable floating mode and move container to workspace 4
+for_window [class="^evil-app$"] floating enable, move container to workspace 4
+
+# enable window icons for all windows with extra horizontal padding of 1px
+for_window [all] title_window_icon padding 1px
+
+# move all floating windows to the scratchpad
+bindsym $mod+x [floating] move scratchpad
+
+

The criteria which are currently implemented are:

+
+
+all +
+
+

+ Matches all windows. This criterion requires no value. +

+
+
+class +
+
+

+ Compares the window class (the second part of WM_CLASS). Use the + special value __focused__ to match all windows having the same window + class as the currently focused window. +

+
+
+instance +
+
+

+ Compares the window instance (the first part of WM_CLASS). Use the + special value __focused__ to match all windows having the same window + instance as the currently focused window. +

+
+
+window_role +
+
+

+ Compares the window role (WM_WINDOW_ROLE). Use the special value + __focused__ to match all windows having the same window role as the + currently focused window. +

+
+
+window_type +
+
+

+ Compare the window type (_NET_WM_WINDOW_TYPE). Possible values are + normal, dialog, utility, toolbar, splash, menu, dropdown_menu, + popup_menu, tooltip and notification. +

+
+
+machine +
+
+

+ Compares the name of the machine the client window is running on + (WM_CLIENT_MACHINE). Usually, it is equal to the hostname of the local + machine, but it may differ if remote X11 apps are used. +

+
+
+id +
+
+

+ Compares the X11 window ID, which you can get via xwininfo for example. +

+
+
+title +
+
+

+ Compares the X11 window title (_NET_WM_NAME or WM_NAME as fallback). + Use the special value __focused__ to match all windows having the + same window title as the currently focused window. +

+
+
+urgent +
+
+

+ Compares the urgent state of the window. Can be "latest" or "oldest". + Matches the latest or oldest urgent window, respectively. + (The following aliases are also available: newest, last, recent, first) +

+
+
+workspace +
+
+

+ Compares the workspace name of the workspace the window belongs to. Use + the special value __focused__ to match all windows in the currently + focused workspace. +

+
+
+con_mark +
+
+

+ Compares the marks set for this container, see [vim_like_marks]. A + match is made if any of the container’s marks matches the specified + mark. +

+
+
+con_id +
+
+

+ Compares the i3-internal container ID, which you can get via the IPC + interface. Handy for scripting. Use the special value __focused__ + to match only the currently focused window. +

+
+
+floating +
+
+

+ Only matches floating windows. This criterion requires no value. +

+
+
+floating_from +
+
+

+ Like floating but this criterion takes two possible values: "auto" + and "user". With "auto", only windows that were automatically opened as + floating are matched. With "user", only windows that the user made + floating are matched. +

+
+
+tiling +
+
+

+ Only matches tiling windows. This criterion requires no value. +

+
+
+tiling_from +
+
+

+ Like tiling but this criterion takes two possible values: "auto" and + "user". With "auto", only windows that were automatically opened as + tiling are matched. With "user", only windows that the user made tiling + are matched. +

+
+
+

The criteria class, instance, role, title, workspace, machine and +mark are actually regular expressions (PCRE). See pcresyntax(3) or perldoc +perlre for information on how to use them.

+
+

Executing applications (exec)

+

What good is a window manager if you can’t actually start any applications? +The exec command starts an application by passing the command you specify to a +shell. This implies that you can use globbing (wildcards) and programs will be +searched in your $PATH.

+

See [command_chaining] for details on the special meaning of ; (semicolon) +and , (comma): they chain commands together in i3, so you need to use quoted +strings (as shown in [exec_quoting]) if they appear in your command.

+

Syntax:

+
+
+
exec [--no-startup-id] <command>
+
+

Example:

+
+
+
# Start the GIMP
+bindsym $mod+g exec gimp
+
+# Start the terminal emulator urxvt which is not yet startup-notification-aware
+bindsym $mod+Return exec --no-startup-id urxvt
+
+

The --no-startup-id parameter disables startup-notification support for this +particular exec command. With startup-notification, i3 can make sure that a +window appears on the workspace on which you used the exec command. Also, it +will change the X11 cursor to watch (a clock) while the application is +launching. So, if an application is not startup-notification aware (most GTK +and Qt using applications seem to be, though), you will end up with a watch +cursor for 60 seconds.

+

If the command to be executed contains a ; (semicolon) and/or a , (comma), +the entire command must be quoted. For example, to have a keybinding for the +shell command notify-send Hello, i3, you would add an entry to your +configuration file like this:

+

Example:

+
+
+
# Execute a command with a comma in it
+bindsym $mod+p exec "notify-send Hello, i3"
+
+

If however a command with a comma and/or semicolon itself requires quotes, you +must escape the internal quotation marks with double backslashes, like this:

+

Example:

+
+
+
# Execute a command with a comma, semicolon and internal quotes
+bindsym $mod+p exec "notify-send \\"Hello, i3; from $USER\\""
+
+
+
+

Splitting containers

+

The split command makes the current window a split container. Split containers +can contain multiple windows. Depending on the layout of the split container, +new windows get placed to the right of the current one (splith) or new windows +get placed below the current one (splitv).

+

If you apply this command to a split container with the same orientation, +nothing will happen. If you use a different orientation, the split container’s +orientation will be changed (if it does not have more than one window). +The toggle option will toggle the orientation of the split container if it +contains a single window. Otherwise it makes the current window a split +container with opposite orientation compared to the parent container. +Use layout toggle split to change the layout of any split container from +splitv to splith or vice-versa. You can also define a custom sequence of layouts +to cycle through with layout toggle, see [manipulating_layout].

+

Syntax:

+
+
+
split vertical|horizontal|toggle
+
+

Example:

+
+
+
bindsym $mod+v split vertical
+bindsym $mod+h split horizontal
+bindsym $mod+t split toggle
+
+
+
+

Manipulating layout

+

Use layout toggle split, layout stacking, layout tabbed, layout splitv +or layout splith to change the current container layout to splith/splitv, +stacking, tabbed layout, splitv or splith, respectively.

+

Specify up to four layouts after layout toggle to cycle through them. Every +time the command is executed, the layout specified after the currently active +one will be applied. If the currently active layout is not in the list, the +first layout in the list will be activated.

+

To make the current window (!) fullscreen, use fullscreen enable (or +fullscreen enable global for the global mode), to leave either fullscreen +mode use fullscreen disable, and to toggle between these two states use +fullscreen toggle (or fullscreen toggle global).

+

Likewise, to make the current window floating (or tiling again) use floating +enable respectively floating disable (or floating toggle):

+

Syntax:

+
+
+
layout default|tabbed|stacking|splitv|splith
+layout toggle [split|all]
+layout toggle [split|tabbed|stacking|splitv|splith] [split|tabbed|stacking|splitv|splith]…
+
+

Examples:

+
+
+
bindsym $mod+s layout stacking
+bindsym $mod+l layout toggle split
+bindsym $mod+w layout tabbed
+
+# Toggle between stacking/tabbed/split:
+bindsym $mod+x layout toggle
+
+# Toggle between stacking/tabbed/splith/splitv:
+bindsym $mod+x layout toggle all
+
+# Toggle between stacking/tabbed/splith:
+bindsym $mod+x layout toggle stacking tabbed splith
+
+# Toggle between splitv/tabbed
+bindsym $mod+x layout toggle splitv tabbed
+
+# Toggle between last split layout/tabbed/stacking
+bindsym $mod+x layout toggle split tabbed stacking
+
+# Toggle fullscreen
+bindsym $mod+f fullscreen toggle
+
+# Toggle floating/tiling
+bindsym $mod+t floating toggle
+
+
+
+

Focusing containers

+

To change focus, you can use the focus command. The following options are +available:

+
+
+<criteria> +
+
+

+ Sets focus to the container that matches the specified criteria. + See [command_criteria]. +

+
+
+workspace +
+
+

+ Sets focus to the workspace that contains the container that matches the + specified criteria. +

+
+
+left|right|up|down +
+
+

+ Sets focus to the nearest container in the given direction. +

+
+
+parent +
+
+

+ Sets focus to the parent container of the current container. +

+
+
+child +
+
+

+ The opposite of focus parent, sets the focus to the last focused + child container. +

+
+
+next|prev +
+
+

+ Automatically sets focus to the adjacent container. If sibling is + specified, the command will focus the exact sibling container, + including non-leaf containers like split containers. Otherwise, it is + an automatic version of focus left|right|up|down in the orientation + of the parent container. +

+
+
+floating +
+
+

+ Sets focus to the last focused floating container. +

+
+
+tiling +
+
+

+ Sets focus to the last focused tiling container. +

+
+
+mode_toggle +
+
+

+ Toggles between floating/tiling containers. +

+
+
+output +
+
+

+ Followed by a direction or an output name, this will focus the + corresponding output. +

+
+
+

Syntax:

+
+
+
<criteria> focus
+<criteria> focus workspace
+focus left|right|down|up
+focus parent|child|floating|tiling|mode_toggle
+focus next|prev [sibling]
+focus output left|right|down|up|current|primary|nonprimary|next|<output1> [output2]…
+
+

Examples:

+
+
+
# Focus firefox
+bindsym $mod+F1 [class="Firefox"] focus
+
+# Focus the workspace where firefox is, without necessarily focusing firefox
+# itself.
+bindsym $mod+x [class="Firefox"] focus workspace
+
+# Focus container on the left, bottom, top, right
+bindsym $mod+j focus left
+bindsym $mod+k focus down
+bindsym $mod+l focus up
+bindsym $mod+semicolon focus right
+
+# Focus parent container
+bindsym $mod+u focus parent
+
+# Focus last floating/tiling container
+bindsym $mod+g focus mode_toggle
+
+# Focus the next output (effectively toggles when you only have two outputs)
+bindsym $mod+x focus output next
+
+# Focus the output right to the current one
+bindsym $mod+x focus output right
+
+# Focus the big output
+bindsym $mod+x focus output HDMI-2
+
+# Focus the primary output
+bindsym $mod+x focus output primary
+
+# Cycle focus through non-primary outputs
+bindsym $mod+x focus output nonprimary
+
+# Cycle focus between outputs VGA1 and LVDS1 but not DVI0
+bindsym $mod+x focus output VGA1 LVDS1
+
+

Note that you might not have a primary output configured yet. To do so, run:

+
+
+
xrandr --output <output> --primary
+
+
+
+

Moving containers

+

Use the move command to move a container.

+

Syntax:

+
+
+
# Moves the container into the given direction.
+# The optional pixel argument specifies how far the
+# container should be moved if it is floating and
+# defaults to 10 pixels. The optional ppt argument
+# means "percentage points", and if specified it indicates
+# how many points the container should be moved if it is
+# floating rather than by a pixel value.
+move <left|right|down|up> [<amount> [px|ppt]]
+
+# Moves the container to the specified pos_x and pos_y
+# coordinates on the screen.
+move position <pos_x> [px|ppt] <pos_y> [px|ppt]
+
+# Moves the container to the center of the screen.
+# If 'absolute' is used, it is moved to the center of
+# all outputs.
+move [absolute] position center
+
+# Moves the container to the current position of the
+# mouse cursor. Only affects floating containers.
+move position mouse
+
+

Examples:

+
+
+
# Move container to the left, bottom, top, right
+bindsym $mod+j move left
+bindsym $mod+k move down
+bindsym $mod+l move up
+bindsym $mod+semicolon move right
+
+# Move container, but make floating containers
+# move more than the default
+bindsym $mod+j move left 20 px
+
+# Move floating container to the center of all outputs
+bindsym $mod+c move absolute position center
+
+# Move container to the current position of the cursor
+bindsym $mod+m move position mouse
+
+
+
+

Swapping containers

+

Two containers can be swapped (i.e., move to each other’s position) by using +the swap command. They will assume the position and geometry of the container +they are swapped with.

+

The first container to participate in the swapping can be selected through the +normal command criteria process with the focused window being the usual +fallback if no criteria are specified. The second container can be selected +using one of the following methods:

+
+
+id +
+
+

+The X11 window ID of a client window. +

+
+
+con_id +
+
+

+The i3 container ID of a container. +

+
+
+mark +
+
+

+A container with the specified mark, see [vim_like_marks]. +

+
+
+

Note that swapping does not work with all containers. Most notably, swapping +containers that have a parent-child relationship to one another does not work.

+

Syntax:

+
+
+
swap container with id|con_id|mark <arg>
+
+

Examples:

+
+
+
# Swaps the focused container with the container marked »swapee«.
+swap container with mark swapee
+
+# Swaps container marked »A« and »B«
+[con_mark="^A$"] swap container with mark B
+
+
+
+

Sticky floating windows

+

If you want a window to stick to the glass, i.e., have it stay on screen even +if you switch to another workspace, you can use the sticky command. For +example, this can be useful for notepads, a media player or a video chat +window.

+

Note that while any window can be made sticky through this command, it will +only take effect if the window is floating.

+

Syntax:

+
+
+
sticky enable|disable|toggle
+
+

Examples:

+
+
+
# make a terminal sticky that was started as a notepad
+for_window [instance=notepad] sticky enable
+
+
+
+

Changing (named) workspaces/moving to workspaces

+

To change to a specific workspace, use the workspace command, followed by the +number or name of the workspace. Pass the optional flag +--no-auto-back-and-forth to disable [workspace_auto_back_and_forth] for this +specific call only.

+

To move containers to specific workspaces, use move container to workspace.

+

You can also switch to the next and previous workspace with the commands +workspace next and workspace prev, which is handy, for example, if you have +workspace 1, 3, 4 and 9 and you want to cycle through them with a single key +combination. To restrict those to the current output, use workspace +next_on_output and workspace prev_on_output. Similarly, you can use move +container to workspace next, move container to workspace prev to move a +container to the next/previous workspace and move container to workspace current +(the last one makes sense only when used with criteria).

+

workspace next cycles through either numbered or named workspaces. But when it +reaches the last numbered/named workspace, it looks for named workspaces after +exhausting numbered ones and looks for numbered ones after exhausting named ones.

+

See [move_to_outputs] for how to move a container/workspace to a different +RandR output.

+

Workspace names are parsed as Pango +markup by i3bar.

+

To switch back to the previously focused workspace, use workspace +back_and_forth; likewise, you can move containers to the previously focused +workspace using move container to workspace back_and_forth.

+

Syntax:

+
+
+
workspace next|prev|next_on_output|prev_on_output
+workspace back_and_forth
+workspace [--no-auto-back-and-forth] <name>
+workspace [--no-auto-back-and-forth] number <name>
+
+move [--no-auto-back-and-forth] [window|container] [to] workspace <name>
+move [--no-auto-back-and-forth] [window|container] [to] workspace number <name>
+move [window|container] [to] workspace prev|next|current
+
+

Examples:

+
+
+
bindsym $mod+1 workspace 1
+bindsym $mod+2 workspace 2
+bindsym $mod+3 workspace 3:<span foreground="red">vim</span>
+...
+
+bindsym $mod+Shift+1 move container to workspace 1
+bindsym $mod+Shift+2 move container to workspace 2
+...
+
+# switch between the current and the previously focused one
+bindsym $mod+b workspace back_and_forth
+bindsym $mod+Shift+b move container to workspace back_and_forth
+
+# move the whole workspace to the next output
+bindsym $mod+x move workspace to output right
+
+# move firefox to current workspace
+bindsym $mod+F1 [class="Firefox"] move workspace current
+
+
+

Named workspaces

+

Workspaces are identified by their name. So, instead of using numbers in the +workspace command, you can use an arbitrary name:

+

Example:

+
+
+
bindsym $mod+1 workspace mail
+...
+
+

If you want the workspace to have a number and a name, just prefix the +number, like this:

+

Example:

+
+
+
bindsym $mod+1 workspace 1: mail
+bindsym $mod+2 workspace 2: www
+...
+
+

Note that the workspace will really be named "1: mail". i3 treats workspace +names beginning with a number in a slightly special way. Normally, named +workspaces are ordered the way they appeared. When they start with a number, i3 +will order them numerically. Also, you will be able to use workspace number 1 +to switch to the workspace which begins with number 1, regardless of which name +it has. This is useful in case you are changing the workspace’s name +dynamically. To combine both commands you can use workspace number 1: mail to +specify a default name if there’s currently no workspace starting with a "1".

+
+
+

Renaming workspaces

+

You can rename workspaces. This might be useful to start with the default +numbered workspaces, do your work, and rename the workspaces afterwards to +reflect what’s actually on them. You can also omit the old name to rename +the currently focused workspace. This is handy if you want to use the +rename command with i3-input.

+

Syntax:

+
+
+
rename workspace <old_name> to <new_name>
+rename workspace to <new_name>
+
+

Examples:

+
+
+
i3-msg 'rename workspace 5 to 6'
+i3-msg 'rename workspace 1 to "1: www"'
+i3-msg 'rename workspace "1: www" to "10: www"'
+i3-msg 'rename workspace to "2: mail"'
+bindsym $mod+r exec i3-input -F 'rename workspace to "%s"' -P 'New name: '
+
+

If you want to rename workspaces on demand while keeping the navigation stable, +you can use a setup like this:

+

Example:

+
+
+
bindsym $mod+1 workspace number "1: www"
+bindsym $mod+2 workspace number "2: mail"
+...
+
+

If a workspace does not exist, the command workspace number "1: mail" will +create workspace "1: mail".

+

If a workspace with number 1 already exists, the command will switch to this +workspace and ignore the text part. So even when the workspace has been renamed +"1: web", the above command will still switch to it. The command workspace 1 +will however create and move to a new workspace "1" alongside the existing +"1: mail" workspace.

+
+
+
+

Moving workspaces to a different screen

+

See [move_to_outputs] for how to move a container/workspace to a different +RandR output.

+
+
+

Moving containers/workspaces to RandR outputs

+

To move a container to another RandR output (addressed by names like LVDS1 or +VGA1) or to a RandR output identified by a specific direction (like left, +right, up or down), there are two commands:

+

Syntax:

+
+
+
move container to output left|right|down|up|current|primary|nonprimary|next|<output1> [output2]…
+move workspace to output left|right|down|up|current|primary|nonprimary|next|<output1> [output2]…
+
+

Examples:

+
+
+
# Move the current workspace to the next output
+# (effectively toggles when you only have two outputs)
+bindsym $mod+x move workspace to output next
+
+# Cycle this workspace between outputs VGA1 and LVDS1 but not DVI0
+bindsym $mod+x move workspace to output VGA1 LVDS1
+
+# Put this window on the presentation output.
+bindsym $mod+x move container to output VGA1
+
+# Put this window on the primary output.
+bindsym $mod+x move container to output primary
+
+

If you specify more than one output, the container/workspace is cycled through +them: If it is already in one of the outputs of the list, it will move to the +next output in the list. If it is in an output not in the list, it will move to +the first specified output. Non-existing outputs are skipped.

+

Note that you might not have a primary output configured yet. To do so, run:

+
+
+
xrandr --output <output> --primary
+
+
+
+

Moving containers/windows to marks

+

To move a container to another container with a specific mark (see [vim_like_marks]), +you can use the following command.

+

The window will be moved right after the marked container in the tree, i.e., it ends up +in the same position as if you had opened a new window when the marked container was +focused. If the mark is on a split container, the window will appear as a new child +after the currently focused child within that container.

+

Syntax:

+
+
+
move window|container to mark <mark>
+
+

Example:

+
+
+
for_window [instance="tabme"] move window to mark target
+
+
+
+

Resizing containers/windows

+

If you want to resize containers/windows using your keyboard, you can use the +resize command:

+

Syntax:

+
+
+
resize grow|shrink <direction> [<px> px [or <ppt> ppt]]
+resize set [width] <width> [px | ppt]
+resize set height <height> [px | ppt]
+resize set [width] <width> [px | ppt] [height] <height> [px | ppt]
+
+

Direction can either be one of up, down, left or right. Or you can be +less specific and use width or height, in which case i3 will take/give space +from all the other containers. The optional pixel argument specifies by how many +pixels a container should be grown or shrunk (the default is 10 pixels). The +optional ppt argument means "percentage points", and if specified it indicates +that a tiling container should be grown or shrunk by that many points, instead +of by the px value.

+

Note about resize set: a value of 0 for <width> or <height> means "do not +resize in this direction".

+

It is recommended to define bindings for resizing in a dedicated binding mode. +See [binding_modes] and the example in the i3 +default config for more +context.

+

Example:

+
+
+
for_window [class="urxvt"] resize set 640 480
+
+
+
+

Jumping to specific windows

+

Often when in a multi-monitor environment, you want to quickly jump to a +specific window. For example, while working on workspace 3 you might want to +jump to your mail client to email your boss that you’ve achieved some +important goal. Instead of figuring out how to navigate to your mail client, +it would be more convenient to have a shortcut. You can use the focus command +with criteria for that.

+

Syntax:

+
+
+
[class="class"] focus
+[title="title"] focus
+
+

Examples:

+
+
+
# Get me to the next open VIM instance
+bindsym $mod+a [class="urxvt" title="VIM"] focus
+
+
+
+

VIM-like marks (mark/goto)

+

This feature is like the jump feature: It allows you to directly jump to a +specific window (this means switching to the appropriate workspace and setting +focus to the windows). However, you can directly mark a specific window with +an arbitrary label and use it afterwards. You can unmark the label in the same +way, using the unmark command. If you don’t specify a label, unmark removes all +marks. You do not need to ensure that your windows have unique classes or +titles, and you do not need to change your configuration file.

+

As the command needs to include the label with which you want to mark the +window, you cannot simply bind it to a key. i3-input is a tool created +for this purpose: It lets you input a command and sends the command to i3. It +can also prefix this command and display a custom prompt for the input dialog.

+

The additional --toggle option will remove the mark if the window already has +this mark or add it otherwise. Note that you might need to use this in +combination with --add (see below) as any other marks will otherwise be +removed.

+

The --replace flag causes i3 to remove any existing marks, which is also the +default behavior. You can use the --add flag to put more than one mark on a +window.

+

Refer to [show_marks] if you don’t want marks to be shown in the window decoration.

+

Syntax:

+
+
+
mark [--add|--replace] [--toggle] <identifier>
+[con_mark="identifier"] focus
+unmark <identifier>
+
+

You can use i3-input to prompt for a mark name, then use the mark +and focus commands to create and jump to custom marks:

+

Examples:

+
+
+
# read 1 character and mark the current window with this character
+bindsym $mod+m exec i3-input -F 'mark %s' -l 1 -P 'Mark: '
+
+# read 1 character and go to the window with the character
+bindsym $mod+g exec i3-input -F '[con_mark="%s"] focus' -l 1 -P 'Goto: '
+
+

Alternatively, if you do not want to mess with i3-input, you could create +separate bindings for a specific set of labels and then only use those labels:

+

Example (in a terminal):

+
+
+
# marks the focused container
+mark irssi
+
+# focus the container with the mark "irssi"
+'[con_mark="irssi"] focus'
+
+# remove the mark "irssi" from whichever container has it
+unmark irssi
+
+# remove all marks on all firefox windows
+[class="(?i)firefox"] unmark
+
+
+
+

Window title format

+

By default, i3 will simply print the X11 window title. Using title_format, +this can be customized by setting the format to the desired output. This +directive supports Pango markup and the +following placeholders which will be replaced:

+
+
+%title +
+
+

+ For normal windows, this is the X11 window title (_NET_WM_NAME or WM_NAME + as fallback). When used on containers without a window (e.g., a split + container inside a tabbed/stacked layout), this will be the tree + representation of the container (e.g., "H[xterm xterm]"). +

+
+
+%class +
+
+

+ The X11 window class (second part of WM_CLASS). This corresponds to the + class criterion, see [command_criteria]. +

+
+
+%instance +
+
+

+ The X11 window instance (first part of WM_CLASS). This corresponds to the + instance criterion, see [command_criteria]. +

+
+
+%machine +
+
+

+ The X11 name of the machine (WM_CLIENT_MACHINE). This corresponds to the + machine criterion, see [command_criteria]. +

+
+
+

Using the [for_window] directive, you can set the title format for any window +based on [command_criteria].

+

Syntax:

+
+
+
title_format <format>
+
+

Examples:

+
+
+
# give the focused window a prefix
+bindsym $mod+p title_format "Important | %title"
+
+# print all window titles bold
+for_window [class=".*"] title_format "<b>%title</b>"
+
+# print window titles of firefox windows red
+for_window [class="(?i)firefox"] title_format "<span foreground='red'>%title</span>"
+
+
+
+

Window title icon

+

By default, i3 does not display the window icon in the title bar.

+

Starting with i3 v4.20, you can optionally enable window icons either for +specific windows or for all windows (using the [for_window] directive).

+

Syntax:

+
+
+
title_window_icon <yes|no|toggle>
+title_window_icon <padding|toggle> <px>
+
+

Examples:

+
+
+
# show the window icon for the focused window to make it stand out
+bindsym $mod+p title_window_icon on
+
+# enable window icons for all windows
+for_window [all] title_window_icon on
+
+# enable window icons for all windows with extra horizontal padding
+for_window [all] title_window_icon padding 3px
+
+
+
+

Changing border style

+

To change the border of the current client, you can use border normal to use the normal +border (including window title), border pixel 1 to use a 1-pixel border (no window title) +and border none to make the client borderless.

+

There is also border toggle which will toggle the different border styles. The +optional pixel argument can be used to specify the border width when switching +to the normal and pixel styles.

+

Note that "pixel" refers to logical pixel. On HiDPI displays, a logical pixel +is represented by multiple physical pixels, so pixel 1 might not +necessarily translate into a single pixel row wide border.

+

Syntax:

+
+
+
border normal|pixel|toggle [<n>]
+border none
+
+# legacy syntax, equivalent to "border pixel 1"
+border 1pixel
+
+

Examples:

+
+
+
# use window title, but no border
+bindsym $mod+t border normal 0
+# use no window title and a thick border
+bindsym $mod+y border pixel 3
+# use window title *and* a thick border
+bindsym $mod+y border normal 3
+# use neither window title nor border
+bindsym $mod+u border none
+# no border on VLC
+for_window [class="vlc"] border none
+
+

To change the default for all windows, see the directive [default_border].

+
+
+

Enabling shared memory logging

+

As described in https://i3wm.org/docs/debugging.html, i3 can log to a shared +memory buffer, which you can dump using i3-dump-log. The shmlog command +allows you to enable or disable the shared memory logging at runtime.

+

Note that when using shmlog <size_in_bytes>, the current log will be +discarded and a new one will be started.

+

Syntax:

+
+
+
shmlog <size_in_bytes>
+shmlog on|off|toggle
+
+

Examples:

+
+
+
# Enable/disable logging
+bindsym $mod+x shmlog toggle
+
+# or, from a terminal:
+# increase the shared memory log buffer to 50 MiB
+i3-msg shmlog $((50*1024*1024))
+
+
+
+

Enabling debug logging

+

The debuglog command allows you to enable or disable debug logging at +runtime. Debug logging is much more verbose than non-debug logging. This +command does not activate shared memory logging (shmlog), and as such is most +likely useful in combination with the above-described [shmlog] command.

+

Syntax:

+
+
+
debuglog on|off|toggle
+
+

Examples:

+
+
+
# Enable/disable logging
+bindsym $mod+x debuglog toggle
+
+
+
+

Reloading/Restarting/Exiting

+

You can make i3 reload its configuration file with reload. You can also +restart i3 inplace with the restart command to get it out of some weird state +(if that should ever happen) or to perform an upgrade without having to restart +your X session. To exit i3 properly, you can use the exit command, +however you don’t need to (simply killing your X session is fine as well).

+

Examples:

+
+
+
bindsym $mod+Shift+r restart
+bindsym $mod+Shift+w reload
+bindsym $mod+Shift+e exit
+
+
+
+

Scratchpad

+

There are two commands to use any existing window as scratchpad window. move +scratchpad will move a window to the scratchpad workspace. This will make it +invisible until you show it again. There is no way to open that workspace. +Instead, when using scratchpad show, the window will be shown again, as a +floating window, centered on your current workspace (using scratchpad show on +a visible scratchpad window will make it hidden again, so you can have a +keybinding to toggle). Note that this is just a normal floating window, so if +you want to "remove it from scratchpad", you can simple make it tiling again +(floating toggle).

+

As the name indicates, this is useful for having a window with your favorite +editor always at hand. However, you can also use this for other permanently +running applications which you don’t want to see all the time: Your music +player, alsamixer, maybe even your mail client…?

+

Syntax:

+
+
+
move scratchpad
+
+scratchpad show
+
+

Examples:

+
+
+
# Make the currently focused window a scratchpad
+bindsym $mod+Shift+minus move scratchpad
+
+# Show the first scratchpad window
+bindsym $mod+minus scratchpad show
+
+# Show the sup-mail scratchpad window, if any.
+bindsym mod4+s [title="^Sup ::"] scratchpad show
+
+
+
+

Nop

+

There is a no operation command nop which allows you to override default +behavior. This can be useful for, e.g., disabling a focus change on clicks with +the middle mouse button.

+

The optional comment argument is ignored, but will be printed to the log file +for debugging purposes.

+

Syntax:

+
+
+
nop [<comment>]
+
+

Example:

+
+
+
# Disable focus change for clicks on titlebars
+# with the middle mouse button
+bindsym button2 nop
+
+
+
+

i3bar control

+

There are two options in the configuration of each i3bar instance that can be +changed during runtime by invoking a command through i3. The commands bar +hidden_state and bar mode allow setting the current hidden_state +respectively mode option of each bar. It is also possible to toggle between +hide state and show state as well as between dock mode and hide mode. Each +i3bar instance can be controlled individually by specifying a bar_id, if none +is given, the command is executed for all bar instances.

+

Syntax:

+
+
+
bar hidden_state hide|show|toggle [<bar_id>]
+
+bar mode dock|hide|invisible|toggle [<bar_id>]
+
+

Examples:

+
+
+
# Toggle between hide state and show state
+bindsym $mod+m bar hidden_state toggle
+
+# Toggle between dock mode and hide mode
+bindsym $mod+n bar mode toggle
+
+# Set the bar instance with id 'bar-1' to switch to hide mode
+bindsym $mod+b bar mode hide bar-1
+
+# Set the bar instance with id 'bar-1' to always stay hidden
+bindsym $mod+Shift+b bar mode invisible bar-1
+
+
+
+

Changing gaps

+

Gaps can be modified at runtime with the following command syntax:

+

Syntax:

+
+
+
# Inner gaps: space between two adjacent windows (or split containers).
+gaps inner current|all set|plus|minus|toggle <gap_size_in_px>
+# Outer gaps: space along the screen edges.
+gaps outer|horizontal|vertical|top|right|bottom|left current|all set|plus|minus|toggle <gap_size_in_px>
+
+

With current or all you can change gaps either for only the currently +focused or all currently existing workspaces (note that this does not affect the +global configuration itself).

+

Examples:

+
+
+
gaps inner all set 20
+gaps outer current plus 5
+gaps horizontal current plus 40
+gaps outer current toggle 60
+
+for_window [class="vlc"] gaps inner 0, gaps outer 0
+
+

To change the gaps for all windows, see the [gaps] configuration directive.

+
+
+
+
+

Multiple monitors

+
+

As you can see in the goal list on the website, i3 was specifically developed +with support for multiple monitors in mind. This section will explain how to +handle multiple monitors.

+

When you have only one monitor, things are simple. You usually start with +workspace 1 on your monitor and open new ones as you need them.

+

When you have more than one monitor, each monitor will get an initial +workspace. The first monitor gets 1, the second gets 2 and a possible third +would get 3. When you switch to a workspace on a different monitor, i3 will +switch to that monitor and then switch to the workspace. This way, you don’t +need shortcuts to switch to a specific monitor, and you don’t need to remember +where you put which workspace. New workspaces will be opened on the currently +active monitor. It is not possible to have a monitor without a workspace.

+

The idea of making workspaces global is based on the observation that most +users have a very limited set of workspaces on their additional monitors. +They are often used for a specific task (browser, shell) or for monitoring +several things (mail, IRC, syslog, …). Thus, using one workspace on one monitor +and "the rest" on the other monitors often makes sense. However, as you can +create an unlimited number of workspaces in i3 and tie them to specific +screens, you can have the "traditional" approach of having X workspaces per +screen by changing your configuration (using modes, for example).

+
+

Configuring your monitors

+

To help you get going if you have never used multiple monitors before, here is +a short overview of the xrandr options which will probably be of interest to +you. It is always useful to get an overview of the current screen configuration. +Just run "xrandr" and you will get an output like the following:

+
+
+
$ xrandr
+Screen 0: minimum 320 x 200, current 1280 x 800, maximum 8192 x 8192
+VGA1 disconnected (normal left inverted right x axis y axis)
+LVDS1 connected 1280x800+0+0 (normal left inverted right x axis y axis) 261mm x 163mm
+   1280x800       60.0*+   50.0
+   1024x768       85.0     75.0     70.1     60.0
+   832x624        74.6
+   800x600        85.1     72.2     75.0     60.3     56.2
+   640x480        85.0     72.8     75.0     59.9
+   720x400        85.0
+   640x400        85.1
+   640x350        85.1
+
+

Several things are important here: You can see that LVDS1 is connected (of +course, it is the internal flat panel) but VGA1 is not. If you have a monitor +connected to one of the ports but xrandr still says "disconnected", you should +check your cable, monitor or graphics driver.

+

The maximum resolution you can see at the end of the first line is the maximum +combined resolution of your monitors. By default, it is usually too low and has +to be increased by editing /etc/X11/xorg.conf.

+

So, say you connected VGA1 and want to use it as an additional screen:

+
+
+
xrandr --output VGA1 --auto --left-of LVDS1
+
+

This command makes xrandr try to find the native resolution of the device +connected to VGA1 and configures it to the left of your internal flat panel. +When running "xrandr" again, the output looks like this:

+
+
+
$ xrandr
+Screen 0: minimum 320 x 200, current 2560 x 1024, maximum 8192 x 8192
+VGA1 connected 1280x1024+0+0 (normal left inverted right x axis y axis) 338mm x 270mm
+   1280x1024      60.0*+   75.0
+   1280x960       60.0
+   1152x864       75.0
+   1024x768       75.1     70.1     60.0
+   832x624        74.6
+   800x600        72.2     75.0     60.3     56.2
+   640x480        72.8     75.0     66.7     60.0
+   720x400        70.1
+LVDS1 connected 1280x800+1280+0 (normal left inverted right x axis y axis) 261mm x 163mm
+   1280x800       60.0*+   50.0
+   1024x768       85.0     75.0     70.1     60.0
+   832x624        74.6
+   800x600        85.1     72.2     75.0     60.3     56.2
+   640x480        85.0     72.8     75.0     59.9
+   720x400        85.0
+   640x400        85.1
+   640x350        85.1
+
+

Please note that i3 uses exactly the same API as xrandr does, so it will see +only what you can see in xrandr.

+

See also [presentations] for more examples of multi-monitor setups.

+
+
+

Interesting configuration for multi-monitor environments

+

There are several things to configure in i3 which might be interesting if you +have more than one monitor:

+
    +
  1. +

    +You can specify which workspace should be put on which screen. This + allows you to have a different set of workspaces when starting than just + 1 for the first monitor, 2 for the second and so on. See + [workspace_screen]. +

    +
    2. +
  2. +

    +If you want some applications to generally open on the bigger screen + (MPlayer, Firefox, …), you can assign them to a specific workspace, see + [assign_workspace]. +

    +
    3. +
  3. +

    +If you have many workspaces on many monitors, it might get hard to keep + track of which window you put where. Thus, you can use vim-like marks to + quickly switch between windows. See [vim_like_marks]. +

    +
    4. +
  4. +

    +For information on how to move existing workspaces between monitors, + see [move_to_outputs]. +

    +
    5. +
+
+
+
+
+

i3 and the rest of your software world

+
+
+

Displaying a status line

+

A very common thing amongst users of exotic window managers is a status line at +some corner of the screen. It is an often superior replacement to the widget +approach you have in the task bar of a traditional desktop environment.

+

If you don’t already have your favorite way of generating such a status line +(self-written scripts, conky, …), then i3status is the recommended tool for +this task. It was written in C with the goal of using as few syscalls as +possible to reduce the time your CPU is woken up from sleep states. Because +i3status only spits out text, you need to combine it with some other tool, like +i3bar. See [status_command] for how to display i3status in i3bar.

+

Regardless of which application you use to display the status line, you +want to make sure that it registers as a dock window using EWMH hints. i3 will +position the window either at the top or at the bottom of the screen, depending +on which hint the application sets. With i3bar, you can configure its position, +see [i3bar_position].

+
+
+

Giving presentations (multi-monitor)

+

When giving a presentation, you typically want the audience to see what you see +on your screen and then go through a series of slides (if the presentation is +simple). For more complex presentations, you might want to have some notes +which only you can see on your screen, while the audience can only see the +slides.

+
+

Case 1: everybody gets the same output

+

This is the simple case. You connect your computer to the video projector, +turn on both (computer and video projector) and configure your X server to +clone the internal flat panel of your computer to the video output:

+
+
+
xrandr --output VGA1 --mode 1024x768 --same-as LVDS1
+
+

i3 will then use the lowest common subset of screen resolutions, the rest of +your screen will be left untouched (it will show the X background). So, in +our example, this would be 1024x768 (my notebook has 1280x800).

+
+
+

Case 2: you can see more than your audience

+

This case is a bit harder. First of all, you should configure the VGA output +somewhere near your internal flat panel, say right of it:

+
+
+
xrandr --output VGA1 --mode 1024x768 --right-of LVDS1
+
+

Now, i3 will put a new workspace (depending on your settings) on the new screen +and you are in multi-monitor mode (see [multi_monitor]).

+

Because i3 is not a compositing window manager, there is no ability to +display a window on two screens at the same time. Instead, your presentation +software needs to do this job (that is, open a window on each screen).

+
+
+
+

High-resolution displays (aka HIDPI displays)

+

See https://wiki.archlinux.org/index.php/HiDPI for details on how to enable +scaling in various parts of the Linux desktop. i3 will read the desired DPI from +the Xft.dpi property. The property defaults to 96 DPI, so to achieve 200% +scaling, you’d set Xft.dpi: 192 in ~/.Xresources.

+

If you are a long-time i3 user who just got a new monitor, double-check that:

+
    +
  • +

    +You are using a scalable font (starting with “pango:”) in your i3 config. +

    +
    • +
  • +

    +You are using a terminal emulator which supports scaling. You could + temporarily switch to gnome-terminal, which is known to support scaling out of + the box, until you figure out how to adjust the font size in your favorite + terminal emulator. +

    +
    • +
+
+
+
+
+
+ + + diff --git a/docs/wsbar.html b/docs/wsbar.html new file mode 100644 index 0000000..6734571 --- /dev/null +++ b/docs/wsbar.html @@ -0,0 +1,134 @@ + + + + + + +i3: External workspace bars + + + + + + + +
+

i3 - improved tiling WM

 + +
+
+ +
+
+

i3 comes with i3bar by default, a simple bar that is sufficient for most users. +In case you are unhappy with it, this document explains how to use a different, +external workspace bar. Note that we do not provide support for external +programs.

+
+
+
+

Internal and external bars

+
+

The internal workspace bar of i3 is meant to be a reasonable default so that +you can use i3 without having too much hassle when setting it up. It is quite +simple and intended to stay this way.

+
+
+
+

dock mode

+
+

You typically want to see the same workspace bar on every workspace on a +specific screen. Also, you don’t want to place the workspace bar somewhere +in your layout by hand. This is where dock mode comes in: When a program sets +the appropriate hint (_NET_WM_WINDOW_TYPE_DOCK), it will be managed in dock +mode by i3. That means it will be placed at the bottom or top of the screen +(while other edges of the screen are possible in the NetWM standard, this is +not yet implemented in i3), it will not overlap any other window and it will be +on every workspace for the specific screen it was placed on initially.

+
+
+
+

The IPC interface

+
+

In the context of using an external workspace bar, the IPC interface needs to +provide the bar program with the current workspaces and output (as in VGA-1, +LVDS-1, …) configuration. In the other direction, the program has to be able +to switch to specific workspaces.

+

By default, the IPC interface is enabled and you can get the path to the socket +by calling i3 --get-socketpath.

+

To learn more about the protocol which is used for IPC, see docs/ipc.

+
+
+
+

Output changes (on-the-fly)

+
+

i3 implements the RandR API and can handle changing outputs quite well. So, an +external workspace bar implementation needs to make sure that when you change +the resolution of any of your screens (or enable/disable an output), the bars +will be adjusted properly.

+
+
+
+

i3-wsbar, an example implementation

+
+

i3-wsbar used to be the reference implementation before we had i3bar. +Nowadays, it is not shipped with release tarballs, but you can still get it at +https://github.com/i3/i3/blob/next/contrib/i3-wsbar

+
+

The big picture

+

The most common reason to use an external workspace bar is to integrate system +information such as what i3status or conky provide into the workspace bar. +So, we have i3status or a similar program, which only provides +text output (formatted in some way). To display this text nicely on the screen, +there are programs such as dzen2, xmobar and similar. We will stick to dzen2 +from here on. So, we have the output of i3status, which needs to go into dzen2 +somehow. But we also want to display the list of workspaces. i3-wsbar takes +input on stdin, combines it with a formatted workspace list and pipes it to +dzen2.

+

Please note that i3-wsbar does not print its output to stdout. Instead, it +launches the dzen2 instances on its own. This is necessary to handle changes +in the available outputs (to place a new dzen2 on a new screen for example).

+

+ +Overview + +

+
+
+

Running i3-wsbar

+

The most simple usage of i3-wsbar looks like this:

+
+
+
i3-wsbar -c "dzen2 -x %x -dock"
+
+

The %x in the command name will be replaced by the X position of the output +for which this workspace bar is running. i3 will automatically place the +workspace bar on the correct output when dzen2 is started in dock mode. The +bar which you will see should look exactly like the internal bar of i3.

+

To actually get a benefit, you want to give i3-wsbar some input:

+
+
+
i3status | i3-wsbar -c "dzen2 -x %x -dock"
+
+
+
+
+
+
+ + + diff --git a/docs/wsbar.png b/docs/wsbar.png new file mode 100644 index 0000000..0789dec Binary files /dev/null and b/docs/wsbar.png differ diff --git a/robots.txt b/robots.txt new file mode 100644 index 0000000..c6742d8 --- /dev/null +++ b/robots.txt @@ -0,0 +1,2 @@ +User-Agent: * +Disallow: /