Next: Ha-Hm Up: Linux Software Encyclopedia Previous: Ga-Gm Contents

Gn-Gz

Last checked or modified: Feb. 28, 1997

Gnans: A program and language for the numerical analysis of deterministic and stochastic dynamical systems which may evolve in either continuous or discrete time. In Gnans a dynamical system is defined using a special equation oriented language which also allows arbitrary C++ code to be included in the description. The resulting definitions are sorted, translated into C++, and compiled and linked into an executable program. The system can then be solved numerically with the speed of a compiled program. Several numerical integrators are included in the distribution. A simple and intuitive GUI is available which makes it possible to control the program by interactively changing the governing parameters. Simple interactive 2-D plotting routines are also provided.
A source code distribution of Gnans is available as are binaries for various platforms including Linux Intel. A user's manual and reference guide is included in PostScript format.
[ftp://ftp.mathematik.uni-bremen.de/pub/gnans/]
GNAT: The GNU NYU Ada Translator is a complete compiler for Ada 95 integrated in the gcc compiler system, i.e. it is a front-end and runtime system for Ada which uses the gcc back-end as a retargetable code generator. The front-end is written in Ada 95 and the gcc back-end extended to meet the needs of Ada semantics. The front-end comprises four phases which communicate by means of a compact Abstract Syntax Tree (AST). GNAT also includes three other modules not involved in code generation but which are an integral part of any Ada compilation system: the runtime and tasking executive, the library manager, and the binder. These components are also written in Ada 95.
The GNAT compiler is available in both source code and binary distributions, but binaries available for several platforms including Linux Intel. The system is described in a technical report available in PostScript format. See also the GLADE package.
[http://www.gnat.com/]
Gnatlab: A program designed to be a tool for fast matrix manipulation and calculation using the MTL. It is easily extensible via a simple programming interface. The features include:

the basic math operations;

support for scalars, complex numbers, vectors, complex vectors, matrices, complex matrices and sparse matrices;

scripting functionality including I/O, comparison functions, control statements, logical operators, and user-defined functions;

a Lapack interface;

help functions; and

matrix creation functions.

A source code distribution is available under the GPL.
[http://www.lsc.nd.edu/students/arodrig6/gnatlab/]
GNet: A simple network library written in C and intended to be small, fast, and easy to use and port. GNet is object-oriented and built on top of glib. The features include:

TCP client and server sockets;

non-blocking TCP sockets;

UDP;

IP Multicast; and

Internet address abstraction.

A source code distribution is available under the GPL.
[http://www.eecs.umich.edu/~dhelder/misc/gnet/]
G95: A project whose goal is to create a free, open source Fortran 95 compiler. This is in the very early stage of development, with the current (10/00) version able to do nothing more than print the contents of internal data structures. Stay tuned.
[http://g95.sourceforge.net/]
GNOME: The GNU Network Object Model Environment is a project whose goal is to build a complete, user-friendly desktop based entirely on free software. GNOME will consists of a free and complete set of user friendly applications and desktop tools somewhat similar to CDE and KDE but based entirely on free software. The three main components of the project are:

CORBA for the network object interface;

GTK for the graphical toolkit; and

Guile for the extension language.

Several features are planned to enhance the standard X11 environment including:

a standard GNOME application framework for programmers to ensure a consistent user interface;

drag-and-drop between applications;

a comprehensive file manager on top of a virtual filesystem (VFS) which exports an API to other GNOME components;

objects which exist on the desktop;

use of CORBA to export interesting APIs between components to allow the use of the components from a wide variety of languages without having to write an interface for each; and

a powerful panel component (which can be written in any language supported by the CORBA bindings) with a default panel including a program launcher, an icon viewer, a docking area of mini-views of other apps.

Software packages that are part of the GNOME project include:

Aorta, a suite of personal management tools including an address book, task manager, and day planner;

Audiotechque, a sound and waveform editor;

Balsa, an e-mail reader;

ElectricEyes, a lightweight image viewer;

Express, a web browser;

gdm, an xdm clone;

genius, an advanced and fully featured calculator;

GLUe, a WYSIWYG page layout tool;

gncal, a calendar program;

GNOME Office, a suite of productivity applications;

GnoMoney, a Quicken-like software package;

Gtop, a process and system monitor;

gwp, a word processor;

Litespeed, an FTP client;

M, a cross-platform e-mail application supporting a wide range of e-mail transfer protocols and providing MIME support; and

xnet, an application for managing PPP connections.

These packages exist in various stages of completion. See the GNOME home site for further information.
A source code distribution of GNOME is available. THe current (3/98) alpha release is version 0.13. The requirements for compilation include Guile, gettext, GTK, GMP, and SLIB.
[http://www.gnome.org/]
GNOME-DB: A suite of libraries and applications for the GNOME desktop that allow easy access to a wide range of database systems. GNOME-DB is composed of three separate and independent layers:

a lower layer of database servers, i.e. CORBA servers that map database-specific APIs to the Gnome Data Access (GDA) model;

a middle layer consisting of a GDA client library sitting on top of the CORBA interface to allow access to client applications, and the GDA user interface library;

an upper layer consisting of applications making use of the middle layer, e.g. the rolodex application and the SQL front-end.

[http://www.gnome.org/gnome-db/]
GNOME Office: A suite of productivity applications for the GNOME desktop. It currently (12/99) consists of:

AbiWord, a word processor;

Gnumeric, a spreadsheet;

GIMP, an image editing program;

Dia, a drawing program for various kinds of diagrams;

Gill, a scalable vector graphics package;

Eye of Gnome, an image viewer;

GNOME-PIM, a personal information manager that is parat of the standard GNOME distribution; and

GNOME-DB, a suite of libraries and applications for accessing a wide range of database systems.

[http://www.gnome.org/gnome-office/]
Gnome Toaster: A CD creation suite intended to be a powerful authoring and copying tool for audio, data and mixed-mode CDs. The features include:

a multi-language GUI;

use of the GNOME/GTK+ interface supporting drag and drop;

copying CDs and writing ISO filesystems on the fly, i.e. without storing intermediate images;

creation of ISO filesystems via drag and drop with a file manager;

creation of El Torito bootable CDs;

filter support that allows any kind of music to be written to an audio track;

a track editor for arranging audio tracks on a CD;

a configurable precaching system for buffering tracks on a hard drive if data throughput isn't high enough;

multisession capabilities allowing incremental writes to archive CDs and editing the existing filesystem structure of a CD;

listening to music tracks before burning via a preview player; and

CD/RW blanking and writing.

This is available under the GPL.
[http://gnometoaster.rulez.org/]
gnotepad+: A simple editor for UNIX-based systems running X11 and GTK. This was designed to offer many of the features found in GUI-based editors with as little bloat as possible. The features include:

multiple windows and documents;

a GUI for changing all preferences;

unlimited undo and redo;

a recent document menu;

popup document lists, window lists and message boxes;

document autosaving;

saving window sizes and positions; and

file locking.

This is part of the GNOME project basic distribution.
[http://gnotepad.sourceforge.net/]
GNU: The GNU's Not UNIX project aims to develop a complete UNIX-compatible software system. The project is operated by the Free Software Foundation (FSF), an organization founded by Richard Stallman, one of the elder gods of the net. Most, if not all, of the GNU software conforms to POSIX standards. There is also an Unofficial GNU Site which was the preferred site before the appearance of the official site. See Loukides and Oram (1996).
The GNU software packages include:

Autoconf, which creates configuration scripts for software packages;

Automake, a makefile generator;

Bash, a UNIX shell or command interpreter;

bc, a calculator language which supports arbitrary precision numbers;

binutils, a package of software development tools including compilers, assemblers, linkers, debuggers, etc.;

Bison, a general purpose parser generator;

Calc, an advanced calculator and mathematical tool that runs in Emacs;

cfengine, a site configuration engine;

cpio, a program to manage archives of files;

CVS, a version control system;

DejaGnu, a framework for testing programs;

diffutils, a package of utilities for comparing and merging files;

dld, a library of C functions for performing dynamic link editing;

GCC, a compiler suite for C, C++, Fortran, etc.;

DJGPP, a suite of GUI utilities for DOS platforms;

ed, a line-oriented text editor;

Emacs, the text editor that can do anything;

Enscript, which converts ASCII files to PostScript for printing;

Fiasco, a replacement for the SPSS statistical software package;

fileutils, a set of file management utilities;

findutils, a set of utilities for finding files and performing actions on them;

Flex, a lexical analyzer;

fontutils, a package of utilities for manipulating fonts;

Gawk, an implementation of the Awk language;

gdb, a debugger that works with GCC;

gdbm, a library of database functions;

gettext, a set of tools for allowing other packages to produce multilingual messages;

gforth, an implemention of the Forth language;

Ghostscript, a PostScript interpreter;

git, a set of tools for browsing and viewing files;

GNUSSL, a scientific subroutine library;

GNUstep, a clone of Next OpenStep;

Groff, an implementation of the [t/n]roff text processing language and tools;

g77, a Fortran compiler;

Guile, the GNU extensbility library;

gzip, a file compression program;

HURD, the kernel of the GNU OS;

id-utils, a set of utilities for implementing an ID database;

inetutils, a set of networking utilities and servers;

JACAL, a symbolic mathematics system;

less, an improved implementation of the more paging utility;

Stow, a program for managing the installation of software packages; and

Teak, the GNU desktop interface.

Free programs which have been adopted as part of the GNU system include:

dbedit, a system for developing web database applications;

Exim, an experimental mail transfer agent;

Generic-NQS, a network queueing system;

GNAT, an Ada compiler suite;

Guavac, a compiler for the Java language;

HylaFAX, a telecommunication software package;

Karma, a toolkit for performing a wide variety of network, graphics, encryption, and other tasks;

Lynx, a text-only Web browser;

Octave, a high-level interactive language for numerical calculations;

Roxen, an HTTP server;

Wget, a non-interactive Web mirroring utiity; and

WN, an HTTP server.

[http://www.gnu.ai.mit.edu/]
GnuCash: A personal finance accounting application whose features include:

an easy-to-use interface no more difficult than using a check register;

a window with running reconciled and cleared balances;

tracking stocks individually or in a portfolio of accounts;

multiple currencies and currency trading;

automatic merging of Quicken files to eliminate duplication transactions;

reports including balance sheets, profit and loss and portfolio valuation that can also be printed in HTML format;

a chart of accounts with a master account and a hierarchy of detailed accounts beneath;

splitting single transactions into several pieces;

ensurance of double entry bookkeepping wherein every transaction debits one account and credits another by an equal amount;

income/expense account types for categorizing cash flow;

simultaneous display of multiple accounts in one register window;

file access locking in a network-safe manner to prevent damage via simultaneous accesses of the same file;

a byte-stream format that allows accounts to be transmitted to other processes via pipes or sockets; and

automatic portfolio updating by obtaining stock and mutual fund quotes from various web sites.

A source code distribution is available under the GPL. This is written in C with support for Perl, Scheme and Tcl for configuration and extensibility. A prototype user's guide is available.
[http://www.gnucash.org/]
GNU Classpath: A project to develop a free software replacement for the proprietary Java standard class libraries of Sun. The goal is to provide a 100% compatible version of the libraries as well as support for all UNIX-like operating systems.
[http://www.classpath.org/]
GNU cobol2c: A project to create a compiler for COBOL with the ability to interact with existing libraries and data files. The final compiler will be implemented as a standard front-end to the GNU C compiler back-end, and will implement a complete ANSI 85 COBOL grammar with complete functionality via runtime libraries.
[http://www.gnu.org/software/cobol/]
GNU-Win32 Project: This was renamed cygwin.
gnubc: A set of programs that run under the GNU bc program for interactively performing arbitrary precision integer arithmetic calculations. The gnubc programs include:

gcd, for calculating the sign function, absolute values, binomial coefficients, and much more;

euclid, for performing Euclid's algorithm;

jacobi, for calculating the Jacobi symbol and finding the square root of the quadratic residues a mod p via Serret's algorithm;

serret, for expressing a prime of the form 4n+1 as the sum of two squares using Serret's algorithm;

phi, for returning the number of distinct prime factors, the value of Euler's functions, the number of divisors, the sum of the divisors, the value of the Mobius function, and more for a given integer;

factors, for factoring an integer using the Brent-Pollard algorithm;

lucas, which performs the strong base 2 pseudoprime and Lucas psuedoprime tests on an integer;

primes, which prints the primes between two integers;

pell, which finds the least solution of Pell's equations;

surd, which finds the continued fraction expansion of a quadratic irrational;

fibonacci, which prints the Fibonacci and Lucas numbers;

rootd, which finds the continued fraction expansion of the square root of a given integer; and

pollard, which attempts to find a factor of an integer using the Pollard method.

[http://www.maths.uq.edu.au/~krm/gnubc.html]
GNUDL: The GNU Data Language is a planned high-level language and environment designed to allow flexible and powerful manipulation and plotting of data. It will provide some of the capabilities of high level languages for data analysis and plotting (e.g. Yorick, Matlab, Octave, and IDL, from which GNUDL gets it name and which the GNUDL author considers the most powerful of such languages). A primary goal is to eventually provide a vast library of numerical, signal processing, imaging processing, etc. routines that can be interactively used within the system.
The useful features of the aforementioned languages planned for replication include the immediate availability of graphing operations for data viewing with well-designed and extensible defaults, the ease and optimization of array operations, the publication quality of output graphics, and the availability on many platforms. General limitations of such languages that the author wants to circumvent include the special-purpose languages developed for each package. GNUDL will use Guile, a Scheme-based utility, as its language. This will allow the use of Scheme as well as a variety of other languages that can be run on top of Scheme to be used for programming applications. Guile also incorporates the Tcl/Tk toolkit, allowing GUI applications to be custom built. It is planned to used the Texinfo system for documentation, which will allows several types of documentation formats to be produced from a single source file. GNUDL will provide X Window and PostScript rendering of all plots (perhaps via Ghostview) to provide publication quality graphical output.
GNUDL is in the prototype stage (with alpha version 0.3 released in 2/96). The source code for the prototype version is available and is known to compile on Linux, IRIS and SunOS platforms. Installing GNUDL requires the prior installation of the aforementioned Guile distribution.
[http://nis-www.lanl.gov/~rosalia/]
GnuPaghe: GnuPaghe is a New Useless Program to Avoid Great Hand-made Elaborations. It aims to offer wages elaboration and bookkeeping facilities in a pure object-oriented N-tier client/server architecture. It does this by implementing electronic copies of real world object companies, employees and money fluxes. It also attempts to maintain records of actual work done by employees. This offers an object-oriented approach to the problem of corporate data manipulation by emulating the real world.
[http://gnupaghe.netpedia.net/]
GNUPG: The GNU Privacy Guard is a complete and free replacement for PGP. It does not use either IDEA or RSA and can thus be used without restrictions. It conforms to RFC 1991, has some extensions, and partly supports OpenPGP. The features of GNUPG include:

can be used as a filter program;

implements the PGP format described in RFC 1991 with some enchancements;

better functionality than PGP with some security enhancements;

decryption and verification of PGP 5.x messages;

support for ElGamal, DSA, Blowfish, CAST5, MD5, SHA-1, RIPE-MD-160 and TIGER;

creation of user ID in a standard format;

support for key expiration data; and

German and Italian language support.

A source code distribution of GNUPG is available and can be installed on most platforms via the usual GNU tools. Documentation is currently (5/98) in a man page although a manual is being written.
[http://www.gnupg.org/]

Geheimnis

A KDE shell for PGP or GNUPG.
[http://geheimnis.sourceforge.net/]

pgpgpg

A wrapper around GPG that takes PGP 2.6 command-line options, translates them into appropriate GPG commands, and then performs the desired actions.
[http://www.nessie.de/mroth/pgpgpg/]

Seahorse

A Gnome front-end for GNUPG.
[http://www1.kcn.ne.jp/~anthony/seahorse/]

TkPGP

A Tk shell for PGP or GNUPG.
[http://www.geocities.com/SiliconValley/Chip/3708/tkpgp/tkpgp.htm]
GNUPIC: A suite of microcontroller development tools for programming microcontrollers on nearly all platforms and operating systems. Microcontrollers are tiny computers on single chips, and are used in thousands of consumer and industrial electronics applications. The available software includes assemblers, disassemblers, compilers, simulators, programmers and libraries, many of which are amenable to use on Linux platforms.
[http://huizen.dds.nl/~gnupic/]

C2C

A C compiler for Microchip PIC and Scenic SX microcontrollers. The Linux version is free for non-profit usage.
[http://www.geocities.com/SiliconValley/Network/3656/c2c/c.html]

gpasm

A project to provide an open source replacement for the Microchip MPASM assembler. This supports all instruction sets of the PIC microcontrollers except for the 17Cxx, and also recognizes the Scenix extensions to the PIC instruction set.
[http://www.dattalo.com/gnupic/gpasm.html]

gpsim

A software simulator for the Microchip PIC microcontrollers. This has been designed to be as accurate as possible, i.e. including the entire PIC from the core to the I/O pins to all of the internal peripherals.
[http://www.dattalo.com/gnupic/gpsim.html]

Posit

A multitasking microcore for PIC16C84-based systems.
[http://www.geocities.com/SiliconValley/Network/3656/posit/posit.html]

P2C

A Pascal compiler for PIC and Scenix microcontrollers. The Linux version is free for non-profit use.
[http://www.geocities.com/SiliconValley/Network/3656/p2c/p.html]
Gnuplot: A command-line driven interactive function plotting utility for UNIX, DOS and VMS platforms. It handles both curves (2-D) and surfaces (3-D), with surfaces plotted as a mesh fitting the specified function, floating in the 3-D coordinate space, or as a contour plot on the x-y plane. There are many plot styles for 2-D plots. Gnuplot supports many different types of terminals and printers, and is most likely easier to install than anything here, even from source code.
[http://www.gnuplot.org/]

Gnuplot.py

A Python interface to Gnuplot.
[http://monsoon.harvard.edu/~mhagger/download/]

xgfe

An X11 GUI front-end to the Gnuplot package. It is written in C++ and uses the Qt widget set.
[http://home.flash.net/~dmishee/xgfe/xgfe.html]
GNU Prolog: A free Prolog compiler with constraint solving over finite domains. GNU Prolog accepts Prolog plus constraint programs and produces native binary code in the same manner as GCC. It additionally offers a classical interactive top-level interpreter with a debugger. The features include:

conformance to the ISO Prolog standard;

many extensions including global variables, definite clause grammars, a sockets interface, and an operating system interface;

over 300 built-in predicates;

Prolog and low-level WAM debuggers;

a line editing facility under the interactive interpreter with completion on atoms;

a bidirectional interface between Prolog and C;

a simple command-line compiler that accepts a wide variety of source files including Prolog, C and WAM files; and

a constraint solver with finite domain variables integrated into the Prolog environment, a wide variety of predefined constraints, several predefined enumeration heuristics, and user-defined contraints.

A source code distribution is available as is a user's and reference manual in the usual formats.
[http://pauillac.inria.fr/~diaz/gnu-prolog/]
Gnus: A drop-in replacement for GNUS as a Emacs newsreader for Usenet. New capabilities include subscribing to groups from as many servers as you like, reading mail, kill files featuring auto-expiring kill calls, scoring articles in various ways, support of virtual newsgroups, and more.
[http://www.gnus.org/]
GNUSSL: The GNU Scientific Subroutine Library is a software package designed to simplify programming for scientific applications. The primary focus is on numerical linear algebra and problems which may be solved with straightforward applications of these algorithms. There are two components to the library: a C version and a C++ version, although the C component is simply a compiled interface to the C++ version. The C++ component is based primarily on vector and matrix classes supplied with libg++, which are template based and compatible with the standard template library (STL). The functionality of this package is provided in the form of template functions and classes plus a number of structures and functions with explicit C linkage.

The present (3/97) version of GNUSSL contains functions that can be divided into three areas: linear algebra, orthogonal and non-orthogonal function transforms, and a plotting class. The linear algebra library contains functions for performing Gauss-Jordan elimination, LU-decomposition, pivoting, reductions (Hessenberg and bi-diagonal), decomposition (QR and singular value), pseudo-inverses, Householder transformations, and Givens rotations. The function transforms include code for FFTs, discrete transforms, and expansion functions. The plotting class, called Viewport, contains many options for plotting and labeling 2- and 3-D plots. Much more is planned, including algorithms for sparse and banded matrices, support for arbitrary precision numbers, eigenvalue routines for Hermitian matrices, etc.
The package includes the source code written in C and C++. This was developed using the GNU C/C++ compiler and libraries and thus should compile on platforms with these installed. The documentation is contained within a GNUSSL user's guide and a guide to numerical template arrays in libg++, both of which are available in TeX or PostScript format. The file to look for is called gnussl-*.tar.gz, where * is the version number.
[http://www.gnu.ai.mit.edu/order/ftp.html]
[http://sourceware.cygnus.com/gsl/]
GNUStep: A project to port Next's OpenStep to UNIX platforms. GNUstep is not an operating system or a window manager, but ``a free, standard, object-oriented, cross-platform development environment meant to provide generalized interface design, a cohesive user interface, and look good as well.'' It is based on and completely compatible with the OpenStep specification originally developed by NeXT, and their are plans to track future changes in the MacOS X system to remain compatible. GNUstep is written in the object-oriented language Objective-C. It runs on top of X11 and uses a common imaging model called Display PostScript to do all its drawing. It will also work with GNOME and KDE.
[http://www.gnustep.org/]

JIGS

The Java Interface to GnuStep integrates Java and Objective-C, with the goal being to allow Java programmers to use the GNUstep libraries. Since the two languages are very similar, JIGS makes it possible to use Objective-C classes from Java using exactly the same API and vice-versa. JIGS can also automatically generate wrappers for newly created Objective-C GNUstep libraries.
[http://www.gnustep.it/jigs/]
GNU C Library: The C library used in the GNU system and in most systems with a Linux kernel. This generally supports the ISO C and POSIX standards as well as the features of several popular UNIX variants when they don't conflict with those standards. Nearly all known and useful functions from other C libraries are currently (7/99) available in the GNU C Library. The most recent version is denoted glibc 2. On Linux systems glibc 2 is also generically known as libc 6, the successor to the previous glibc/libc 5 version. Currently (circa mid-1999) the Linux community is in the midst of a painful transition from libc 5 to libc 6, with all sorts of compatibility problems arising. These should be ironed out before long, and there is plenty of documentation (see below) to help smooth the transition for Joe Average User.
The significant improvements of glibc 2 over previous versions include:

a thread safe implementation in which functions with interfaces prohibiting a thread safe design are reimplemented with a reentrant counterpart;

an improved scheme for handling name databases;

a more correct and faster math library;

the addition of several new POSIX functions as well as the modification of existing functions to bring them closer to POSIX compliance;

reduced dependency on kernel header files;

use of GNATS for tracking bug reports;

clean header files and name space;

a single source tree for multiple platforms;

a 64-bit clean implementation.

Compilation of the glibc 2.1 (or higher) release requires either egcs 1.0.3 or higher or GCC 2.8.1 or higher, with the former the preferable option (at least until the egcs/GCC convergence is complete). Recent versions of binutils, texinfo, make, gawk and Perl may also be required. Check the INSTALL file in the distribution for details. The library is documented in a nearly 1000 page document in Texinfo format. See Garzik (2000).
Useful sites and documents include:

GNU Libc 2 for Linux FAQ
[http://www.gnu.org/software/libc/faq-index.html]

Glibc 2 HOWTO
[http://www.gnu.org/software/libc/Glibc2-HOWTO.html]

Installing Glibc-2 on Linux
[http://huizen.dds.nl/~frodol/glibc/]

Glibc Problems
[http://www.gnu.org/software/libc/problems.html]

[http://www.gnu.org/software/libc/libc.html]

Glibc Test Tool

A tool developed to examine the internationalization (I18N) APIs provided by Glibc. This tool was developed to conform to or support the following standards and implementations:

ISO/IEC 9945-1;

ISO/IEC 9945-2;

ISO/IEC 9899;

ISO/IEC 9899 Amendment 1;

cultural convention specification PDTR (future ISO/IEC Technical Report 14652);

X/Open Portability Guide Issue 4; and

LI18NUX 2000 Globalization Specification.

This requires Glibc 2.1.X or above, and is currently (10/00) optimized for Glibc 2.2.
[http://oss.software.ibm.com/developerworks/opensource/glibctest/]
GNU Make: A program for redirecting compilation which automatically determines which pieces of a large program need to be compiled and issues commands to recompile them. This GNU version of the widely used UNIX make utility conforms to section 6.2 of IEEE Standard 1003.2-1992 (POSIX.2). This utility can be used with any programming language whose compiler can be run with a shell command, and is not limited to programming languages. It can perform any task wherein some files must be automatically updated from others whenever the others change. The make utility is used by creating a makefile which contains descriptions of the relationships among files in a package and a procedure for updating each file.
GNU Make considers the make utility in 4.2BSD systems as a baseline and adds features from System V, other versions of make, and features unique to GNU Make. Features unique to GNU Make include:

simply expanded variables whose values are substitute verbatim when they are expanded;

passing command-line variable assignments automatically through the variable MAKE to recursive make invocations;

making verbatim variable definitions with define;

manipulating text by calling functions to compute files to be operated on or commands to use;

specifying a search path for included makefiles;

specifying extra makefiles to read with an environment variable;

keeping track of the current make level using the MAKELEVEL variable;

specifying static pattern rules;

providing a selective vpath search;

providing computed variable references; and

a larger selection of built-in implicit rules.

A source code distribution of GNU Make is available and can be compiled and installed via the usual GNU utilities on a wide variety of platforms. It is documented in a 160+ page user's and reference manual in Texinfo format.
[http://www.gnu.org/software/make/make.html]
[http://www.gnu.ai.mit.edu/order/ftp.html]
Godess: The Generic Ordinary Differential Equation Solver System is an initial value solver for ODEs and DAEs written in C++. It is a project whose aim is to construct better time-stepping solvers for dynamical systems and contains the necessary structures to facilitate the implementation of new numerical methods for these classes of problems as well as for developing special purpose solvers and testing methods. The solver is a collection of different classes for, e.g. norms, time stepping, step-size control, etc. which can be improved and added to independently.
The goals of the Godess project include:

the uniform implementation of different methods,

support for method development,

method testing and verification under ceteris paribus conditions,

better control of how algorithmic features affect method performance,

common functionality in all routines,

easy to switch solvers,

ease of development of special purpose solvers within the system, and

the provision of a general interface for the entire system instead of separate ones for various methods.

The current (6/97) beta release of the Godess package can be obtained via the given Web site. Some documentation is available, although it is still a bit sketchy.
[http://w1.461.telia.com/~u46108092/Godess/]
Gödel: Gödel is a declarative, general-purpose programming language in the family of logic programming languages. It is a strongly typed language, the type system being based on many-sorted logic with parametric polymorphism. It has a module system. Gödel supports infinite precision integers, infinite precision rationals, and also floating-point numbers. It can solve constraints over finite domains of integers and also linear rational constraints. It supports processing of finite sets. It also has a flexible computation rule and a pruning operator which generalises the commit of the concurrent logic programming languages. Considerable emphasis is placed on Gödel's meta- logical facilities which provide significant support for meta-programs that do analysis, transformation, compilation, verification, debugging, etc.
The source code distribution of Gödel requires SICStus Prolog version 2.1 or later for compilation. Precompiled binaries are available for Linux Intel and Sun SPARC platforms. Documentation is available in the form of a user's manual and other assorted documents in PostScript format. See Hill and Lloyd (1994).
[http://www.cs.bris.ac.uk/~bowers/goedel.html]
Golem: An inductive logic programming (ILP) system designed to learn by creating RLGGS. Golem uses extensional background knowledge to avoid the problem of non-finite RLGGS. A source code distribution of Golem is available. It is written in ANSI C and can be compiled and installed on generic UNIX platforms. See Muggleton and Feng (1992).
[http://www-users.cs.york.ac.uk/~stephen/golem.html]
Goliath: A Fortran 77 package for the exact analysis of rectangular rank-deficient sparse rational linear systems. This is TOMS algorithm 701 and is documented in Alfeld and Eyre (1991) and Alfeld and Eyre (1991).
[http://www.acm.org/calgo/contents/]
[http://www.acm.org/toms/V17.html]
[http://www.netlib.org/toms/index.html]
GOM: GOM is nOt yet another Mixer is a generic audio mixer program whose facilities include sound driver (compiler time) and sound card (runtime time) independence, arbitrary mixer selection, loading and saving of mixer settings, volume fading, verbosity-level driven output, and more. It has a complete command line interface and two built-in interactive interfaces (called gomiis): a terminal gomii which uses ncurses and an X11 gomii which uses the Xview toolkit. GOM supports the OSS software in the Linux kernel.
[http://www.fh-worms.de/~suerken/code/c/gom/www/gom.en.html]
GOOD: An object-oriented C++/Tcl/Tk framework for interactive 3D applications running under the X Window with special support for SGI GL and PHIGS. It features a Tcl shading/raytracing/radiosity kernel, a Tk interaction application builder, and C++ class library. An extension is available that implements additional objects for scientific visualization, and a set of Tcl objects for generating interactive 3D graphics is included. This will run on many UNIX systems, and a Linux port is available. More information can be found at the GOOD Web site.
[ftp://metallica.prakinf.tu-ilmenau.de/GOOD.html]
[ftp://wuarchive.wustl.edu/pub/wuarchive/graphics/ graphics/mirrors/metallica.prakinf.tu-ilmenau.de/]
[ftp://ftp.sunet.se/pub/multimedia/VR/]
GOODS: The Generic Object Oriented Database System is an object-oriented fully distributed database management system that uses an active client model. The multithreaded high-performance database server is language and application independent, and the client application interface is built using metaobject protocol methods and provides transparent persistence for normal programming languages. An aspect oriented programming approach used for implementing object access and synchronization policies make it possible to define various database access strategies that fit the requirements for concrete applications while separating them from the application code itself. A source code distribution is available. It is documented in a user's manual and an API reference.
[http://www.ispras.ru/~knizhnik/goods/]
Goose: The GNU Object-Oriented Statistics Environment is a C++ statistical library for calculating common statistical quantities and manipulating data sets. This was originally developed to provide statistical functionality for the Guppi program in the GNOME environment. A future (5/99) goal of the project is to include a complete set of Guile bindings. The features of Goose include:

numerical functions useful for statistical computation including combinatorial functions, CDF and inverse CDF functions for many common distributions, and several useful special functions;

a fast Mersenne twister-based random number generator;

a RealSet optimized container class for statistical data with caching of a sorted version of the data, optimized data transformations, efficient calculation of descriptive statistics, and descriptive statistics involving two variables or data sets;

an implementation of simple linear regression;

optimized and optionally multi-threaded resampling routines for bootstrapping;

kernel density estimation using a choice of several kernels; and

an ASCII data import system that can analyze and make intelligent guesses about the format and layout of text data files.

[http://www.gnu.org/software/goose/goose.html]
gOpenMol: A graphical interface to the OpenMol package which can also be used for the analysis and display of molecular dynamics trajectories and the display of molecular orbitals, electron densities, and electrostatic potentials from external programs. The gOpenMol GUI can import, display, and analyze several different input coordinate file formats and binary trajectory file formats, and can be used for a wide range of analysis and display tasks like the display of isocontour surfaces. The coordinate input formats supported include Amber, CHARMm/CHARMM, Gaussian formatted checkpoint files, HyperChem, Insight, Mol2, Mumod, OpenMol, PDB, Xmol, and YASP. The supported binary trajectory formats are Amber, Cerius2, CHARMm/CHARMM, Discover, Gromos, HyperChem, MUMOD, XPLOR, and YASP.
Several utility tools which work with gOpenMol are available including:

gcube2plt, which converts Gaussian cube output into a form readable by gOpenMol;

contman, a program to manipulate contours;

sybyl2amber, which converts SYBYL ASCII trajectory files to AMBER binary files;

trajmerge, which merges two CHARMM trajectories into one;

charmmtrj, which converts a CHARMM trajectory to and from formatted form;

xmol2bamber, which transforms XMOL formatted trajectories into AMBER binary trajectories;

probesurf, which generates a grid mesh; and

vss, which calculates the electrostatic potential created by the electronic distribution and the nuclei of a molecule in the surrounding space.

Binary distributions of gOpenMol are available for several platforms including Linux Intel. The source code is available via special request. The documentation is available in HTML format.
[http://laaksonen.csc.fi/gopenmol/gopenmol.html]
Gopher: The Gopher Internet protocol is a client/server model designed for distributed document search and retrieval. Documents reside on autonomous servers and users run client software to connect to these servers, search for documents, find them, and retrieve them. The client software presents the available servers and their contents as a hierarchy of items and directories similar to a file system. This allows the user to see the entire networked information system in the familiar guise of a file system.
[http://www.faqs.org/rfcs/rfc1436.html]
[http://www.faqs.org/rfcs/rfc2151.html]
GopherVR: An interface to Gopher that maps a 3D virtual world interface onto the existing Gopher servers. GopherVR makes it possible to display clustering of documents and thus visualize complex relationships within collections.
[ftp://boombox.micro.umn.edu/pub/gopher/Unix/GopherVR/]
Gorby: A small, powerful scripting language for Linux which is stack-based but also allows for direct interface to Linux system calls. It is infinitely extensible in that its syntax can be added on to infinitely, which allows for the extension of the basic language set to include any and all system calls. Gorby can also be easily extended to support any function supplied by the operating system by using the register, string manipulation, and syscall words. Gorby was called Slang at one time but the name was changed when it was found to conflict with another langage.
Gorby is available in versions for Linux Intel and ELKS platforms. It is documented in a reference guide and a tutorial.
[http://www.knotwork.com/(nobg)/info/comp/freeware/linux/gorby/]
[http://198.164.159.190/~gsh/gorby.html]
gpc: A library for performing polygon set operations such as clipping for use with C applications. The features include:

difference, intersection, exclusive-or and union clip operations;

support for polygons comprised of multiple disjoint contours;

specifying contour vertices in any order;

support for convex, concave or self-intersecting contours;

support for nested contours (i.e. polygons with holes);

output in the form of either polygon contours or tristrips;

differentiation of hole and external contours in the output; and

correct handling of coincident edges and degenerate regions.

A source code distribution is available which includes a user's manual. A GUI for this called gpctool is also available. See Vatti (1992).
[http://www.cs.man.ac.uk/aig/staff/alan/software/]
GPC+: The Genetic Programming package is a C++ class library which can be used to apply genetic programming techniques to a large variety of problems. The library defines a class hierarchy and an integral component is the ability to produced automatically defined functions.
The GPC++ system features include:

automatically defined functions (ADFs);

tournament and fitness selection;

demetic grouping;

an optional steady-state genetic programming kernel in which a complete new population is not built every generation but bad performing GPs are replaced by newly evolved ones;

subtree crossover;

swap and shrink mutation;

the capability of changing all parameters without recompilation;

the capacity for multiple populations;

the loading and saving of populations and genetic programs;

a standard random number generator for portability;

explanations of how to write the modules for evolving code and several examples;

a parameter study showing the influence of every important parameter; and

internal parameter checks that can be turned off by a compiler switch.

The GPC++ system is available as C++ source code. It does not make use of templates or exceptions and has been compiled with gcc 2.7.0 and the SunSoft C++ compiler. The documentation includes a user's manual as well as a short introduction to genetic programming, both in PostScript format. Several examples are included in the package.
[http://www.emk.e-technik.th-darmstadt.de/~thomasw/gp.html]
GPERF: A GNU program that generates perfect hash functions for sets of words. A perfect hash function is a hash function and data structure which allow the recognition of a key word in a set of words using exactly one probe into the data structure. It can generate the reserved keyword recognizer for lexical analyzers in several compilers including GCC. This program is also distributed with the libg++ library.
A source code distribution of GPERF is available. It is written in C and can be compiled and installed on a variety of platforms using the supplied makefile. It is documented in a user's manual in Texinfo format as well as in a man page.
[http://www.gnu.ai.mit.edu/order/ftp.html]
gPhoto: GNU Photo is a graphical application for retrieving, organizing and publishing images from a range of supported digital cameras or existing images on a local hard drive. The features include:

an HTML engine for the creation of gallery themes (i.e. templates with special tags);

a directory browser mode; and

a command-line interface useful for setting up webcams, time-lapse movies and other applications from within scripted languages.

A source code distribution is available which requires GTK+ for the GUI.
[http://www.gphoto.org/]
GPIB: See Linux-GPIB.
GPK: The Genetic Programming Kernel is an easy-to-use C++ class library for performing genetic programming tasks. The algorithm is based on simple genetic algorithms (GAs) over context-free languages. It can handle any grammar available in a file in its Backus-Naur-Form, with the user having to add only an appropriate interpreter.
The features of GPK include:

initialization by both standard random and uniformly distributed initialization heuristic methods;

fitness standardization;

fitness adjustment by any user-defined function;

fitness normalizing;

either proportional or linear rank selection;

a choice of stochastic sampling with replacement or stochastic universal sampling;

random or random permutation mating;

1-point, n-point, or user-defined crossover;

mutation based on user defined weighting of subtree selection based upon treesize or search space size;

an optional elitism strategy;

optional including of subtrees;

fast seach space-size calculation of every grammar;

retraceable parents; and

load- and save-operators to save a population into a file.

A source code distribution of GPK is available. It is written in C++ and can be compiled with g++. A user's manual is available in HTML or PostScript format.
[http://aif.wu-wien.ac.at/%7Egeyers/archive/gpk/vuegpk.html]
GPL: The General Public License is the license that covers all software developed by the GNU Project. The terms of the license are that anyone can modify the software and distribute a separate version of it. The constraint is that no one can prevent a recipient of such software from further distributing it for free. This right attaches to the original software and to all modified derivatives thereof. Anyone who distributes the software or a derivative of it, for whatever price, is obligated to make the source code available for no more than the cost of copying it. Frequent and seemingly interminable discussion about the GPL can be found on the usenet group gnu.misc.discuss. Further information about GNU and the GPL can be found at the official GNU Web site.
GPLOT: A graphics utility program which processes CGM metafiles produced by other packages. GPLOT can be used to select and animate several images from a CGM file. The GPLOT package consists of several components. GPLOT is a CGM processor which allows CGM files to be displayed using various X11-based GUIs including Motif, DECWindows, Xaw, and Suntools. It can also produce color PostScript output. GTEX is a companion program which displays TeX DVI files on various X11 devices. DrawCGM is a package of Fortran and C routines designed to be called from Fortran programs which can be used to create a CGM metafile as well as store and manipulate graphics data. It uses the same drivers as GPLOT but can also be used to create output formats such as Tektronix, X11, SUN and PostScript in addition to CGM. A separate package in the same directory (hdfdev.tar.Z) contains the additions needed to add a new device to produce output in HDF format.
A source code distribution is available as is a binary for Linux Intel platforms. The various components are documented (more or less) in text files scattered about in the distribution.
[http://www.psc.edu/general/software/packages/gplot/gplot.html]
GPLOTM: A CGM graphics metafile interpreter which uses Motif. GPLOTM can be used to select and animate several frames from a CGM file. This is a version of GPLOT rewritten in C++. The source code is available as are binaries for various machines including Linux Intel platforms.
[http://www.psc.edu/general/software/packages/gplotm/gplotm.html]
G++: The name used for the GNU C Compiler, i.e. GCC, when it is being used to compile C++ programs. G++ is a compiler and not merely a preprocessor. It builds object code directly from C++ program source, i.e. there is no intermediate C version of the program. It provides most of standard ANSI C++ in addition to several extensions which include: giving a new name to C++ function return values, C++ minimum and maximum operators, the safe use of goto even when destructors are needed, the capability of using a single C++ header file for both declarations and definitions, methods for ensuring that exactly one copy of each needed template instantiation is emitted, and specifying abstract types to get subtype polymorphism independent from inheritance. G++ can also take advantage of most of the GCC extensions to the ANSI C standard.
[http://www.gnu.ai.mit.edu/software/gcc/gcc.html]
GPM: Gardens Point Modula is an implementation of Modula-2 for 32-bit machines. It provides a uniform programming environment across a wide range of platforms, and is based on the ISO standard for the Modula-2 language andits libraries. The features include:

a fully type-checked, safe programming environment;

safe separate compilation based on pre-declared interfaces, data hiding and data abstraction;

comprehensive compile-time diagnostics with explicit error messsages as well as optional warnings for obsolete syntax or dubious program constructs;

rigorous version checking of symbol and object files during compilation and load-module building;

seamless integration with standard profiling and debugging tools;

safe interfaces to common libraries such as Curses; and

standard extensive runtime checking with both command-line and embedded pragma control of checks available.

Source code and binary distributions are available for several platforms including Linux Intel. Each distribution includes a native code back-end. The distribution consists of the compiler, a load-builder, libraries and various utilities. Documentation includes language reference and library definition manuals and a user's guide and technical reference manual.
[http://www.plasrc.qut.edu.au/GPM/]
gprof: A program which produces an execution profile of C, Pascal for Fortran 77 programs. See the binutils package for availability.
gps: This is a Pascal compiler from the GNU folks. It is a 32 bit highly optimizing compiler with no limits, runs on all operating systems supported by GNU C, and is compatible with other GNU languages and tools. It implements most of the ISO 7185 Standard and ISO 10206 Extended Pascal standards including complex numbers, initialized variables, structured function return values, and modules from Extended Pascal. It also includes some extensions from Borland Pascal as well as some GNU extensions. The drawbacks are that gdb does not yet (1/97) understand Pascal syntax and types, there are few standard libraries (although the C standard libraries can be used instead), and longer compilation times than with Borland Pascal.
[http://didaktik.physik.uni-essen.de:80/~gnu-pascal/]
gps3d: A set of utilities for manipulating a GPS unit from a Linux or Windoze box. The utilities are:

gpsd, a daemon that monitors a port for messages sent by a GPS device and broadcasts it on a TCP port;

viz, an OpenGL utility that connects to the daemon and displays a 3-D, texture-mapped Earth with GPS related information it reads from the daemon, e.g. current fix, current track, waypoints, and satellite trajectories;

gps, a simple example client for the gpsd daemon that connects to the daemon, reads and parses the HMEA sentences, and prints them in human readable form.

[http://www.mgix.com/gps3d/]
GPsys: A genetic programming system developed in Java. The features of GPsys include:

a steady state engine;

ADP support;

strong typing which supports generic functions and terminals, has many built-in primitives, includes indexed memory, and has exception support;

a save/load feature which can save or load the current generation to or from a file, store it in compressed format, and uses serializable objects for efficiency;

full documentation including commented source code and javadoc generated class documentation;

total parameterization;

full object-orientation and extensibility;

high performance;

memory efficiency; and a set of example problems.

A source code distribution of GPsys is available. It is written in Java and can be compiled and used on UNIX systems with the JDK distribution. Documentation is included in the distribution.
[http://www.cs.ucl.ac.uk/staff/A.Qureshi/gpsys.html]
GQAPD: A set of Fortran 77 subroutines for finding approximate solutions to dense quadratic assignment problems having at least one symmetric flow or distance matrix. A greedy, randomized, adaptive search procedure (GRASP) is used to find solutions. This is TOMS algorithm 754 and is documented in Resende et al. (1996).
[http://www.acm.org/calgo/contents/]
[http://www.netlib.org/toms/index.html]
GQmpeg: A front-end for mpg123 with playlist support that can be used to play MPEG files. The source code requires Imlib for compilation.
[http://www.geocities.com/SiliconValley/Haven/5235/]
GQview: A image viewer for Linux whose features include single click file viewing, external editor support, thumbnail previewing, and zoom. It supports most file types if the libraries are already resident on the system. The source code distribution requires GTK and Imlib for compilation.
[http://www.geocities.com/SiliconValley/Haven/5235/view-over.html]
Grace: A 2-D WYSIWYG plotting program descended from ACEgr. The original developer of ACEgr ceased development and the current Grace development team picked up at V4. They decided to rename the project after ACEgr 4.1.2 to Grace 5.0.0. This has all the features that ACEgr had with more planned. An online manual is in the nascent stages of development (3/99).
[http://plasma-gate.weizmann.ac.il/Grace/]
GRadio: A GTK-based application for interfacing with any Video4Linux-supported radio cards in kernels 2.1.106 or greater.
[http://fallout.cs.unr.edu/projects/gradio/]
GrADS: The Grid Analysis and Display System is an interactive tool for the analysis and display of Earth science data. It provides an integrated environment for access, manipulation, and display of gridded data. GrADS implements a 4-D data model, where the dimensions are usually latitude, longitude, level and time, and each data set is located within this 4-D space using a separate data description file. Both gridded and station data may be described, and the gridded data may be unevenly spaced. Intercomparison of separate data sets is greatly facilitated by the 4-D data space model, which allows disparate data to be graphically overlaid with correct spatial and temporal matching.
Features of GrADS include:

direct support for both Gaussian and variable resolution of ocean model grids;

a command language with Fortran-like expressions that can be run interactively or in batch mode,

a rich set of built-in functions and the capability of adding new functions as external routines written in any programming language, and

a large variety of graphical output techniques.

Graphical output forms include line, bar, and scatter plots as well as contour, shaded contour, streamline, wind vector, grid box, shaded grid box, and station model plots. These plots can be viewed interactively or output to either monochrome or color PostScript files for printing. Almost all graph attributes can be modified by the user or the reasonable and intuitive default values may be used. The scripting or command language can be used to develop user interfaces where widgets are displayed and actions are performed based on pointing and clicking.
It is available in binary form for all commonly available UNIX workstations (including Linux) and for DOS platforms. A more recent version of the Linux port can be found at the LLNL GrADS site than at the given home site. The documentation is available as either a 148-page PostScript file or online as a hypertext document. Reference cards for both GrADS commands and the scripting language are also available as is a mailing list for GrADS users.
[http://grads.iges.org/grads/head.html]
GRAFIC: A library of interactive graphics routines that provide the capability of easily creating multi-line, grid, vector, contour or specialized plots in 2- and 3-D. This is intended to provide graphics from within application programs and as such is not stand-alone. Device drivers for X11 and Apollo's GRP are supplied, and hardcopy output can be created in PostScript format. A source code distribution is available. It is written in Fortran and C and is documented in an ASCII text file.
[ftp://ftp.comlab.ox.ac.uk/pub/Packages/Visual/]
Grafix: A C++ library originally designed to aid scientists in the visualization of the results of computations but more widely applicable for any application which wants to use the X Window System for drawing pictures, functions, or other graphical objects in a convenient interactive manner. Grafix is a layer between an application and the X Window System which comprises a set of basic classes as building blocks, with the simplest way to use it being defining instances of these classes.
The capabilities available within the Grafix classes include:

windows with automatic restoring for complex drawings,

several types of predefined button classes for different purposes,

pop-up windows and pulldown menus for selecting discrete values,

binding pop-up help windows to any window,

scrollbars for selecting continuous values,

windows with real-valued coordinate systems,

an edit window for entering strings,

simple file selection boxes,

a predefined palette manager for color definitions,

an advanced class with a complete manager for handling the display of 2-D functions as a lattice or body in arbitrary perspective with shadowing and zooming capabilities,

an animator class to store time sequences of 2-D arrays in a file and play them like a video,

an integrator class for linking any numerical 2-D or 3-D integration program with the graphical interface and playback features, scrolled windows, and

classes for displaying tree and graph structures including a graphical class browser.

Several example programs are included to demonstrate the basic functions available in the package as well as to demonstrate a complete numerical integration procedure.
A source code distribution of Grafix is available. It is written in C++ and can be compiled using g++. The documentation is a bit sketchy and basically comprises an introductory ASCII file and the examples mentioned.
[http://sunsite.unc.edu/pub/Linux/libs/X/c++libs/]
Grail: An extensible Internet browser that supports the protocols and file formats commonly found on the WWW, e.g. HTTP, FTP, HTML. It is easily extended to support other protocols or file formats. It is written (and extensible) in the Python language and uses the Tcl/Tk toolkit, and should compile and run on any UNIX system to which these have been ported. The source code is available as well as binaries for several platforms, including Linux.
[http://monty.cnri.reston.va.us/grail-0.3/]
Grail (FSM): A symbolic computation environment for finite state machines (FSM), regular expressions, and finite languages. Grail can be used to input machines or expressions, convert them from one form to the other, minimize, make deterministic, complement, and perform many other operations. The package consists of sets of UNIX-type filters for transforming and manipulating FSMs, regular expressions and finite languages. The FSM machine filters include:

fmcat, concatenates two FSMs;

fmcment, complements a FSM;

fmcomp, completes a FSM;

fmcross, compute the cross-product of two FSMs;

fmdeterm, make a FSM deterministic;

fmenum, enumerate the language of a FSM;

fmexec, test a word for membership in the language of a FSM;

fmmin, minimize a FSM via Hopcroft's algorithm;

fmreach, compute the reachable submachine of a FSM;

fmrevers, reverse a FSM;

fmtofl, convert a FSM to a finite language; and

isuniv, test for the universality of a FSM.

The regular expression filters include:

recat, concatenate two regular expressions;

restar, compute the Kleene star of a regular expression;

retofm, convert a regular expression into a FSM;

isempty, test the equivalence to an empty string; and

remin, minimally bracket a regular expression.

The finite language (FL) filters include:

flappend, append two FLs;

flfilter, intersect a FL with a FSM;

flprepen, prepend a FL with a string;

flreverse, reverse a FL;

fltofm, convert a FL to a FSM; and

fltore, convert a FL to a regular expression.

A source code distribution is available. It is written in C and can be compiled and used on most generic UNIX flavors. Documentation includes a user's guide, a programmer's guide, release notes, and various technical reports, all of which are available in PostScript format.
[http://www.csd.uwo.ca/research/grail/]
GramoFile: A program for transferring audio signals from vinyl records onto CDs. The features include:

integrated sound recording and playback;

signal peak level meter during recording;

playback of user-specified parts of sound files;

signal processing via filter applications including four supplied filters

use of multiple filters in arbitrary order with each filter fine tuned via several available parameters;

splitting large sound files into smaller ones representing individual tracks;

a text-mode user interface; and

use of WAV files for easy interchange.

A source code distribution is available.
[http://cardit.et.tudelft.nl/~card06/]
GRAPE: The GRAphics Programming Environment is a a general programming and viewing environment. It is interactive and has an object-oriented, C-based structure. The object-oriented kernel uses a library of classes and methods for different geometric objects as well as mathematical descriptions and other technical entities. Each class contains a set of methods with standard object-oriented mechanisms. The library consists of classes for triangulated geometric objects like curves, surfaces, and volumes as well as subclasses with additional information like finite element functions, refinement information, and functional descriptions.
GRAPE includes mathematical tools to compute:

parametric curves and surfaces;

level set surfaces;

minimal and H-surfaces or the evolution of surfaces restricted to spatial surfaces;

the solutions to ODEs and PDEs;

with vector fields on surfaces and in volumes;

with geometric objects in Euclidean, spherical and hyperbolic space; and

finite element functions on geometric objects.

The GRAPE viewer consists of a window for graphics output and a control panel with standard layers for lighting, surface properties, transformation operations, and managing the data hierarchy. Additional layers can be designed by the user. Additional capabilities include:

clipping algorithms;

extraction of level lines and surfaces;

interactive refinement and coarsening;

reflection tools;

calculation of particle traces;

displaying functions on surfaces or volumes; and

grid editing.

Most of the GRAPE distribution is available via FTP, although an essential header file can only be obtained by filling out a license application and returning it via snailmail to the appropriate address. An extensive user's guide is available both online and in the usual printable formats.
[http://www.iam.uni-bonn.de/sfb256/grape/main.html]
GraphApp: A toolkit for platform-independent GUI programming in C. Version (2.2) of GraphApp (10/97) has versions for MS Windows, mac, Motif, and Xaw. A Python binding is also available for the X Window versions.
A source code distribution of GraphApp is available. It includes instructions on how to build each version as well as numerous examples. It is documented in a reference manual and a tutorial slide show.
[http://www.cs.su.oz.au/~loki/graphapp/]
graphics: Quite a few packages are available for performing various tasks relating to graphics. These packages include those for creating and manipulating graphics and images, for building 2- and 3-D models for ray tracing, for ray tracing, for volume visualization, and for converting between various graphics formats. They range from standalone programs to collections of tools to libraries.
Animation packages include:

AERO, a tool for the simulation and visualization of rigid-body systems;

Agat, a tool for the fast and easy production of algorithm animation;

AL, a programming language for modeling and animation;

anim, a system for algorithm animation;

blender, a package of 3-D design and animation software;

Crystal Space, a 3-D graphics and animation engine;

DAVID, an interactive visualization environment;

EcoSim, an ecological modeling package with animation capabilities;

Egon Animator, a animation development tool written in Scheme;

FElt, a finite element analysis tool with animation capabilities;

Geomview, an interactive program for viewing and manipulating geometric objects;

gifmerge, a program for creating animations out of a series of GIF images;

Gifsicle, another program for creating animations out of a series of GIF images;

GMV, a scientific visualization tool;

Histo-Scope Widget Set, a collection of widgets for graphing and plotting;

ImageMagick, an image manipulation package with animation capabilities;

LinkWinds, a visual data exploration system;

MindsEye, a project to create a modeling and animation package;

MMTK, a molecular modeling tool with animation capabilities;

Pixcon/Anitroll, a 3-D renderer and animation system;

PlotPlus, a general purpose graphics package;

POLKA, a general purpose animation system;

POSES++, a tool for modeling and simulating arbitrary discrete and continuous systems;

Sceda, a 3-D modeling package;

StageTools, a set of modules that work with Geomview for creating animations;

StarSplatter, a package for creating images and animations from astrophysical simulations;

Vigie, a system for data visualization;

Vis5D, a system for data visualization;

VolVis, a system for data visualization;

VORT, a rendering toolkit;

xa, an animation package with a panel interface; and

Xanim, a program for viewing animations in many formats.

2-D plotting packages or package which contain such functionality include:

ACEgr, an interactive 2-D plotting package with numerous capabilities;

AGL, a library of graphics routines with C and Fortran interfaces;

Aipsview, a tool for visual astronomical data analysis with which images can be viewed and processed and interactive vector plots can be created;

DATAPLOT, a scientific and mathematical computational environment with 2-D plotting capabilities;

DAVID, an interactive visualization environment with, among many other things, 2-D plotting functionality;

DISLIN, a high-level library of functions for graphical data display;

Dore, a graphics library for producing high-quality images and image sequences;

EDGR, an interactive program for creating, editing, printing and storing graphical data;

EPIC, a sytem for the management, display and analysis of oceanographic data;

ESO-MIDAS, an astronomical data analysis system with 2-D plotting functionality;

gd, a library for quickly drawing images and writing them out as GIF files;

Geomview, an interactive program for viewing and manipulating geometric objects;

GLE, a scientific graphics library;

GMT, a collection of over 50 UNIX tools for manipulating and graphing 2-D data;

GMV, a scientific visualization tool for simulation data from structured and unstructured meshes;

Gnuplot, a command-line driven interactive plotting utility;

GPLOT, a utility program for plotting CGM metafiles produced by other programs;

GrADS, an interactive tool for the display and analysis of Earth science data;

GRAFIC, a library of interactive graphics routines;

Gri, a language for drawing scientific graphs;

GYVE, a planned vector-based drawing program;

Hvplot, a scientific plotting package for 2-D plots;

Ipe, a drawing editor for creating figures for LaTeX documents;

ivtools, a framework for building drawing editors which contains example drawing editors;

jsplot, an interactive drawing and charting tool;

LASSPTools, a collection of utilities for analyzing and graphing data;

LinkWinds, a visual data exploration system that can output geophysical data in several formats;

MAPGEN/PLOTGEN, a collection of programs to create maps of data with geographic coordinates;

Mesh-TV, an interactive tool for visualizing and analyzing data on regular meshes;

PGPerl, a Perl interface to PGPLOT;

PGPLOT, a library of Fortran-callable graphing routines;

PHYSICA, a high-level interactive programming environment with graphics capabilities;

Plotmtv, an interactive 2-D plotting program;

PlotPlus, an interactive, command-driven 2-D scientific graphics package;

plotutils, a collection of programs for plotting 2-D scientific data;

PLplot, a library of C functions for creating 2-D scientific graphs;

PONGO, an application for interactively plotting data which uses PGPLOT;

PRL, a family of compatible libraries including one for creating 2-D graphs;

PSPLOT, a library of Fortran-callable routines for generating 2-D PostScript graphs;

ptcl, a package that registers PGPLOT functions as Tcl commands;

PPGPLOT, a Python interface to PGPLOT;

Robot, a plotting and data analysis program;

STAP, an interactive graphics and data analysis program built on top of PGPLOT;

tgif, a 2-D drawing utility that supports the hierarchical construction of drawings;

TIPSY, a tool for displaying and analyzing the results of N-body simulations in astronomy;

VCS, a package for the manipulation and display of scientific data;

Vigie, a system for data visualization;

Vis5D, a package for visualizing output from numerical weather models and similar sources;

VOGLE, a library of C routines for creating 2-D graphs;

VOPL, a plotting library built on top of VOGLE;

WIP, an interactive scientific graphics package built on top of PGPLOT;

xdang, a data visualization and viewing package;

XFarbe, a contouring program for isolines;

xfig, an interactive tool for drawing and manipulating objects;

XGraph, an interactive program for creating line and restricted surface plots;

Xgraphic, an interactive package for drawing graphs;

Xlisp-Stat, an extensible statistical computing environment with graph creation capabilities;

XmdvTool, a package for visually exploring multivariate data;

XploRe, an interactive statistical computing environment with graph creation capabilities; and

YPLOT, a tool for creating 2-D scientific plots.

Packages that can create 3-D graphics include:

AL, a language for modeling and animation;

Alpha Shapes, which reconstructs surface and volume shapes for point clouds;

blender, 3-D design and animation software;

CINEMA, for the visualization and manipulation of protein and DNA sequences;

Crystal Space, a 3-D graphics engine based on the portal technology;

DATAPLOT, a system for data analysis and graphics;

DEM Tools, for working with Digital Elevation Model (DEM) data;

DISLIN, a graphics library;

Dore, a graphics library for generating full-color, high-resolution 3-D images;

Geomview, an interactive program for viewing and manipulating geometric objects;

GGI, a generic package for accessing graphics capabilities;

GL-Space, a 3-D modeler;

GMV, a visualization tool for data from structured or unstructured meshes;

GOOD, an object-oriented framework for building interactive 3-D applications;

jaw3d, a 3-D model viewer;

Lab-3D, a library for testing and comparing graphics algorithms;

LinkWinds, a visual data exploration system for the geosciences;

MAGE, a viewer for 3-D scientific images;

MAM/VRS, a toolkit for animated, interactive 3-D graphics;

Mesa, a graphics library similar to OpenGL;

MindsEye, a modeling and animation package;

MolScript, for creating schematic and detailed molecular graphics images;

MR Toolkit, tools for the production of virtual reality systems and other 3-D interfaces;

Panorama, for creating, rendering and processing 3-D images;

Plush, a 3-D graphics library;

SART, a library for highly complex 3-D modeling;

Sceda, a 3-D modeler and scene animator;

3Dom, a 3-D solid object modeler designed to create input files for rendering programs;

TINA, a library for vision algorithm development and evaluation;

Vis5D, a system for visualizing numerical weather model output;

xdang, a data visualization package;

XDataSlice, a color imaging and data analysis tool;

Zone, a library of 3-D PostScript operators;
Graphlet: A toolkit for implementing graph editors and graph drawing algorithms, Graphlet is a graph editor, a toolkit for graph editors, a programming language for graphs, and a toolkit for graph drawing algorithms. A graph is a set of nodes and edges where the nodes are objects and the edges the connections between those objects. These can be used to describe diagrams, networks, hierarchies, data flow diagrams, data structures, and more.
The Graphlet graph editor comes with a set of 12 pre-installed layout algorithms with more currently (3/97) under development. The graph editor toolkit is a powerful toolkit for graph editors and is implemented in C++, LEDA, Tcl/Tk, and Graphscript. Graphscript is a high level scripting language based on Tcl/TK with which users can customize and extend graph editors. Graph drawing algorithms help turn abstract graph structures into nicely arranged sets of nodes and edges.
The Graphlet package is available either as source code or in binary form for Sun Solaris and SunOS, Linux and MS-DOS/Windows platforms. The documentation includes a Graphscript manual, a C++ interface manual, a GML file format manual, and a standards manual, all of which are available in PostScript format.
[http://www.fmi.uni-passau.de/Graphlet/]
GraphMaker: A Java application for demonstrating various graph theories. The features include:

comparing and contrasting breadth first seach with depth first search;

comparing and constrasting Kruskal's and Prim's methods for find the minimal spanning tree; and

finding the shortest path between two nodes in a graph.

A source code distribution is available.
[http://home.earthlink.net/~nfiedler/graph/]
GraphPanel: A Java application that supports the interactive editing of simple graphs with labels. A source code distribution is available.
[http://binger.centre.edu/GraphPanel/]
Graphplan: A planner for STRIPS-like domains based on ideas used in graph algorithms. Graphplan explicitly constructs and annotates a compact structure called a Planning Graph which is then explored in a search. A source code distribution is available. Extended versions of this are IPP and SGP. See Blum and Furst (1995).
[http://www.cs.cmu.edu/~avrim/graphplan.html]
Graph3D: A library of C++ classes which implement a real-time 3-D rendering library with Gouraud shading, support for different color depths and palettes, and color dithering. Scenes can be built in Graph3D by either: using the built-in primitives by creating objects, calling the appropriate methods, and adding the objects to a scene; loading polygon-based objects (in a simple text format) in from files; and loading an entire scene in the MSDL format.
A source code distribution of Graph3D is available. It is written in C++ and can be compiled and used on several types of platforms, including most UNIX flavors. It can be compiled to use either floating point or fixed point arithmetic. The documentation is a bit sketchy.
[ftp://ftp.math.ohio-state.edu/pub/users/gregt/]
graphviz: A set of graph drawing tools which address the problem of visualizing structural information by constructing geometric representations of abstract graphs and networks. The goals of this package are to find efficient algorithms for making readable drawings of graphs up to several hundreds of nodes which quality approaching that of manual layouts as well as to create systems that provide graph drawing as a convenient service (i.e. defining sound interfaces and supporting features).
The graphviz package includes:

dot, which makes hierarchical layouts of directed graphs;

neato, which makes ``spring'' model layouts of undirected graphs;

dotty, a customizable interface written in LEFTY;

tcldot, a customizable graphical interface written in Tcl 7.6; and

libgraph, a base library for graph tools.

These tools can run stand-alone and can also be extended to create interfaces to external databases and systems via writing dotty or tcldot scripts to customize the graph editor's behavior and to program it to communicate with external files or programs.
A source code distribution of graphviz is available as Open Source. Binaries are also available for several platforms including Linux Intel. User's guides for some of the programs are available in PostScript format. The program suite is also documented in Krishnamurthy (1995).
[http://www.research.att.com/sw/tools/graphviz/]
Grand Unified Toolkit: A comprehensive C++ API for developing games and other forms of interactive media. It performs the task of abstracting the hardware and OS so the same source code can run on different systems. The GUT package contains several features for working with the 3-D OpenGL API including:

rendering to a window or full screen at any available video resolution, and switching resolutions on the fly;

listing all the rendering surfaces (i.e. visuals or pixel formats) supported by the video hardware and choosing the one best suited to a given application;

listing the available OpenGL drivers and switching between them on the fly;

transparent support for the 3Dfx family of standalone 3-D card, including automatic detection of card type;

loading PNG and uncompressed TGA images; and

fast and flexible text rendering with texture fonts.

Additional GUT features include:

full keyboard, mouse and joystick support;

working with the OpenAL 3-D sound library;

reading the system timer;

math including basic bector, matrix and quaternion objects and operators;

file services including file and shared library objects, simple directory manipulation, and routines for swapping data endianness;

a debugging heap to track down common memory errors; and

complete API documentation.

[http://www.379.com/gut/]
GRASP: A commercial-grade GUI front-end for GNAT, GCC, and JDK with which users can compile, edit, and run programs. It was originally developed for Ada software development but has been extended to other languages. It provides complete support for generating, editing, and printing Control Structure Diagrams (CSDs) from Ada 95, C, Java, and VHDL source code (where a CSD is a diagram intended to increase the comprehension efficiency of the source code).
The features of GRASP include:

extensive capabilities as a GUI interface to the GNU compiler family including the ability to run semantic checks via the compiler and performing compiles without leaving the CSD window;

a full text editor in the CSD window with capabilities including cut, paste, copy, and search and replace;

multiple file viewing and editing within one copy of GRASP;

multiple CSD views;

multiple language support;

pre-defined language templates which can be modified;

CSD generation either dynamically or on demand;

preservation of spacing and comments;

syntax error detection;

creation and printing of PostScript images of CSDs;

color syntax highlighting of keywords, strings, comments, numbers, operators, etc.;

the creation of a project workspace for project management; and

the creatino of a Complexity Profile Graph (CPG) which is the visualization of a fine-grained, statement level complexity metric.

Binary versions of GRASP are available for Sun Solaris and SunOS, Linux Intel ELF, SGI IRIX, and and DOS/Windows platforms. The UNIX binaries are available in versions that are both dynamically and statically linked with the Motif libraries. Documentation is both included in the distribution and available online.
[http://www.eng.auburn.edu/department/cse/research/grasp/]
GRASS: The Geographic Resources Analysis Support System is a raster- and vector-based Geographic Information System (GIS), an image processing sytem, and a graphics production system. It can serve as an educational tool due to its ease of use via a simple graphical user interface, and it can also be use as a research tool due to the capability of extending and customizing it via programs written in the native GRASS language that call the available libraries. GRASS allows the quick and easy analysis, storage, updating, modeling, and displaying of landscape data.
GRASS contains over 40 programs to render images on both interactive and hardcopy devices, over 60 raster manipulation programs, over 30 vector manipulation programs, around 30 multi-spectral image processing and manipulation programs, 16 data management programs, and more. There is also an extensive library o