Provided by: crafty_23.4-6_i386 bug


       crafty - chess engine


       crafty [bookpath=<directory>] [logpath=<directory>]


       Crafty  is a chess "engine".  That is, the program concerns itself with
       playing chess and not with providing a graphic  user  interface.   Thus
       Crafty  is commonly invoked indirectly via XBoard, and current versions
       of these programs generally work very well together.   Some  noteworthy
       features of Crafty are:

       *  Source  code, provided, is unusually deserving of study.  The author
          has sought to provide a starting point  for  others  writing  chess-
          playing  programs,  leading  to  clean  and  portable code.  Another
          objective has been to maintain a state-of-the-art chess engine, with
          the  result that some parts of the source code may be challenging to

       *  Flexible and powerful command-line interface.  About the only  thing
          that  can  not  be  done  within  the  CLI is changing various paths
          determining where Crafty  reads  and  writes  various  files.   This
          manual page focuses on explaining these paths.

       *  Easy graphic user interface via xboard(6).

       *  Informative  log files.  Writes "game.nnn" file storing current game
          in PGN format, and also writes "log.nnn"  file  recording  what  the
          engine was "thinking".

       *  Intelligent  opening play.  Crafty learns from experience, and makes
          appropriate modifications to its opening book.  The  "book"  command
          allows   generation   of  an  opening  book  (from  PGN  data),  and
          customization of how it is used.  The learning facilities synthesize
          several different approaches, and allow various ways for the user to
          customize and follow what  is  being  learned.  Additional  commands
          allow  easy  creation  of  files  to  customize how Crafty plays the
          opening against humans and against other computer programs.

       *  Uses endgame tablebases.  Precompiled tablebases in the  appropriate
          format are freely downloadable from

       *  Polished  and  powerful  facilities for Internet play (for which the
          program continues to be extensively used).  Note that the  licencing
          forbids  concealing Crafty under another name, or unauthorized entry
          of it in a tournament in which other  computer  programs  have  been
          invited to compete.

       *  Annotation.   Generates  either  PGN or HTML files, in a manner made
          very flexible by choosing appropriate aptions  to  the  "annotate  |
          annotateh" command.


       In  the  command  line  arguments,  <directory-spec>  is  a  path  to a
       directory, whereas <directory-list> is a non-empty sequence of paths to
       directories.   For  portability, several different characters are taken
       as path separators: the colon (:), the semicolon  (;),  and  the  comma

       There  are  actually  four of these: bookpath is where Crafty seeks its
       opening books and writes learned knowledge;  logpath  is  where  Crafty
       normally  writes a pair of files "game.nnn" and "log.nnn" for each game
       it plays; rcpath is where Crafty looks for a run  control  file  to  be
       read only; and tbpath is where Crafty looks for endgame tablebase files
       to be read only.

       The four path specifications have a number of things in  common:   each
       has  a  default  value  set  when Crafty is compiled, which can then be
       modified by the appropriate environment variable, and can then again be
       modified  by  an invocation argument, but can not be modified after the
       engine has been initialized (thus, in particular, it is not possible to
       modify  the  paths  by  editing a run control file).  Possibly the best
       procedure is to avoid  the  invocation  options,  experiment  with  the
       environment  variables,  and  then  perhaps  recompile the program with
       different defaults.  Note that if the program is compiled "out  of  the
       box"  then  all  four  values  default  to "./" (the directory in which
       Crafty has been launched).

       Crafty can be  invoked  with  other  arguments  (such  as  "xboard"  to
       indicate  that  Crafty  is being invoked through xboard(6)) which would
       not usually be used directly.


       Crafty's extensive command-line interface  is  defined  in  "option.c",
       discussed in "crafty.doc", and briefly described by the command "help".


   Run control
       Crafty  tries  to read a run control file rcpath/.craftyrc.  (On a non-
       Unix system, ".craftyrc" changes to "crafty.rc".)  Such a  file  should
       contain  a sequence of valid Crafty commands, terminated by the command
       "exit" to restore standard input to the keyboard.  See craftyrc(5)  for
       a skeletal example.

       When  a game is played, Crafty normally writes "logpath/game.<nnn>" and
       "logpath/log.<nnn>". Details of what is written are modifiable  by  the
       `log'  command. Because $CRAFTY_LOG_DIR defaults to "./" (the directory
       in which Crafty is launched), trouble  can  occur  if  the  program  is
       launched  in a directory to which it is unable to write.  Note that the
       "log.<nnn>" file normally contains all output that would be visible  if
       Crafty  were run from the command line but is usually hidden when it is
       run from a GUI.

   Opening books
       Crafty is designed to maintain its chess opening knowledge  in  a  file
       "book.bin",  and  to  modify  this file as it learns from its mistakes.
       Refer to the documentation for the "book" command  for  information  on
       generating and customizing usage of "book.bin".

       Further,  files "books.bin" and "bookc.bin" allow easy customization of
       Crafty's opening play (against humans and computer, respectively).  See
       the documentation for the "books" command.

       Finally,  there  are  several files "*.lrn" for synopses of what Crafty
       has been learning.  See the documentation for the "learn" command.

   Endgame tablebases
       When normally configured, Crafty  reads  late  endgame  knowledge  from
       "*.emd"   files,   which  are  distance-to-mate  tablebases.   See  the
       documentation for the "egtb" command.


       If $CRAFTY_BOOK_PATH  is  set,  it  overrides  the  compiled  value  of
       bookpath,  the  path  to  directory  containing "book.bin" and friends.
       Unless learning has been disabled,  Crafty  will  be  writing  in  this

       If $CRAFTY_LOG_PATH is set, it overrides the compiled value of logpath,
       the path to directory for writing, but not reading, the log files.

       If $CRAFTY_RC_PATH is set, it overrides the compiled value  of  rcpath,
       the  path to directory for reading, but not writing, a run control file
       (".craftyrc" or "crafty.rc").

       If $CRAFTY_TB_PATH is set, it overrides the compiled value  of  tbpath,
       the  sequence  of  paths  to  directories for reading, but not writing,
       endgame tablebase files.


       craftyrc(5), xboard(6), /usr/share/doc/crafty


       Crafty is the son of Cray  Blitz,  also  written  by  Bob  Hyatt.   The
       subsequent  history  of Crafty is detailed in the source file "main.c".
       Opening books appeared in version  1.9.  log  files  in  1.11,  endgame
       tablebases  in  8.24,  run  control  files  in  9.22,  and  environment
       variables in 16.5.


       In the interests of portability, Crafty deals with files  in  a  simple
       manner,  at  the  cost of robustness.  Very long or incorrect paths may
       result in a "segmentation fault" when a file writing operation fails.

       This manual page itself will probably always be  flagrantly  incomplete
       in that many essential, powerful, and interesting aspects of Crafty are
       not even mentioned.


       Robert Hyatt (