# vile(1)

## NAME

           vile, xvile, uxvile, lxvile - VI Like Emacs

## SYNOPSIS

           vile  [@cmdfile] [+command] [-FhIiRVv] [-gNNN] [-kcryptkey] [-spattern]
           [-ttag] [filename]...

## DESCRIPTION

           vile  is  a  text  editor.   This  man  page  is  fairly  terse.   More
           information  can be obtained from the internal help, available with the
           -h option or by using the ":help" command from within vile.

           xvile is the same text editor, built as an X-windows application,  with
           fully integrated mouse support, scrollbars, etc.

           uxvile  is a wrapper around xvile which invokes the latter program with
           the correct locale environment required to use a unicode character  set
           and the "UXVile" X resource class set.

           lxvile  is a wrapper around xvile which invokes the latter program with
           a font chosen to match the current locale environment.

## SPIRIT

           vile retains the "finger-feel" if you will, of  vi,  while  adding  the
           multiple  buffer  and  multiple  window  features  of  emacs  and other
           editors.  It is definitely not a vi clone,  in  that  some  substantial
           stuff  is  missing,  and  the  screen doesn't look quite the same.  The
           things that you tend to type over and over probably work.  Things  done
           less  frequently,  like  configuring  a  startup file, are somewhat (or
           very, depending on how ambitious you are) different.  But what  matters
           most  is that one's "muscle memory" does the right thing to the text in
           front of you, and that is what vile tries to do for vi users.

## OPTIONS

           Vile accumulates most options into two temporary buffers [vileinit] and
           [vileopts].   The former is executed before reading the first file into
           a buffer.  The latter is executed after reading the first file  into  a
           buffer.  Each is removed after executing (unless an error is detected).

