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 ranges 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 of 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 file in it,
           and load recursively any subdirectory

       •   if it does not exist, 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.

SEE ALSO

       For more information, look at the individual Kakoune-related manual pages:

       •   kak_commands(1)

       •   kak_execeval(1)

       •   kak_expansions(1)

       •   kak_faces(1)

       •   kak_faq(1)

       •   kak_highlighters(1)

       •   kak_hooks(1)

       •   kak_options(1)

       •   kak_registers(1)

       •   kak_scopes(1)

       •   kak_shortcuts(1)

                                            10/26/2017                                     KAK(1)