NAME

       kak - a vim inspired, selection oriented code editor

SYNOPSIS

       kak -help

       kak -version

       kak -l

       kak -clear

       kak -f keys [-q] [-i] file...

       kak -p session_id

       kak -s session_id -d [-n] [-ro] [-E command] [+line[:column]|+:] file...

       kak  [-c session_id|-s session_id] [-n] [-ro] [-ui ui_type] [-e command] [-E command] [+line[:column]|+:]
       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.

       For  more  information,  use  the  :doc  command  after   starting   Kakoune,   the   Kakoune   wiki   at
       https://github.com/mawww/kakoune/wiki or the main Kakoune web site: https://kakoune.org/

OPTIONS

       -help  display a help message and quit

       -version
              display kakoune version and quit

       -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 command after the client initialization phase

       -E command
              execute command after the server initialization phase

       -f keys
              enter in filter mode: select the whole file, then execute keys

       -i suffix
              backup the files on which a filter is applied using the given suffix

       -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
              set 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

       +line[:column]
              specify  a  target  line  and  column for the first file; when the plus sign is followed by only a
              colon, then the cursor is sent to the last line of the file

       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

       Edit a file:

              kak /path/to/file

       Edit multiple files (multiple buffers will be created):

              kak ./file1.txt /path/to/file2.c

       Insert a modeline that sets the tabstop variable at the beginning of several source code files:

              kak -f "ggO// kak: tabstop=8<esc>" *.c

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

       vi(1), vim(1), sam(1plan9)

                                                                                                          KAK(1)