### COMMON OPTIONS

           -ccommand
                  vile will begin the session on the first file invoking the given
                  command.  Legal commands include many ex-style  commands,  vile-
                  commands,  etc.,  subject to shell quoting.  This option is used
                  most often with a line number or search pattern.  For example

                     vile -c123 filename
                     vile -c/pattern filename

                  They correspond to ex-style commands on the given file:

                     :123
                     :/pattern

                  These are more verbose equivalents:

                     vile -c'123 goto-line' filename
                     vile -c'search-forward /pattern/' filename

                  You can use more than one command, e.g.,

                     vile -c'123' -c'10*goto-col' filename

                  to put the cursor on column 10 of  line  123.   The  "*"(or  ":"
                  separates  the repeat count (used by goto-col) from the line- or
                  range-specification used by line-oriented commands.

           @cmdfile
                  vile will run the specified file as its startup file,  and  will
                  bypass  any  normal  startup file (i.e.  .vilerc) or environment
                  variable (i.e.  $VILEINIT).  This is added to [vileinit].

           -D     tells vile to trace the results  of  macro  execution  into  the
                  hidden buffer "[Trace]".

           -e | -E
                  Invokes  vile  in  "noview"  mode - changes are permitted to any
                  buffer while in this mode (see "-v".

           -F     will run the syntax filter that applies to each filename on  the
                  command-line,  and  write  the  attributed  text to the standard
                  output.

           -h     Invokes vile on the  helpfile.   See  "-?"  for  a  short  usage
                  message.

           -i | -I
                  Tells  vile  to  use  vileinit.rc  (which  is  installed) as the
                  initialization file.  If you do not have a  .vilerc,  vile  will
                  make  a  short  one  that  sources  vileinit.rc This is added to
                  [vileinit].

           -k cryptkey | -K cryptkey
                  Specifies an encryption/decryption key.  See below  for  further
                  discussion.   This  option  applies  only locally to the buffers
                  named on the command-line, and is not added to [vileopts], since
                  that is executed too late.

           -R     Invokes  vile in "readonly" mode - no writes are permitted while
                  in this mode.  (This will also be true if  vile  is  invoked  as
                  view, or if "readonly" mode is set in the startup file.)

           -s pattern | -S pattern
                  In  the  first file, vile will execute an initial search for the
                  given pattern.  This is not the same as "-c/pattern" since  that
                  positions  the  cursor  to  the line matching the pattern.  This
                  option positions the cursor within the line.

           -t tag
                  vile will edit the correct file  and  move  the  cursor  to  the
                  location  of the tag.  This requires a tagsfile created with the
                  ctags(1) command.  The option -T is equivalent, and can be  used
                  when X11 option parsing eats the -t.

           -U     overrides the $system-crlf variable, making new buffers start in
                  dos mode.

           -u     overrides the $system-crlf variable, making new buffers start in
                  nodos mode.

           -v     Invokes  vile  in  "view" mode - no changes are permitted to any
                  buffer while in this mode (see "-e".

           -V     vile will report its version number.

           -?     If an option is not recognized (or the  special  option  "?"  is
                  given),  vile  prints  a  short usage message.  Normally that is
                  sent to the standard output.   The  GUI  winvile  displays  this
                  information in a window.

### SCREENSIZE OPTIONS

           Screensize can be set from the command line for certain configurations:

           -25 -43 -50 -60
                  On  PC  systems  you  may  be  able  to  set  the initial screen
                  resolution from the command line.

           -80 -132
                  On VMS systems you  may  be  able  to  set  the  initial  screen
                  resolution from the command line.  See vile.hlp for details.

### X11 OPTIONS

           xvile-specific  command-line options are detailed in the help file (see
           "Standard  X  command  line  arguments".   The  standard  ones   (e.g.,
           -display, -fn, -geometry, -name, etc.) are all supported.

### OBSOLETE OPTIONS

           vile  recognizes  some options which duplicate the functionality of the
           POSIX "-c" option:

           +command
                  This has the same effect as "-ccommand"

           -g NNN | -G NNN
                  This has the same effect as "-cNNN" vile will begin the  session
                  on the first file jumping to the given line number NNN.

## INVOCATION

           vile  will  edit  the files specified on the command line.  If no files
           are specified, and standard input is not connected to a terminal,  then
           vile  will  bring  up  a buffer containing the output of the pipe it is
           connected to, and will re-open /dev/tty for  commands.   Files  (except
           for  the  first) are not actually read into buffers until "visited" All
           buffers are kept in memory: machines with not much memory or swap space
           may have trouble with this.

## STARTUP

           If  the @cmdfile option is given, then the file given as "cmdfile" will
           be run before any files are loaded.  If no @  option  appears,  startup
           commands will be taken from the user's VILEINIT variable, if it is set,
           from the file .vilerc in the current directory, if it exists,  or  from
           $HOME/.vilerc,  as  a  last  resort.  See the help file for examples of
           what sorts of things might go into these command files.

## COMMANDS

           Please refer to  the  help  available  within  vile  for  vile-specific
           commands.   (That  document,  however,  assumes  familiarity  with vi.)
           Short descriptions of each  vile  command  may  be  obtained  with  the
           ":describe-function" and ":describe-key" commands.  All commands may be
           listed with ":show-commands"

           Additional documentation on writing macros using the internal scripting
           language can be found in the file macros.doc, distributed with the vile
           source.

## RELATED PROGRAMS

### xvile

           vile may also be built and installed as xvile, in which case it behaves
           as  a  native  X  Windows  application,  with  scrollbars, better mouse
           support, etc.

           The help file has more information on this  in  the  section  X  Window
           System specifics.

### vile-manfilt

           There  is  a  program distributed with the vile source which is usually
           installed as vile-manfilt.  It may be used in conjunction with vile  or
           xvile  (with  the  help of the macros in the file manpage.rc) to filter
           and view system manual pages.  xvile will  even  (with  your  font  set
           properly)  display  certain portions of the manual page text in bold or
           italics as appropriate.

           See the help file section on Filtering "man" pages for details.

### Syntax filters

           Likewise, there are several language filters, e.g., vile-c-filt for  C,
           which  can  embolden,  underline, or perform coloring on program source
           code.

           Again,  see  the  help  file  section  on  Syntax  Coloring  for   more
           information.

## UTILITY SCRIPTS

           Vile  is not simply an interactive program.  Its macro language and use
           of environment variables lets it be useful in scripting.

### vile-libdir-path

           The syntax filters and vile-manfilt may  not  be  installed  where  you
           would  execute them in your PATH.  The vile-libdir-path script looks in
           the usual places and  prints  an  updated  PATH  variable  which  other
           scripts can use when executing these programs.

### vile-pager

           Vile  can  be used as a pager (typical examples include more and less).
           This script uses vile-manfilt to preprocess a file which  is  piped  to
           vile, adding markup which vile displays properly.

           Unlike  a  typical  pager,  vile-pager  handles multi-line color escape
           sequences, and multiple levels of overstrikes.  But  unlike  a  typical
           pager,  vile-pager  expects  the  pipe  to  be  closed before it starts
           displaying.

### vile-to-html

           Vile's "-F"  option  makes  it  act  like  a  smart  interface  to  the
           collection  of  syntax  filters.   But  its output uses vile's internal
           markup rather than standard escape sequences.  Vile's utilities include
           programs which translate that markup into different formats:

           atr2ansi
                  converts the markup to ANSI escape sequences.

           atr2html
                  converts the markup to HTML (with color).

           atr2text
                  converts the markup to plain text.

           The  vile-to-html script uses atr2html to convert a text file into HTML
           using color.

## ENCRYPTION

           The program vile-crypt can be used to encrypt/decrypt files  using  the
           same  algorithm as microEmac's internal crypt algorithm.  This program,
           which uses public domain code written by Dana  Hoggatt,  is  no  longer
           used in vile, though it is provided for compatibility.

           vile  currently  uses  the crypt(3) function for encryption/decryption,
           which is available on most Unix systems.  This  ensures  that  vile  is
           able  to  read  and  write files compatibly with vi (but not vim, which
           uses an different  algorithm  derived  from  info-zip).   The  editor's
           encryption/decryption key can be specified on the command line with "-k
           key" Text to be encrypted can be specified as filenames on the  command
           line, or provided as the standard input.

           On  systems with a getpass() library routine, the user will be prompted
           for the encryption key if it is not given  on  the  command  line.   To
           accommodate systems (such as linux) where the getpass() library routine
           is not interruptible from the keyboard, entering a  crypt-key  password
           which ends in ^C will cause the program to quit.

           See  the  help  file for more information on vile's encryption support,
           including a discussion of a collection of macros  that  interface  with
           GNU's gpg package.

## ENVIRONMENT VARIABLES

           VILEINIT
                  Editor initialization commands in lieu of a startup file.  These
                  are copied into [vileinit], and executed.

           VILE_HELP_FILE
                  Override the name of the help file, normally "vile.hlp".

           VILE_LIBDIR_PATH
                  Augment $PATH when searching for a filter program.

           VILE_STARTUP_FILE
                  Override the name of the startup file,  normally  ".vilerc"  (or
                  "vile.rc" for non-UNIX systems).

           VILE_STARTUP_PATH
                  Override the search path for the startup and help files.

## SEE ALSO

           Your favorite vi document, the file macros.doc, and the vile help page,
           available with the -h option or as the text file vile.hlp.

## DEBTS and CREDITS

           vile was originally built from a copy of microEmacs, so a large debt of
           gratitude  is  due  to the developers of that program.  A lot of people
           have helped with code and bug reports on vile.  Names are named at  the
           bottom of the help file.

## AUTHORS

           vile was created by Paul Fox, Tom Dickey, and Kevin Buettner.

## BUGS

           The  "VI Like Emacs" joke isn't really funny.  It only sounds that way.
           :-) Other suspicious  behavior  should  be  reported  via  the  project
           mailing list, or via the web-based bug reporting system.  Both of these
           are available here:

           https://savannah.nongnu.org/projects/vile

                                                                           VILE(1)