-*- text -*- Last modified Sat May 2 19:45:08 1998 This is an incomplete and probably out-of-date list of all the packages distributed on ftp.gnu.org and its mirror sites with a brief description explaining what each one is. More information about these programs can typically be found in the GNU Bulletin. To receive a copy, write to gnu@gnu.org. Problems with the contents of this file (or problems pertaining to the packaging of these programs, e.g. if a file is corrupted) should be sent to gnu@gnu.org. Bug reports for the programs themselves should go to the appropriate address indicated in the instructions with that program and its source code. Because the unix `compress' utility is patented (by two separate patents, in fact), we cannot use it; it is not free software. Therefore, the GNU Project has chosen a new compression utility, `gzip', which is free of any known software patents and which tends to compress better anyway. Files compressed with this new compression program end in `.gz' (as opposed to `compress'-compressed files, which end in `.Z'). Gzip can uncompress `compress'-compressed files and SVR4 `pack' files (which end in `.z'). This is possible because the various decompression algorithms are not patented---only compression is. The gzip program is available from any GNU mirror site in shar, tar, or gzipped tar format (for those who already have a prior version of gzip and want faster data transmission). It works on virtually every unix system, MSDOS, OS/2, and VMS. Filenames below ending with "/" are directories. Other entries are plain files. COPYING-1.0 Version 1 of the GNU General Public License. COPYING-2.0 Version 2 of the GNU General Public License. COPYING.LIB-2.0 Version 2 of the GNU General Public Library License (there is no version 1). GNUinfo/ General files of interest about the GNU Project, most of them included in the GNU Emacs distribution. MailingListArchives/ Archives of the GNU mailing lists (most of which are also gatewayed to the various gnu.* newsgroups). MicrosPorts/ The GNU Project is not directly interested in integrating or maintaining ports of GNU software to many micro-computer systems, like Amiga's or MSDOS, because of limited resources. However, a few files with pointers to people who do maintain GNU software for these other systems are available in this directory. ProgramIndex A file with an index of which package each GNU program is in. The rest of this file is the articles ``Forthcoming GNUs'' and ``GNU Software'' from the most recent GNU's Bulletin. They contain descriptions of our software. For more infomation on FSF's tapes, diskettes and CD-ROMs see the file /pub/gnu/GNUinfo/ORDERS FTPable from ftp.gnu.org or one of its mirror sites. ---------------------------------------------------------------------- `acct' is a system accounting package. It includes the programs `ac' (summarize login accounting), `accton' (turn process accounting on or off), `last' (show who has logged in recently), `lastcomm' (show which commands have been used recently), `sa' (summarize process accounting), `dump-utmp' (print a `utmp' file in human-readable format), & `dump-acct' (print an `acct' or `pacct' file in human-readable format). * `acm' (SrcCD) `acm' is a LAN-oriented, multiplayer, aerial combat simulation that runs under the X Window System. Players engage in air to air combat against one another using heat seeking missiles and cannons. We are working on a more accurate simulation of real airplane flight characteristics. * aegis (SrcCD) Aegis is a transaction-based software configuration management system. It provides a framework within which a team of developers may work on many changes to a program concurrently, and Aegis coordinates integrating these changes back into the master source of the program, with as little disruption as possible. * Apache *Also see* `http://www.apache.org/' (SrcCD) Apache is an HTTP server used on almost 50% of the Web sites on the Internet. It has an extensive API for modular enhancements, many features, and a large family of add-ons; it is highly flexible, runs on many popular operating systems, and has an active development group and user community. * Autoconf (SrcCD) Autoconf produces shell scripts which automatically configure source code packages. These scripts adapt the packages to many kinds of Unix-like systems without manual user intervention. Autoconf creates a script for a package from a template file which lists the operating system features which the package can use, in the form of `m4' macro calls. Autoconf requires GNU `m4' to operate, but the resulting configure scripts it generates do not. * Automake (SrcCD) Automake is a tool for generating `Makefile.in' files for use with Autoconf. The generated makefiles are compliant with GNU Makefile standards. * BASH (SrcCD) GNU's shell, BASH (Bourne Again SHell), is compatible with the Unix `sh' and offers many extensions found in `csh' and `ksh'. BASH has job control, `csh'-style command history, command-line editing (with Emacs and `vi' modes built-in), and the ability to rebind keys via the `readline' library. BASH conforms to the POSIX 1003.2-1992 standard. * bc (SrcCD) `bc' is an interactive algebraic language with arbitrary precision numbers. GNU `bc' follows the POSIX 1003.2-1992 standard with several extensions, including multi-character variable names, an `else' statement, and full Boolean expressions. The RPN calculator `dc' is now distributed as part of the same package, but GNU `bc' is not implemented as a `dc' preprocessor. * BFD (BinCD, SrcCD) The Binary File Descriptor library allows a program which operates on object files (e.g., `ld' or GDB) to support many different formats in a clean way. BFD provides a portable interface, so that only BFD needs to know the details of a particular format. One result is that all programs using BFD will support formats such as a.out, COFF, and ELF. BFD comes with Texinfo source for a manual (not yet published on paper). At present, BFD is not distributed separately; it is included with packages that use it. * Binutils (BinCD, SrcCD) Binutils includes these programs: `addr2line', `ar', `c++filt', `gas', `gprof', `ld', `nm', `objcopy', `objdump', `ranlib', `size', `strings', & `strip'. Binutils version 2 uses the BFD library. The GNU assembler, `gas', supports the a29k, Alpha, ARM, D10V, H8/300, H8/500, HP-PA, i386, i960, M32R, m68k, m88k, MIPS, Matsushita 10200 and 10300, NS32K, PowerPC, RS/6000, SH, SPARC, Tahoe, Vax, and Z8000 CPUs, and attempts to be compatible with many other assemblers for Unix and embedded systems. It can produce mixed C and assembly listings, and includes a macro facility similar to that in some other assemblers. GNU's linker, `ld', supports shared libraries on many systems, emits source-line numbered error messages for multiply-defined symbols and undefined references, and interprets a superset of AT&T's Linker Command Language, which gives control over where segments are placed in memory. `objdump' can disassemble code for most of the CPUs listed above, and can display other data (e.g., symbols and relocations) from any file format read by BFD. * Bison (BinCD, SrcCD) [FSFman, FSFrc] Bison is an upwardly compatible replacement for the parser generator `yacc'. Texinfo source for the `Bison Manual' and reference card are included. * C Library (`glibc') (BinCD, SrcCD) [FSFman] The GNU C library supports ISO C-1989, ISO C/amendment 1-1995, POSIX 1003.1-1990, POSIX 1003.1b-1993, POSIX 1003.1c-1995 (when the underlying system permits), & most of the functions in POSIX 1003.2-1992. It is nearly compliant with the extended XPG4.2 specification which guarantees upward compatibility with 4.4BSD & many System V functions. When used with the GNU Hurd, the C Library performs many functions of the Unix system calls directly. Mike Haertel has written a fast `malloc' which wastes less memory than the old GNU version. GNU `stdio' lets you define new kinds of streams, just by writing a few C functions. Two methods for handling translated messages help writing internationalized programs & the user can adopt the environment the program runs in to conform with local conventions. Extended `getopt' functions are already used to parse options, including long options, in many GNU utilities. The name lookup functions now are modularized which makes it easier to select the service which is needed for the specific database & the document interface makes it easy to add new services. Texinfo source for the `GNU C Library Reference Manual' is included (*note Documentation). Previous versions of the GNU C library ran on a large number of systems. The architecture-dependent parts of the C library have not been updated since development on version 2.0 started, so today it runs out of the box only on GNU/Hurd (all platforms GNU/Hurd also runs on) & GNU/Linux (ix86, Alpha, m68k, MIPS, Sparc, PowerPC; work is in progress for ARM). Other architectures will become available again as soon as somebody does the port. * Calc (SrcCD) [FSFman, FSFrc] Calc (written by Dave Gillespie in Emacs Lisp) is an extensible, advanced desk calculator & mathematical tool that runs as part of GNU Emacs. You can use Calc as a simple four-function calculator, but it has many more features including: choice of algebraic or RPN (stack-based) entry; logarithmic, trigonometric, & financial functions; arbitrary precision; complex numbers; vectors; matrices; dates; times; infinities; sets; algebraic simplification; & differentiation & integration. It outputs to `gnuplot', & comes with source for a manual & reference card (*note Documentation). * `cfengine' (SrcCD) `cfengine' is used to maintain site-wide configuration of a heterogeneous Unix network using a simple high level language. Its appearance is similar to `rdist', but allows many more operations to be performed automatically. See Mark Burgess, "A Site Configuration Engine", `Computing Systems', Vol. 8, No. 3 (ask `office@usenix.org' how to get a copy). * Chess (SrcCD) GNU Chess enables you to play a game of chess with a computer instead of a person. It is useful to practice with when there are significant spare cpu cycles and a real person is unavailable. The program offers a plain terminal interface, one using curses, and a reasonable X Windows interface `xboard'. Best results are obtained by compiling with GCC. Improvements this past year are in the Windows-compatible version, mostly bugfixes. Stuart Cracraft started the GNU mascot back in the mid-1980's. John Stanback (and innumerable contributors) are responsible for GNU's brain development and its fair play. Acknowledgements for the past year's work are due Conor McCarthy. Send bugs to `bug-gnu-chess@gnu.org' & general comments to `info-gnu-chess@gnu.org'. Visit the author's Web site at `http://www.earthlink.net/~cracraft/index.html'. Play GNU Chess on the Web at `http://www.delorie.com/game-room/chess'. * CLISP (SrcCD) CLISP is a Common Lisp implementation by Bruno Haible & Michael Stoll. It mostly supports the Lisp described by `Common LISP: The Language (2nd edition)' & the ANSI Common Lisp standard. CLISP includes an interpreter, a byte-compiler, a large subset of CLOS & a foreign language interface. The user interface language (English, German, French, Spanish) can be chosen at run time. An X11 API is available through CLX & Garnet. CLISP needs only 2 MB of memory & runs on all kinds of systems (Unix, MS-DOS, OS/2, Windows NT, Windows 95, Amiga 500-4000, Acorn RISC PC). See also item "Common Lisp", which describes GCL, a complete Common Lisp implementation with compiler. * CLX (SrcCD) CLX is an X Window interface library for GCL. This is separate from the built-in TK interface. * Common Lisp (`gcl') (SrcCD) GNU Common Lisp (GCL, formerly known as Kyoto Common Lisp) is a compiler & interpreter for Common Lisp. GCL is very portable & extremely efficient on a wide class of applications, & compares favorably in performance with commercial Lisps on several large theorem-prover & symbolic algebra systems. GCL supports the CLtL1 specification but is moving towards the proposed ANSI standard. GCL compiles to C & then uses the native optimizing C compiler (e.g., GCC). A function with a fixed number of args & one value turns into a C function of the same number of args, returning one value--so GCL is maximally efficient on such calls. Its conservative garbage collector gives great freedom to the C compiler to put Lisp values in registers. It has a source level Lisp debugger for interpreted code & displays source code in an Emacs window. Its profiler (based on the C profiling tools) counts function calls & the time spent in each function. There is now a built-in interface to the Tk widget system. It runs in a separate process, so users may monitor progress on Lisp computations or interact with running computations via a windowing interface. There is also an Xlib interface via C (xgcl-2). CLX runs with GCL, as does PCL (see "PCL" later in this article). GCL version 2.2.2 is released under the GNU Library General Public License. * cook (SrcCD) Cook is a tool for constructing files, and maintaining referential integrity between files. It is given a set of files to create, and recipes of how to create and maintain them. In any non-trivial program there will be prerequisites to performing the actions necessary to creating any file, such as include files. The `cook' program provides a mechanism to define these. Some features which distinguish Cook include a strong procedural description language, and fingerprints to supplement file modification time stamps. There is also a `make2cook' utility included to ease transition. * `cpio' (SrcCD) `cpio' is an archive program with all the features of SVR4 `cpio', including support for the final POSIX 1003.1 `ustar' standard. `mt', a program to position magnetic tapes, is included with `cpio'. * CVS (SrcCD) CVS is a version control system (like RCS or SCCS) which allows you to keep old versions of files (usually source code), keep a log of who, when, and why changes occurred, etc. It handles multiple developers, multiple directories, triggers to enable/log/control various operations, and can work over a wide area network. It does not handle build management or bug-tracking; these are handled by `make' and GNATS, respectively. * `cxref' (SrcCD) `cxref' is a program that will produce documentation (in LaTeX or HTML) including cross-references from C program source code. It has been designed to work with ANSI C, incorporating K&R, and most popular GNU extensions. The documentation for the subject program is produced from comments in the code that are appropriately formatted. The cross referencing comes from the code itself and requires no extra work. * DDD (SrcCD) The Data Display Debugger (DDD) is a common graphical user interface to GDB, DBX, and XDB, the popular Unix debuggers. DDD provides a graphical data display where complex data structures can be explored incrementally and interactively. DDD has been designed to compete with well-known commercial debuggers; as of release 2.1.1, DDD also compiles and runs with LessTif, a free Motif clone, without loss of functionality. For more details, see the DDD Web page at `http://www.cs.tu-bs.de/softech/ddd/'. * DejaGnu (SrcCD) DejaGnu is a framework to test programs with a single front end for all tests. DejaGnu's flexibility & consistency makes it easy to write tests. DejaGnu will also work with remote hosts and embedded systems. DejaGnu comes with `expect', which runs scripts to conduct dialogs with programs. * Diffutils (SrcCD) GNU `diff' compares files showing line-by-line changes in several flexible formats. It is much faster than traditional Unix versions. The Diffutils package has `diff', `diff3', `sdiff', & `cmp'. Future plans include support for internationalization (e.g., error messages in Chinese) & some non-Unix PC environments, & a library interface that can be used by other free software. * DJGPP *Also see "GCC" below* (BinCD) DJ Delorie has ported GCC/G++ to i386s running DOS. DJGPP has a 32-bit i386 DOS extender with a symbolic debugger, development libraries, & ports of Bison, `flex', & Binutils. Full source code is provided. It needs at least 5MB of hard disk space to install & 512K of RAM to use. It supports SVGA (up to 1024x768), XMS & VDISK memory allocation, `himem.sys', VCPI (e.g., QEMM, DESQview, & 386MAX), & DPMI (e.g., Windows 3.x, OS/2, QEMM, & QDPMI). Version 2 was released in Feb. 1996, & needs a DPMI environment; a free DPMI server is included. Web at `http://www.delorie.com/djgpp/' or FTP from `ftp.simtel.net' in `/pub/simtelnet/gnu/djgpp/' (or a SimTel mirror site). Ask `listserv@delorie.com', to join a DJGPP users mailing list. * `dld' (SrcCD) `dld' is a dynamic linker written by W. Wilson Ho. Linking your program with the `dld' library allows you to dynamically load object files into the running binary. `dld' supports a.out object types on the following platforms: Convex C-Series (BSD), i386/i486/Pentium (GNU/Linux), Sequent Symmetry i386 (Dynix 3), Sun-3 (SunOS 3 & 4), Sun-4 (SunOS 4), & VAX (Ultrix). * `doschk' (SrcCD) This program is a utility to help software developers ensure that their source file names are distinguishable on System V platforms with 14-character filenames and on MS-DOS systems with 8+3 character filenames. * `ed' (SrcCD) `ed' is the standard text editor. It is line-oriented and can be used interactively or in scripts. * Elib (SrcCD) Elib is a small library of Emacs Lisp functions, including routines for using AVL trees and doubly-linked lists. * Elisp archive (SrcCD) This is a snapshot of Ohio State's GNU Emacs Lisp FTP Archive. FTP it from `archive.cis.ohio-state.edu' in `/pub/gnu/emacs/elisp-archive'. * Emacs [FSFman(s), FSFrc] In 1975, Richard Stallman developed the first Emacs, an extensible, customizable real-time display editor & computing environment. GNU Emacs is his second implementation. It offers true Lisp--smoothly integrated into the editor--for writing extensions & provides an interface to the X Window System. It runs on Unix, MS-DOS, & Windows NT or 95. In addition to its powerful native command set, Emacs can emulate the editors vi & EDT (DEC's VMS editor). Emacs has many other features which make it a full computing support environment. Source for the `GNU Emacs Manual' & a reference card comes with the software. Sources for the `GNU Emacs Lisp Reference Manual' and `Programming in Emacs Lisp: An Introduction' are distributed in separate packages. *Note Documentation. * Emacs 20 (SrcCD) [FSFman(s), FSFrc] The new features in Emacs 20 include support for many languages and many character codes (the MULE facility) and a new convenient customization feature. The text-filling commands handle indented and bulleted paragraphs conveniently; there are new help facilities for looking up documentation about functions and symbols in various languages. A new method of file-locking works even when using NFS. Some dired commands have been made more systematic. We believe Emacs 20 operates on the same systems as Emacs 19, but we do not have confirmation for all of them. * Emacs 19 (SrcCD) [FSFman(s), FSFrc] Emacs 19 works with character-only terminals & with the X Window System (with or without an X toolkit). It also runs on MS-DOS, MS Windows, and with multiple-window support on MS Windows 95/NT. Emacs 19 works on: Acorn RISC (RISCiX); Alliant FX/2800 (BSD); Alpha (OSF/1 or GNU/Linux); Apollo (DomainOS); Bull DPX/2 2nn & 3nn (SysV.3) & sps7 (SysV.2); Clipper; Convex (BSD); Cubix QBx (SysV); Data General Aviion (DGUX); DEC MIPS (Ultrix 4.2, OSF/1, not VMS); Elxsi 6400 (SysV); Gould Power Node & NP1 (4.2 & 4.3BSD); Harris Night Hawk 1200, 3000, 4000 & 5000 (cxux); Harris Night Hawk Power PC (powerunix); Honeywell XPS100 (SysV); HP 9000 series 200, 300, 700, 800 (but not 500) (4.3BSD; HP-UX 7, 8, 9; NextStep); Intel i386/i486/Pentium (GNU/Hurd, GNU/Linux, 386BSD, AIX, BSDI/386, FreeBSD, Esix, ISC, MS-DOS, NetBSD, SCO3.2v4, Solaris, SysV, Xenix, WindowsNT, Windows95); IBM RS/6000 (AIX 3.2) & RT/PC (AIX, BSD); Motorola Delta 147 & 187 (SysV.3, SysV.4, m88kbcs); National Semiconductor 32K (Genix); NeXT (BSD, Mach 2 w/ NeXTStep 3.0); Paragon (OSF/1); Prime EXL (SysV); Pyramid (BSD); Sequent Symmetry (BSD, ptx); Siemens RM400 & RM600 (SysV); SGI Iris 4D (Irix 4.x & 5.x); Sony News/RISC (NewsOS); Stardent i860 (SysV); Sun 3 & 4, SPARC 1, 1+, 2, 10, Classic (SunOS 4.0, 4.1, Solaris 2.0-2.3); Tadpole 68k (SysV); Tektronix XD88 (SysV.3) & 4300 (BSD); & Titan P2 & P3 (SysV). * Emacs 18 (SrcCD) [FSFrc] Emacs 18 is several years old. We no longer maintain it, but still distribute it for those using platforms which Emacs 19 does not support. * `enscript' (SrcCD) `enscript' is an upwardly-compatible replacement for the Adobe `enscript' program. It formats ASCII files (outputting in Postscript) and stores generated output to a file or sends it directly to the printer. * `es' (SrcCD) `es' is an extensible shell (based on `rc') with first-class functions, lexical scope, exceptions, and rich return values (i.e., functions can return values other than just numbers). `es''s extensibility comes from the ability to modify and extend the shell's built-in services, such as path searching and redirection. Like `rc', it is great for both interactive use and scripting, particularly since its quoting rules are much less baroque than the C and Bourne shells. * Exim (SrcCD) Exim is an Internet mail transfer agent, similar in style to Smail 3. It can handle relatively high volume mail systems, header rewriting, control over which hosts/nets may use it as a relay, blocking of unwanted mail from specified hosts/nets/senders, and multiple local domains on one mail host ("virtual domains") with several options for the way these are handled. * `f2c' *Also see "Fortran" below & in *Note Forthcoming GNUs.* (SrcCD) `f2c' converts Fortran-77 source into C or C++, which can be compiled with GCC or G++. Get bug fixes by FTP from site `netlib.bell-labs.com' or by email from `netlib@netlib.bell-labs.com'. For a summary, see the file `/netlib/f2c/readme.gz'. * `ffcall' (SrcCD) `ffcall' is a C library for implementing foreign function calls in embedded interpreters by Bill Triggs and Bruno Haible. It allows C functions with arbitrary argument lists and return types to be called or emulated (callbacks). * Fileutils (SrcCD) The Fileutils are: `chgrp', `chmod', `chown', `cp', `dd', `df', `dir', `dircolors', `du', `install', `ln', `ls', `mkdir', `mkfifo', `mknod', `mv', `rm', `rmdir', `sync', `touch', & `vdir'. * Findutils (SrcCD) `find' is frequently used both interactively and in shell scripts to find files which match certain criteria and perform arbitrary operations on them. Also included are `locate', which scans a database for file names that match a pattern, and `xargs', which applies a command to a list of files. * Finger (SrcCD) GNU Finger has more features than other finger programs. For sites with many hosts, a single host may be designated as the finger "server" host and other hosts at that site configured as finger "clients". The server host collects information about who is logged in on the clients. To finger a user at a GNU Finger site, a query to any of its client hosts gets useful information. GNU Finger supports many customization features, including user output filters and site-programmable output for special target names. * `flex' (BinCD, SrcCD) [FSFman, FSFrc] `flex' is a replacement for the `lex' scanner generator. `flex' was written by Vern Paxson of the Lawrence Berkeley National Laboratory and generates far more efficient scanners than `lex' does. Sources for the `Flex Manual' and reference card are included (*note Documentation). * Fontutils (SrcCD) The Fontutils convert between font formats, create fonts for use with Ghostscript or TeX (starting with a scanned type image & converting the bitmaps to outlines), etc. It includes: `bpltobzr', `bzrto', `charspace', `fontconvert', `gsrenderfont', `imageto', `imgrotate', `limn', & `xbfe'. * Fortran (`g77') *Also *note Forthcoming GNUs.* (BinCD, SrcCD) GNU Fortran (`g77'), developed by Craig Burley, is available for public beta testing on the Internet. For now, `g77' produces code that is mostly object-compatible with `f2c' & uses the same run-time library (`libf2c'). * `gawk' (SrcCD) [FSFman] `gawk' is upwardly compatible with the latest POSIX specification of `awk'. It also provides several useful extensions not found in other `awk' implementations. Texinfo source for the `The GNU Awk User's Guide' comes with the software (*note Documentation). * `gcal' (SrcCD) `gcal' is a program for printing calendars. It displays different styled calendar sheets, eternal holiday lists, and fixed date warning lists. * GCC (BinCD, SrcCD) [FSFman] Version 2 of the GNU C Compiler supports the languages C, C++, and Objective-C; the source file name suffix or a compiler option selects the language. (Also see "GNAT" later in this article for Ada language supports.) Objective-C support was donated by NeXT. The runtime support needed to run Objective-C programs is now distributed with GCC. (This does not include any Objective-C classes aside from `object', but see "GNUstep" in *Note Forthcoming GNUs) G++ seeks to be compliant with the ANSI C++ language standard. GCC is a fairly portable optimizing compiler which performs many optimizations. They include: automatic register allocation, common sub-expression elimination (CSE) (including a certain amount of CSE between basic blocks - though not all the supported machine descriptions provide for scheduling or delay slots), invariant code motion from loops, induction variable optimizations, constant propagation, copy propagation, delayed popping of function call arguments, tail recursion elimination, integration of inline functions & frame pointer elimination, instruction scheduling, loop unrolling, filling of delay slots, leaf function optimization, optimized multiplication by constants, the ability to assign attributes to instructions, & many local optimizations automatically deduced from the machine description. GCC can open-code most arithmetic on 64-bit values (type `long long int'). It supports extended floating point (type `long double') on the 68k; other machines will follow. GCC supports full ANSI C, traditional C, & GNU C extensions (including: nested functions support, nonlocal gotos, & taking the address of a label). GCC can generate a.out, COFF, ELF, & OSF-Rose files when used with a suitable assembler. It can produce debugging information in these formats: BSD stabs, COFF, ECOFF, ECOFF with stabs, & DWARF. GCC generates code for many CPUs, including the a29k, Alpha, arc, ARM, AT&T, DSP1610, Clipper, Convex cN, Elxsi, Fujitsu Gmicro, i370, i860, i960, MIL-STD-1750a, MIPS, m32r, mn10200, mn10300, ns32k, PDP-11, Pyramid, ROMP, RS/6000, SH, SPUR, Tahoe, V850, VAX, & we32k. Position-independent code is generated for the Clipper, Hitachi H8/300, HP-PA (1.0 & 1.1), i386/i486/Pentium, m68k, m88k, SPARC, & SPARClite. Operating systems supported include: GNU/Hurd, GNU/Linux, ACIS, AIX, AOS, BSD, Clix, Concentrix, Ctix, DG/UX, Dynix, FreeBSD, Genix, HP-UX, Irix, ISC, Luna, LynxOS, Minix, NetBSD, NewsOS, NeXTStep, OS/2, OSF, OSF-Rose, RISCOS, SCO, Solaris 2, SunOS 4, System/370, SysV, Ultrix, Unos, VMS, & Windows/NT. Using the configuration scheme for GCC, building a cross-compiler is as easy as building a native compiler. Texinfo source for the `Using and Porting GNU CC' manual is included with GCC (*note Documentation). * GDB (BinCD, SrcCD) [FSFman, FSFrc] GDB, the GNU DeBugger, is a source-level debugger for C, C++, & Fortran. It provides partial support for Modula-2 & Chill. GDB can debug both C & C++, & will work with executables made by many different compilers; but, C++ debugging will have some limitations if you do not use GCC. GDB has a command line user interface, and Emacs has GDB mode as an interface. An X interface for GDB, called DDD, is described above. Executable files and symbol tables are read via the BFD library, which allows a single copy of GDB to debug programs with multiple object file formats (e.g., a.out, COFF, ELF). Other features include a rich command language, remote debugging over serial lines or TCP/IP, and watchpoints (breakpoints triggered when the value of an expression changes). GDB uses a standard remote interface to a simulator library which includes simulators for the ARM, Hitachi H8/300, Hitachi SH, & PowerPC. GDB can perform cross-debugging. To say that GDB "targets" a platform means it can perform native or cross-debugging for it. To say that GDB can "host" a given platform means that it can be built on it, but cannot necessarily debug native programs. GDB can: * "target" & "host": Amiga 3000 (AmigaOS, Amix, NetBSD), DEC Alpha (OSF/1), DECstation 3100 & 5000 (Ultrix), HP 9000/300 (BSD, HP-UX), HP 9000/700 (HP-UX 9, 10), i386/i486/Pentium (GNU/Hurd, GNU/Linux, BSD, FreeBSD, LynxOS, NetBSD, SCO, Windows NT), IBM RS/6000 (AIX 3.x, AIX 4.x, LynxOS), Motorola Delta m88k (System V, CX/UX), Motorola m68k MVME-167 (LynxOS), NCR 3000 (SVR4), PC532 (NetBSD), PowerPC (AIX 4.x, MacOS, Windows NT), SGI (Irix V3, V4, V5), SONY News (NewsOS 3.x), SPARC (LynxOS, NetBSD, Solaris 2.x, & SunOS 4.1), & Sun-3 (SunOS 4.1). * "target", but not "host": AMD 29000, ARM (RDP), Fujitsu SPARClite, Hitachi H8/300, Hitachi SH (CMON, SH3, E7000), HP PA Pro (Winbond, Oki), i960 (MON960, Nindy, VxWorks), m68k/m68332 (CPU32BUG, EST, ROM68K, VxWorks), Matra Sparclet, MIPS (IDT, PMON, VxWorks), PowerPC (PPCBug), & Z8000. * "host", but not "target": HP/Apollo 68k (BSD), IBM RT/PC (AIX), & m68k Apple Macintosh (MacOS). Sources for the manual, `Debugging with GDB', and a reference card are included (*note Documentation). * `gdbm' (SrcCD) `gdbm' is the GNU replacement for the traditional `dbm' and `ndbm' libraries. It implements a database using quick lookup by hashing. `gdbm' does not ordinarily make sparse files (unlike its Unix and BSD counterparts). * Generic NQS (SrcCD) Generic NQS is a network queuing system for spreading batch jobs across a network of machines. It is designed to be simple to install on a heterogeneous network of machines, and has optimizations for running on the high end, symmetric multiprocessing servers that are currently on the market. It is available for many more Unix variants than any other comparable product, and inter-operates with other NQS systems, including Cray's NQE. * `geomview' *See* `http://www.geom.umn.edu/software/geomview' (SrcCD) `geomview' is an interactive geometry viewing program, which requires Motif or LessTif and uses X, GL, or OpenGL graphics. It allows multiple independently controllable objects and cameras. External programs may drive desired aspects of the viewer, e.g. loading changing geometry or controlling motion, while allowing interactive mouse-and-GUI control of everything else. Controllable features include motion, appearance (wireframe, shading, lighting and material properties), mouse-based selection, snapshoting (PPM or SGI image, Postscript, and RenderMan formats), display in hyperbolic and spherical spaces, and projection from higher dimensions. Includes converters to display Mathematica and Maple 3-D graphics, and limited conversion to/from VRML. * `gettext' *Also *note Help the Translation Project.* (SrcCD) The GNU `gettext' tool set has everything maintainers need to internationalize a package's user messages. Once a package has been internationalized, `gettext''s many tools help translators localize messages to their native language and automate handling the translation files. * `gforth' (SrcCD) `gforth' is a fast, portable implementation of the ANS Forth language. * Ghostscript (SrcCD) Ghostscript is an interpreter for the Postscript and PDF graphics languages. The current version of GNU Ghostscript, 3.33, includes a Postscript Level 2 interpreter and a PDF 1.1 interpreter (except for encryption). Significant new features include the ability to convert PDF to Postscript. Ghostscript executes commands in the Postscript and PDF languages by writing directly to a printer, drawing on an X window, or writing to files for printing later or manipulating with other graphics programs. Ghostscript includes a C-callable graphics library (for client programs that do not want to deal with the Postscript language). It also runs on MS-DOS, MS Windows, OS/2, OpenVMS, and Mac OS (native on both 68K and PowerPC) but please do *not* ask the FSF staff any questions about this; we do not use these operating systems. * Ghostview (SrcCD) Tim Theisen, `ghostview@cs.wisc.edu', created Ghostview, a previewer for multi-page files with an X Window interface. Ghostview & Ghostscript work together; Ghostview creates a viewing window & Ghostscript draws in it. * The GIMP *Also see* `http://www.gimp.org/' The GIMP is the GNU Image Manipulation Program--a replacement for Adobe Photoshop. Although it is still considered to be in the testing stage, many users already regard it as superior to the original. * GIT (SrcCD) The GNU Interactive Tools package includes: an extensible file system browser, an ASCII/hex file viewer, a process viewer/killer, & other related utilities & shell scripts. It can be used to increase the speed & efficiency of many daily tasks, such as copying & moving files & directories, invoking editors, compressing/uncompressing files, creating & expanding archives, compiling programs, sending mail, etc. It looks nice, has colors (if the standard ANSI color sequences are supported), & is user-friendly. * gmp (SrcCD) GNU mp is a library for arithmetic on arbitrary precision integers, rational numbers, and floating-point numbers. It has a rich set of functions with a regular interface. A major new release, version 2, came out in Spring '96. Compared to previous versions, it is much faster, contains lots of new functions, & has support for arbitrary precision floating-point numbers. * GN (SrcCD) GN is a gopher/HTTP server. * Gnans (SrcCD) Gnans is a program (and language) for the numerical study of deterministic and stochastic dynamical systems. The dynamical systems may evolve in continuous or discrete time. Gnans has graphical & command line interfaces. * GNAT: The GNU Ada Translator (SrcCD) GNAT, a front end for the entire Ada 95 language, including all special needs annexes, is available via anonymous FTP from `cs.nyu.edu' and various mirror sites in `/pub/gnat'. SGI, DEC, and Siemens Nixdorf have chosen GNU Ada 95 as the Ada compiler for some of their systems. GNAT is maintained by Ada Core Technologies. For more information, see `http://www.gnat.com'. * GNATS (SrcCD) GNATS, GNats: A Tracking System, is a bug-tracking system. It is based upon the paradigm of a central site or organization which receives problem reports and negotiates their resolution by electronic mail. Although it has been used primarily as a software bug-tracking system so far, it is sufficiently generalized that it could be used for handling system administration issues, project management, or any number of other applications. * GnuGo (SrcCD) GnuGo plays the game of Go. It is not yet very sophisticated. * GNUMATH (`gnussl') (SrcCD) GNUMATH is a library (`gnussl') that simplifies scientific programming in C & C++. Its focus is on problems that can be solved by a straight-forward application of numerical linear algebra. It also handles plotting. It is in beta release; it is expected to grow more versatile & offer a wider scope in time. * `gnuplot' (SrcCD) `gnuplot' is an interactive program for plotting mathematical expressions and data. It plots both curves (2 dimensions) & surfaces (3 dimensions). It was neither written nor named for the GNU Project; the name is a coincidence. Various GNU programs use `gnuplot'. * `gnuserv' (SrcCD) `gnuserv' is an enhanced version of Emacs' `emacsclient' program. It lets the user direct a running Emacs to edit files or evaluate arbitrary Emacs Lisp constructs from another process. * `gpc' (SrcCD) The GNU Pascal Compiler (GPC) is part of the GNU compiler family, GNU CC or GCC. It combines a Pascal front end with the proven GNU compiler backend for code generation and optimization. Unlike utilities such as p2c, this is a true compiler, not just a converter. Version 2.0 of GPC corresponds to GCC version 2.7.2.1. The purpose of the GNU Pascal project is to produce a compiler which: * combines the clarity of Pascal with powerful tools suitable for real-life programming, * supports both the Pascal standard and the Extended Pascal standard as defined by ISO, ANSI and IEEE. (ISO 7185:1990, ISO/IEC 10206:1991, ANSI/IEEE 770X3.160-1989) * supports other Pascal standards (UCSD Pascal, Borland Pascal, Pascal-SC) in so far as this serves the goal of clarity and usability, * can generate code for and run on any computer for which the GNU C Compiler can generate code and run on. The current release (2.0) implements Standard Pascal (ISO 7185, level 0) and a large subset of Extended Pascal (ISO 10206) and Borland Pascal. The upcoming release 2.1 features better conformance to the various Pascal standards, and of course bug fixes. GNU Pascal sources are on `ftp://kampi.hut.fi/jtv/gnu-pascal/' (release) or `ftp://agnes.dida.physik.uni-essen.de/pub/gnu-pascal/' (development versions). * grep (SrcCD) This package has GNU `grep', `egrep', and `fgrep', which find lines that match entered patterns. They are much faster than the traditional Unix versions. * Groff (SrcCD) Groff is a document formatting system based on a device-independent version of `troff', & includes: `eqn', `nroff', `pic', `refer', `tbl', `troff'; the `man', `ms', & `mm' macros; & drivers for Postscript, TeX `dvi' format, the LaserJet 4 series of printers, and typewriter-like devices. Groff's `mm' macro package is almost compatible with the DWB `mm' macros with several extensions. Also included is a modified version of the Berkeley `me' macros and an enhanced version of the X11 `xditview' previewer. Written in C++, these programs can be compiled with GNU C++ Version 2.7.2 or later. Groff users are encouraged to contribute enhancements. Most needed are complete Texinfo documentation, a `grap' emulation (a `pic' preprocessor for typesetting graphs), a page-makeup postprocessor similar to `pm' (see `Computing Systems', Vol. 2, No. 2; ask `office@usenix.org' how to get a copy), and an ASCII output class for `pic' to integrate `pic' with Texinfo. Questions and bug reports from users who have read the documentation provided with Groff can be sent to `bug-groff@gnu.org'. * `guavac' (SrcCD) `guavac' is a free compiler for the Java language. * GTK GTK is the GNU GUI toolkit; it can be used from C and other compiled programming languages, and also from GUILE. * GUILE *Also *note GNUs Flashes.* (SrcCD) GUILE is GNU's Ubiquitous Intelligent Language for Extension, an interpreter for the Scheme programming language, packaged as a library that you can link into your programs to make them extensible. * `gzip' (BinCD, SrcCD) `gzip' can expand LZW-compressed files but uses another, unpatented algorithm for compression which generally produces better results. It also expands files compressed with System V's `pack' program. * `hello' (SrcCD) The GNU `hello' program produces a familiar, friendly greeting. It allows non-programmers to use a classic computer science tool which would otherwise be unavailable to them. Because it is protected by the GNU General Public License, users are free to share and change it. `hello' is also a good example of a program that meets the GNU coding standards. Like any truly useful program, `hello' contains a built-in mail reader. * `hp2xx' (SrcCD) GNU `hp2xx' reads HP-GL files, decomposes all drawing commands into elementary vectors, and converts them into a variety of vector and raster output formats. It is also an HP-GL previewer. Currently supported vector formats include encapsulated Postscript, Uniplex RGIP, Metafont, various special TeX-related formats, and simplified HP-GL (line drawing only) for imports. Raster formats supported include IMG, PBM, PCX, & HP-PCL (including Deskjet & DJ5xxC support). Previewers work under X11 (Unix), OS/2 (PM & full screen), & MS-DOS (SVGA, VGA, & HGC). * HylaFAX *Also see* `http://www.vix.com/hylafax/' (SrcCD) HylaFAX (once named FlexFAX) is a facsimile system for Unix systems. It supports sending, receiving, & polled retrieval of facsimile, as well as transparent shared data use of the modem. * Hyperbole (SrcCD) Hyperbole, written by Bob Weiner in Emacs Lisp, is an open, efficient, programmable information management, autonumbered outliner, & hypertext system, intended for everyday work on any platform Emacs runs on. * ID Utils (SrcCD) ID Utils is a package of simple, fast, high-capacity, language-independent tools that index program identifiers, literal numbers, or words of human-readable text. Queries can be issued from the command-line, or from within Emacs, serving as an augmented tags facility. * ILISP (SrcCD) ILISP is a powerful GNU Emacs interface to many dialects of Lisp, including GCL, KCL, AKCL, ECL, IBCL, Lucid, Allegro, Harlequin and CMUCL. Some Scheme implementations are supported also. * `indent' (SrcCD) GNU `indent' formats C source code into the GNU, BSD, K&R, or your own special indentation style. GNU `indent' is more robust & provides more functionality than other such programs, including handling C++ comments. It runs on Unix, Windows, VMS, ATARI and other systems. The next version which formats C++ source code will soon be released. * Inetutils (SrcCD) Inetutils has common networking utilities & servers. Version 1.3a is more portable than previous releases: Inetutils now works on GNU/Linux and SunOS/Solaris systems, although it still requires a system with some degree of BSD compatibility. This release also has many security holes plugged. * Ispell (SrcCD) Ispell is an interactive spell checker that suggests "near misses" to replace unrecognized words. System & user-maintained dictionaries for multiple languages can be used. Standalone & Emacs interfaces are available. * JACAL *Not available from the FSF except by FTP* JACAL is a symbolic mathematics system for the manipulation & simplification of algebraic expressions & equations. The FSF is not distributing JACAL on any physical media. You can FTP it, or visit the Web site `http://www-swiss.ai.mit.edu/~jaffer/JACAL.html'. * jargon (SrcCD) The jargon file is the online version of `The New Hacker's Dictionary'. * Karma (SrcCD) Karma is a signal and image processing library and visualization toolkit that provides interprocess communications, authentication, graphics display, and user interface to and manipulation of the Karma network data structure. Several foreign data formats are also supported. Karma comes packaged with a number of generic visualization tools and some astronomy-specific tools. * `less' (SrcCD) `less' is a display paginator similar to `more' and `pg', but with various features (such as the ability to scroll backwards) that most pagers lack. * LessTif (SrcCD) LessTif is a free clone of Motif. * `libg++' (Old C++ Library) (BinCD, SrcCD) The package was once main GNU C++ support library. More recently, it contained the `libstc++' library which provided the support for the forthcoming C++ standard, but `libstc++' is now a separate package (see below). `libg++' now contains only the old routines, supported for backwards compatibility; new programs should avoid using it. * `libstdc++' (BinCD, SrcCD) This library implements the library facilities defined by the forthcoming ISO C++ standard; it was formerly part of `libg++'. This includes strings, iostream, and various container classes. All of this is templatized. The package also contains the older libg++ library for backward compatibility, but new programs should avoid using it. * Libtool (SrcCD) GNU libtool is a generic library support script which manages the complexity of building and linking against shared libraries. Libtool allows source code package maintainers to easily add shared library support without breaking static-only platform compatibility. Libtool supports building static libraries on all known platforms. Shared library support has been implemented for several platforms. * Lout (SrcCD) Lout is a text formatter, approximately as powerful as TeX but with a cleaner programming language. * Lynx *Also see* `http://lynx.browser.org' (SrcCD) Lynx is a World Wide Web browser for those running "cursor-addressable" (text-only) terminals or terminal emulators. Lynx has been ported to text-based PC platforms such as DOS. * `m4' (SrcCD) GNU `m4' is an implementation of the traditional Unix macro processor. It is mostly SVR4 compatible, although it has some extensions (e.g., handling more than 9 positional parameters to macros). `m4' also has built-in functions for including files, running shell commands, doing arithmetic, etc. * `make' (BinCD, SrcCD) [FSFman] GNU `make' supports POSIX 1003.2 and has all but a few obscure features of the BSD and System V versions of `make', and runs on MS-DOS, AmigaDOS, VMS, & Windows NT or 95, as well as all Unix-compatible systems. GNU extensions include long options, parallel compilation, flexible implicit pattern rules, conditional execution, & powerful text manipulation functions. Source for the `Make Manual' comes with the program (*note Documentation). * MandelSpawn (SrcCD) A parallel Mandelbrot generation program for the X Window System. * Maxima (SrcCD) Maxima is a Common Lisp implementation of MIT's Macsyma system for computer based algebra. * MCSim (SrcCD) MCSim v4.2.0 is a general purpose modeling and simulation program. It provides numerical solution to sets of nonlinear (or linear) algebraic equations or ordinary differential equations. It also performs standard or Markov chain Monte Carlo simulations for Bayesian statistical inference. * Mesa (SrcCD) Mesa is a 3-D graphics library with an API which is very similar to that of OpenGL. * Meta-HTML (SrcCD) is a programming language specifically designed for working within the World Wide Web environment. It works by interpreting and executing an extended version of standard HTML on the server. With mSQL, mySQL, and other database access, statefull sessions and more, it provides the most commonly wanted Web functionality as built-in primitives, so you don't have to write them. * Midnight Commander (`mc') (SrcCD) The Midnight Commander is a user friendly & colorful file manager & shell, useful to novice & guru alike. It has a built-in virtual file system that manipulates files inside tar files or files on remote machines using the FTP protocol. This mechanism is extendable with external programs, and is the basis for the GNOME file manager. * Miscellaneous Files Distribution (SrcCD) The GNU Miscellaneous Files are non-crucial files that are common on various systems, including word lists, airport codes, ZIP codes, etc. * `mkisofs' (SrcCD) `mkisofs' is a pre-mastering program to generate an ISO 9660 file system. It takes a snapshot of a directory tree, and makes a binary image which corresponds to an ISO 9660 file system when written to a block device. It can also generate the System Use Sharing Protocol records of the Rock Ridge Interchange Protocol (used to further describe the files in an ISO 9660 file system to a Unix host; it provides information such as longer filenames, uid/gid, permissions, and device nodes). The `mkisofs' program is often used with `cdwrite'. The `cdwrite' program works by taking the image that `mkisofs' generates and driving a cdwriter drive to actually burn the disk. `cdwrite' works under GNU/Linux, and supports popular cdwriter drives. Older versions of `cdwrite' were included with older versions of `mkisofs'; `sunsite.unc.edu' has the latest version: `/pub/Linux/utils/disk-management/cdwrite-2.0.tar.gz'. * `mtools' (SrcCD) `mtools' is a collection of utilities to access MS-DOS disks from Unix without mounting them. It supports Windows 95 style long file names, FAT32, OS/2 Xdf disks, 2m disks (store up to 1992k on a high density 3 1/2 disk), and ZIP/JAZ disks. * MULE (SrcCD) MULE is a MULtilingual Enhancement to GNU Emacs. MULE text buffers can contain a mix of characters from many languages including: Japanese, Chinese, Korean, Vietnamese, Thai, modern European languages (including Greek & Russian), Arabic, & Hebrew. MULE also provides input methods for all of them. *Note GNU & Other Free Software in Japan, for more information about MULE. Emacs 20 includes most of the MULE features except for right-to-left writing, interface to external Japanese/Chinese conversion server programs, and terminal faces. These missing features will be included in Emacs soon. * `mutt' *Also see* `http://www.cs.hmc.edu/~me/mutt' (SrcCD) Mutt is a small but very powerful screen-oriented mail client, with support for MIME, message threading, color terms, and configurable key binding. * Nana (SrcCD) Nana is a debugging-support library; it provides improved support for assertion checking and logging, for programs written in C, C++ and Ada. * `ncurses' (SrcCD) `ncurses' implements the Unix `curses' API for developing screen-based programs that are terminal independent. It is not merely an emulation of old (BSD) curses/termcap, but is fully compatible with SVR4 curses/terminfo. It includes color, multiple-highlight, & xterm mouse-event support. * NetHack (SrcCD) NetHack is a display-oriented adventure game similar to Rogue. ASCII, X11, and various PC based GUI displays are supported. NetHack runs on GNU/Linux, Amiga, Atari, BeBox, Mac, MS Windows, MS-DOS, OS/2, Unix, VMS, and Windows NT. The current release of NetHack is 3.2.2. Bug reports concerning NetHack should be sent to `nethack-bugs@linc.cis.upenn.edu'. * NIH Class Library (SrcCD) The NIH Class Library is a set of C++ classes (similar to Smalltalk-80's) written in C++ by Keith Gorlen of the National Institutes of Health (NIH). * `nvi' (SrcCD) `nvi' is an implementation of the `ex'/`vi' Unix editor. It has all the functionality of the original `ex'/`vi', except `open' mode & the `lisp' edit option. Enhancements include multiple buffers, command-line editing & path completion, integrated Perl5 & Tcl scripting languages, Cscope support & tag stacks, 8-bit data support, infinite file/line lengths, infinite undo, language catalogs, incremental search, extended regular expressions, and security fixes. It uses Autoconf for configuration and runs on any Unix-like system. * Oaklisp (SrcCD) Oaklisp is a fast, portable, object-oriented Scheme with first class types. * Objective-C Library (SrcCD) Our Objective-C Class Library (`gstep-base.tar.gz', `libgnustep-base') has general-purpose, non-graphical Objective-C objects written by Andrew McCallum & others. It includes collection classes for maintaining groups of objects, I/O streams, coders for formatting objects & C types to streams, ports for network packet transmission, distributed objects (remote object messaging), string classes, invocations, notifications, event loops, timers, exceptions, pseudo-random number generators, & more. It has the base classes for the GNUstep project; all but a few of them have already been written. Send queries & bugs to `mccallum@gnu.org'. See "GNUstep" in *Note Forthcoming GNUs. * OBST (SrcCD) OBST is a persistent object management system with bindings to C++. OBST supports incremental loading of methods. Its graphical tools require the X Window System. It features a hands-on tutorial including sample programs. It compiles with G++, and should install easily on most Unix platforms. * Octave (SrcCD) Octave does arithmetic for real and complex scalars and matrices, solves sets of nonlinear algebraic equations, integrates systems of ordinary differential & differential-algebraic equations, and integrates functions over finite & infinite intervals. Two- & three-dimensional plotting is available using `gnuplot'. Version 2.0.9 includes support for dynamically linked functions, user-defined data types, many new functions, & a completely revised manual. Octave works on most GNU and Unix systems, OS/2, and Windows NT/95. * Oleo *Also *note Forthcoming GNUs.* (SrcCD) Oleo is a spreadsheet program (better for you than the more expensive spreadsheets). It supports the X Window System and character-based terminals, and can output Embedded Postscript renditions of spreadsheets. Keybindings should be familiar to Emacs users and are configurable. Oleo supports multiple variable-width fonts when used under the X Window System or outputting to Postscript devices. * `p2c' (SrcCD) `p2c' is Dave Gillespie's Pascal-to-C translator. It inputs many dialects (HP, ISO, Turbo, VAX, etc.) & generates readable, maintainable, portable C. * `patch' (SrcCD) `patch' applies `diff''s output to a set of original files to generate the modified versions. Recent versions of GNU `patch' can update files' timestamps as well as their contents. * PCL (SrcCD) PCL is a free implementation of a large subset of CLOS, the Common Lisp Object System. It runs under both GCL and CLISP, mentioned above. * `perl' (SrcCD) Larry Wall's `perl' combines the features & capabilities of C, `sed', `awk', & `sh', and provides interfaces to the Unix system calls & many C library routines. * PIPS (SrcCD) PIPS is the Parallel Information Processing System. It includes programs to convert data between the portable map image format (PNM) and the network common data format (NetCDF), and to perform several operations on NetCDF files in parallel. * plotutils (SrcCD) The GNU plotutils (plotting utilities) package includes `libplot', a subroutine library for producing 2-D device-independent vector graphics, and `graph', a sample application for plotting 2-D scientific data that is built on top of `libplot'. Supported devices include X Window System displays, Postscript devices, HP-GL/2 and HP-GL printers and plotters, and Tektronix emulators. `xfig' output format, which can be edited with the free graphics editor `xfig', is also supported. The Postscript output format includes directives which allow it to be edited with the `idraw' graphics editor. Included with `graph' are `spline', a program that uses splines in tension to interpolate data, and `ode', an application that will numerically integrate a system of ordinary differential equations. * PRCS (SrcCD) PRCS, the Project Revision Control System, is a version control program with purpose similar to that of CVS. It was designed with simplicity in mind. Like CVS, PRCS uses RCS to accomplish this task, but this is inconsequential to the user, as RCS is completely hidden beneath a layer of abstraction. * `ptx' (SrcCD) GNU `ptx' is our version of the traditional permuted index generator. It handles multiple input files at once, has TeX compatible output, & outputs readable "KWIC" (KeyWords In Context) indexes without using `nroff'. Plans are to merge this package into `textutils'. It does not yet handle input files that do not fit in memory all at once. * `rc' (SrcCD) `rc' is a shell that features a C-like syntax (much more so than `csh') and far cleaner quoting rules than the C or Bourne shells. It's intended to be used interactively, but is also great for writing scripts. It inspired the shell `es'. * RCS (SrcCD) RCS, the Revision Control System, is used for version control & management of software projects. Used with GNU `diff', RCS can handle binary files (8-bit data, executables, object files, etc). RCS now conforms to GNU configuration standards & to POSIX 1003.1b-1993. Also see the CVS item above. * `readline' (BinCD, SrcCD) Brian Fox wrote the `readline' library one weekend in 1987, so that the FSF would have a clean Emacs-like line editing facility that could be used across multiple programs. After installing it in Bash, he went on to test the reusability of the code by adding it to GDB, and then later, to the GNU FTP client. The library supplies many entry points--the simplest interface gives any program the ability to store a history of input lines, and gives the end user a complete Emacs-like (or vi-like) editing capability over the input, simply by replacing calls to `gets' with calls to `readline'. * `recode' (SrcCD) GNU `recode' converts files between character sets and usages. When exact transliterations are not possible, it may delete the offending characters or fall back on approximations. This program recognizes or outputs nearly 150 different character sets and is able to transliterate files between almost any pair. Most RFC 1345 character sets are supported. * `regex' (SrcCD) The GNU regular expression library supports POSIX.2, except for internationalization features. It is included in many GNU programs which do regular expression matching & is available separately. An alternate regular expression package, `rx', is faster than `regex' in many cases; we were planning to replace `regex' with `rx', but it is not certain this will happen. * Roxen (SrcCD) Roxen is a modularized, object-oriented, non-forking World Wide Web server with high performance and throughput, and capabilities for on the fly image generation (`http://www.roxen.com'). It was formerly named Spinner, but was renamed for trademark reasons. * `rsync' (SrcCD) `rsync' is a replacement for `rcp' that has many more features. `rsync' uses the "rsync algorithm", which provides a very fast method for synchronizing large remote files, sending only the differences across the link. It does not require both versions of a file to be local in order to compute the differences. A technical report describing the rsync algorithm is included with the package. * `rx' (SrcCD) Tom Lord has written `rx', a regular expression library which is generally faster and more correct than the older GNU `regex' library. * SAOimage (SrcCD) SAOimage is an X-based astronomical image viewer. It reads array data images, which may be in specific formats, and displays them with a pseudocolor colormap. There is full interactive control of the colormap, panning and zooming, graphical annotation, and cursor tracking in pixel and sky coordinates, among other features. * `screen' (SrcCD) `screen' is a terminal multiplexer that runs several separate "screens" (ttys) on a single character-based terminal. Each virtual terminal emulates a DEC VT100 plus several ISO 2022 and ISO 6429 (ECMA 48, ANSI X3.64) functions, including color. Arbitrary keyboard input translation is also supported. `screen' sessions can be detached and resumed later on a different terminal type. Output in detached sessions is saved for later viewing. * `sed' (SrcCD) `sed' is a stream-oriented version of `ed'. It comes with the `rx' library. * Sharutils (SrcCD) `shar' makes so-called shell archives out of many files, preparing them for transmission by electronic mail services; `unshar' helps unpack these shell archives after reception. `uuencode' and `uudecode' are POSIX compliant implementations of a pair of programs which transform files into a format that can be safely transmitted across a 7-bit ASCII link. * Shellutils (SrcCD) The Shellutils are: `basename', `chroot', `date', `dirname', `echo', `env', `expr', `factor', `false', `groups', `hostname', `id', `logname', `nice', `nohup', `pathchk', `printenv', `printf', `pwd', `seq', `sleep', `stty', `su', `tee', `test', `true', `tty', `uname', `uptime', `users', `who', `whoami', & `yes'. * Shogi (SrcCD) Shogi is a Japanese game similar to Chess; a major difference is that captured pieces can be returned into play. GNU Shogi is a variant of GNU Chess; it implements the same features & similar heuristics. As a new feature, sequences of partial board patterns can be introduced to help the program play toward specific opening patterns. It has both character and X display interfaces. It is primarily supported by Matthias Mutz on behalf of the FSF. * SIPP (SrcCD) SIPP is a library for photorealistically rendering 3D scenes. Scenes can be illuminated by an arbitrary number of light sources; they are built up of object hierarchies, with arbitrarily many subobjects and subsurfaces. Surfaces can be rendered with either Phong, Gouraud, or flat shading. The library supports programmable shaders and texture mapping. * Smail (SrcCD) Smail is a mail transport system, designed as a compatible drop-in replacement for `sendmail'. It uses a much simpler configuration format than `sendmail' and is designed to be setup with minimal effort. Current beta versions of `smail' which have enhanced security and anti-spam features are available from `ftp://ftp.planix.com/pub/Smail/'. * Smalltalk (SrcCD) GNU Smalltalk is an interpreted object-oriented programming language system written in highly portable C. It has been ported to MS-DOS, many Unixes, & other OSes. Features include a binary image save capability, the ability to call user-written C code with parameters, an Emacs editing mode, a version of the X protocol invocable from Smalltalk, optional byte-code compilation and/or execution tracing, & automatically loaded per-user initialization files. It implements all of the classes & protocol in the book "Smalltalk-80: The Language", except for the graphic user interface (GUI) related classes. * SNePS (SrcCD) SNePS is the Semantic Network Processing System. It is an implementation of a fully intensional theory of propositional knowledge representation and reasoning. SNePS runs under CLISP or GCL. * `spell' (SrcCD) GNU `spell' is a clone of standard Unix `spell', implemented as a wrapper to `ispell'. * `stow' (SrcCD) `stow' manages the installation of multiple software packages, keeping them separate while making them appear (via symbolic links) to be installed in the same place. For example, Emacs can be installed in `/usr/local/stow/emacs' and Perl in `/usr/local/stow/perl', permitting each to be administered separately, while with `stow' they will both appear to be installed in `/usr/local'. * Superopt (SrcCD) Superopt is a function sequence generator that uses an exhaustive generate-and-test approach to find the shortest instruction sequence for a given function. You provide a function as input, a CPU to generate code for, and how many instructions you want. Its use in GCC is described in the `ACM SIGPLAN PLDI'92 Proceedings'. It supports: SPARC, m68k, m68020, m88k, IBM POWER and PowerPC, AMD 29k, Intel x86 & 960, Pyramid, DEC Alpha, Hitachi SH, & HP-PA. * Swarm (SrcCD) Swarm is a software package for multi-agent simulation of complex systems being developed at The Santa Fe Institute. Swarm is intended to be a useful tool for researchers in a variety of disciplines, especially artificial life. The basic architecture of Swarm is the simulation of collections of concurrently interacting agents: with this architecture, a large variety of agent based models can be implemented. * `tar' (BinCD, SrcCD) GNU `tar' includes multi-volume support, the ability to archive sparse files, compression/decompression, remote archives, and special features that allow `tar' to be used for incremental and full backups. GNU `tar' uses an early draft of the POSIX 1003.1 `ustar' format which is different from the final version. This will be corrected in the future. * Termcap Library (SrcCD) [FSFman] The GNU Termcap library is a drop-in replacement for `libtermcap.a' on any system. It does not place an arbitrary limit on the size of Termcap entries, unlike most other Termcap libraries. Included is source for the `Termcap Manual' in Texinfo format (*note Documentation). * Termutils (SrcCD) The Termutils package contains programs for controlling terminals. `tput' is a portable way for shell scripts to use special terminal capabilities. `tabs' is a program to set hardware terminal tab settings. * TeX (SrcCD) TeX is a document formatter that is used, among other things, by the FSF for all its printed documentation. You will need it if you want to make printed manuals. See `http://www.tug.org/web2c/'. The Source Code CD-ROM contains a minimal TeX collection, sufficient to process Texinfo files. We hope to provide a full TeX distribution in the future. * Texinfo (SrcCD) [FSFman] Texinfo is a set of utilities (`makeinfo', `info', `install-info', `texi2dvi', `texindex', & `texinfmt.el') which generate printed manuals, plain ASCII text, & online hypertext documentation (called "Info"), & can read online Info documents; Info files can also be read in Emacs. Texinfo mode for Emacs enables easy editing & updating of Texinfo files. Source for the `Texinfo Manual' is included (*note Documentation). * Textutils (SrcCD) The Textutils programs manipulate textual data. They include: `cat', `cksum', `comm', `csplit', `cut', `expand', `fmt', `fold', `head', `join', `md5sum', `nl', `od', `paste', `pr', `sort', `split', `sum', `tac', `tail', `tr', `unexpand', `uniq', and `wc'. * TIFF library (SrcCD) The TIFF library, `libtiff', is a library for manipulating Tagged Image File Format files, a commonly used bitmap graphics format. * Tile Forth (SrcCD) Tile Forth is a 32-bit implementation of the Forth-83 standard written in C, allowing it to be easily ported to new systems & extended with any C-function (graphics, windowing, etc). Many documented Forth libraries are available, e.g. top-down parsing, multi-threads, & object-oriented programming. * `time' (SrcCD) `time' reports (usually from a shell) the user, system, & real time used by a process. On some systems it also reports memory usage, page faults, etc. * `ucblogo' (SrcCD) `ucblogo' implements the classic teaching language, Logo. * `units' GNU `units' converts between different units of measurement, such as miles/gallon to km/liter. (It can only handle multiplicative scale changes, so it cannot convert Celsius to Fahrenheit though it could convert temperature differences between those temperatures scales.) * UUCP (SrcCD) GNU's UUCP system (written by Ian Lance Taylor) supports the `f', `g' (all window & packet sizes), `v', `G', `t', `e', Zmodem, & two new bidirectional (`i' & `j') protocols. With a BSD sockets library, it can make TCP connections. With TLI libraries, it can make TLI connections. Source is included for a manual (not yet published by the FSF). * vera (SrcCD) VERA (Virtual Entity of Relevant Acronyms) is a document listing thousands of acronyms of the computer field. Updated tri-monthly. * viewfax (SrcCD) Viewfax is a tool for displaying fax files on an X display. It can display raw, digifax or tiff/f files, such as those received by HylaFAX. * VRweb (SrcCD) VRweb is a browser for 3D worlds and scenes modeled in VRML (the Virtual Reality Modeling Language), developed by Graz University of Technology, in Austria. * Emacs/W3 (SrcCD) Emacs/W3 (written by William Perry in Emacs Lisp) is an extensible, advanced World Wide Web browser that runs as part of Emacs. It includes support for frames, tables, stylesheets, and much more. See `http://www.cs.indiana.edu/elisp/w3/docs.html'. * `wdiff' (SrcCD) `wdiff' is a front-end to GNU `diff'. It compares two files, finding the words deleted or added to the first to make the second. It has many output formats and works well with terminals and pagers. `wdiff' is very useful when two texts differ only by a few words and paragraphs have been refilled. Plans are to merge this package into `diffutils'. * `Wget' (SrcCD) `Wget' non-interactively retrieves files from the Web using HTTP & FTP. It is suitable for use in shell scripts. * `windows32api' (SrcCD) `windows32' is a set of header files & import libraries that can be used by GNU tools for compiling & linking programs to be run on Windows NT/95. * WN (SrcCD) WN is a World Wide Web server designed to be secure and flexible. It offers many different capabilities in pre-parsing files before passing them to the client, and has a very different design from Apache and the NCSA server. * X11 (SrcCD) We distribute Version 11, Release 6.3 of the X Window System with the latest patches & bug fixes. X11 includes all of the core software, documentation, contributed clients, libraries, & toolkits, games, etc. While supplies last, we will distribute X11R5 on the November 1993 and earlier Source Code CD-ROMs. * `xboard' (SrcCD) `xboard' is a graphical chessboard for X Windows. It can serve as a user interface to the Crafty or GNU chess programs, the Internet Chess Servers, Email correspondence chess, or games saved in Portable Game Notation. * `xgrabsc' (SrcCD) `xgrabsc' is a screen capture program similar to `xwd' but with a graphical user interface, more ways of selecting the part of the screen to capture, & different types of output: Postscript, color Postscript, xwd, bitmap, pixmap, & puzzle. * `xinfo' (SrcCD) `xinfo' is an X-windows program for reading Info files. It uses a special widget, which is available for use in other programs. * `xmcd' *Also see* `http://sunsite.unc.edu/~cddb/xmcd/' (SrcCD) `xmcd' is an X11-based CD player utility and `cda' is a command-line driven, non-graphical CD audio player. `xmcd' is developed to use the OSF/Motif API (version 1.1 and later) and can also be used with LessTif, the free Motif clone. In its evolution over the past few years, `xmcd' has established itself as the premier CD player application for the X window system with an attractive, easy-to-use user interface. It is feature-rich and runs on virtually all of the popular Unix and OpenVMS platforms. It also supports the widest array of CD-ROM and CD-R devices, including some older SCSI-1 drives that do not work with other CD player applications. The remote CD database query feature fully utilizes the Internet and taps on a vast repository of CD artists/titles, track titles and other information. Multi-disc changers are also supported. Like many other CD player applications, `xmcd' supports a CD database of disc and track titles and other information. A distinguishing feature of `xmcd' is the ability to connect to a remote CD database server to query this information. Many public Internet CD database servers have been established around the world for this purpose, and `xmcd' also allows the user to submit new CD entries to the master database. * `xshogi' (SrcCD) `xshogi' is a graphical Shogi (Japanese Chess) board for the X Window System. It can serve as a user interface to GNU Shogi, as a referee for games between two humans, or as a client for the Internet Shogi Server. * `Ygl' (SrcCD) `Ygl' emulates a subset of SGI's GL (Graphics Language) library under X11 on most platforms with an ANSI C compiler (including GCC). It has most two-dimensional graphics routines, the queue device & query routines, double buffering, RGB mode with dithering, Fortran bindings, etc. * zlibc (SrcCD) Zlibc is an uncompressing C library for GNU/Linux, Solaris, SunOS systems. It is a preloadable shared object that allows executables to uncompress the datafiles that they need on the fly. No kernel patch, no recompilation of these executables and no recompilation of the libraries is needed; the package overrides the `open' function (and other system call functions) in the shared library. ---------------------------------------------------------------------- Forthcoming GNUs **************** Information about the current status of released GNU programs can be found in *Note GNU Software. Here is some news of future plans. * GNU Privacy Guard The GNU Privacy Guard is a free program for private communication using public key encryption. It will be released under the GNU GPL, and will be patent-free all around the world. Most of the code is written, but we can't predict yet when the release will be. After the GNU Private Guard is released, we hope to follow it with a free replacement for SSH, and then, if possible, free software for secure financial transations on the World Wide Web. * E-scape E-scape is a graphical web browser currently in development. We plan to support CSS1, PNG, tables, and frames. XML support and client-side scripting will likely be added eventually. E-scape is on hold right now. We don't know whether a free GNU web browser is still needed because we don't know whether the Netscape browser will be released on suitable terms. By April we will have cancelled E-scape, or resumed work at full speed. * GNOME GNOME is the GNU GUI desktop project, started by Miguel de Icaza in August 1997. It is based on the GTK GUI toolkit, and uses GUILE for extensibility. GNOME replaces the Teak project, which had been placed on hold while Jim Blandy finished the development of GUILE. GNOME provides a set of application framework libraries to facilitate making all applications consistent and hiding all of the configuration, session management, help and common user interface details from the programmer. We are using MICO, a GPL/LGPL implementation of CORBA, to export the functionality of our bigger applications as servers: editing interface, text editing, image editing, file management, document display, dictionary, calendar/tasks/rolodex. GNOME development is being carried out by numerous volunteers together with several programmers funded by Red Hat Software. * `gnusql' `gnusql' (formerly `gss') is the GNU SQL Server, a multiuser relational DBMS. An alpha release is currently available. For info on updates, paths, and most recent releases as well as links to related documentation, software, and mailing lists, see `http://www.ispras.ru/~gsql'. * GNU Emacs (For current status, *note GNU Software Now Available ) The next Emacs release, 20.3, will once again count buffer positions and string indices in characters, not bytes, even when you use multibyte characters. Future versions of Emacs will have support for variable-width fonts (already written) and inclusion of graphics in a document. Also, perhaps, the ability to save the undo history in a file (which allows you to undo older changes in the history). Our long term plan is to move it in the direction of a WYSIWYG word processor and make it easier for beginners to use. * GNUstep (Also see "Objective-C Library" in *Note GNU Software ) OpenStep is an object-oriented application programming interface specification being proposed as an open object standard. Since its announcement, there has been much interest in a GNU implementation, named GNUstep. Work has begun on GNUstep, starting with a library written in Objective-C. Much remains to be done to bring this library close to the OpenStep specifications. Volunteers should contact `gnustep-maintainer@gnu.org'. Also see `http://www.gnustep.org/'. * C Interpreter We hope to add interpreter facilities to our compiler and debugger. This task is partly finished. GCC generates byte code for all supported languages, but that support is in flux at this time. A new effort to finish this work has begun. To make this work usable, we need to enhance GDB to load the byte code dynamically. We would also like support for compiling just a few selected functions in a file. Due to limited resources, the FSF cannot fund this. Interested volunteers should contact `gnu@gnu.org'. * Fortran (For info on `f2c' & GCC, *note GNU Software Now Available ) The GNU Fortran (`g77') front end is stable, but more work is needed to bring its overall packaging, feature set, and performance up to the levels the Fortran community expects. Tasks to be done include: improving documentation and diagnostics; speeding up compilation, especially for large, densely initialized data tables; completing existing support for `INTEGER*2', `INTEGER*8', and similar features; allowing intrinsics in `PARAMETER' statements; and providing debug information on `COMMON' and `EQUIVALENCE' variables. We don't know when these things will be done, but hope some will be finished in the coming months. You can speed progress by working on them or by offering funding. A mailing list exists for announcements about `g77'. To subscribe, ask `info-gnu-fortran-request@gnu.org'. To contact the developer of `g77' or get current status, write or finger `fortran@gnu.org'. * Oleo (For current status, *note GNU Software Now Available ) Oleo is the spreadsheet program for the GNU project. We've brushed the dust off, and are working on giving Oleo a facelift. In Oleo's next release, it will support GTK++, as well as link in with Plotutils for graph creation. We are also "internationalizing" Oleo using GNU Gettext, to handle messages in languages other than English. Macros in Oleo will be handled in Guile to allow for the most flexible language possible. Many reported bugs from the last release (Oleo 1.6) have been fixed as well. Lastly, Oleo now has a complete set of documentation included in the package in Texinfo format. * The Dictionary Project The FSF has a copy of the unabridged `Century Dictionary', now in the public domain, and we want to put it online. We tried OCR, but it wasn't reliable enough. It looks like the only way to do this is to have people type it in. The job will need many volunteers; that means it first needs a manager with a can-do attitude and substantial time. If you want to volunteer to be the manager, please write to `gnu@gnu.org'. This project provides a way for people without programming skills or money to contribute to the GNU Project.