kakoune/doc/kak.1.txt

kak(1)
======

NAME
----
kak - a vim inspired, selection oriented code editor

SYNOPSIS
--------
*kak* [-q] [-n] [-l] [-ro] [-clear] [-ui ui_type] [-e command] [-f keys] [-p session_id] [-c session_id|[[-d] -s session_id] file ...

DESCRIPTION
-----------
Kakoune is a code editor heavily inspired by Vim, as such most of its commands are similar to Vi's ones, and it
shares Vi's "keystrokes as a text editing language" model.

Kakoune can operate in two modes, normal and insertion. In insertion mode, keys are directly inserted into the
current buffer. In normal mode, keys are used to manipulate the current selection and to enter insertion mode.

Kakoune has a strong focus on interactivity, most commands provide immediate and incremental results, while still
being competitive (as in keystroke count) with Vim.

Kakoune works on selections, which are oriented, inclusive range of characters, selections have an anchor and
a cursor character. Most commands move both of them, except when extending selection where the anchor character
stays fixed and the cursor one moves around.

OPTIONS
-------
-n::
	do not load resource files on startup ('kakrc', 'autoload', 'rc' etc)

-l::
	list existing sessions

-d::
	run as a headless session (requires -s)

-e <command>::
	execute the *command* after the initialization phase

-f <keys>::
	enter in 'filter mode' and execute *keys* on the files passed as arguments

-q::
	when in 'filter mode', don't print any errors

-p <session_id>::
	send the commands written on the standard input to session *session_id*

-c <session_id>::
	connect to the given session

-s <session_id>::
	rename the current session name to *session_id*

-ui <type>::
	select the user interface, can be one of 'ncurses', 'dummy' or 'json'

-clear::
	remove sessions that terminated in an incorrect state (e.g. after a crash)

-ro::
	enter in 'readonly mode', all the buffers opened will not be written to disk

file::
	one or more files to edit

At  startup, if -n is not specified, Kakoune will try to source the file '../share/kak/kakrc' relative to the
kak binary. This kak file will then try to recursively source any files in *$XDG_CONFIG_HOME*'/kak/autoload'
(with *$XDG_CONFIG_HOME* defaulting to *$HOME*'/.config', and falling back to '../share/kak/autoload' if that
autoload directory does not exist), and finally *$XDG_CONFIG_HOME*'/kak/kakrc'.

That leads to the following behaviour: by default, with no user autoload directory, the system wide autoload
directory is used, once the user wants control on autoloading, they can create an autoload directory and eventually
symlink individual scripts, or the whole system wide autoload directory. They can as well add any new scripts not
provided with Kakoune.

EXAMPLES
--------
kak /path/to/file::
	Edit a file

kak ./file1.txt /path/to/file2.c::
	Edit multiple files (multiple buffers will be created)

kak -f "ggO// kak: tabstop=8<esc>" *.c::
	Insert a modeline that sets the tabstop variable at the beginning of several source code files

FILES
-----
If not started with the -n switch, Kakoune will source the '../share/kak/kakrc' file relative to the kak binary,
which will source additional files:

	* if the *$XDG_CONFIG_HOME*'/kak/autoload' directory exists, load every '*.kak' files in it, and load
		recursively any subdirectory
	* if it does not exists, fall back to the system wide autoload directory in '../share/kak/autoload'

After that, if it exists, source the *$XDG_CONFIG_HOME*'/kak/kakrc' file which should be used for user
configuration. In order to continue autoloading site-wide files with a local autoload directory, just add a symbolic
link to '../share/kak/autoload' into your local autoload directory.