Provided by: kakoune_2019.01.20-2_amd64 bug

NAME

       kak - a vim inspired, selection oriented code editor

SYNOPSIS

       kak  [-help]  [-version]  [-q]  [-n]  [-l]  [-ro]  [-clear] [-ui ui_type] [-e command] [-E
       command] [-f keys] [-p session_id] [-c session_id|[[-d] -s session_id] [+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.

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.

                                                                                           KAK(1)