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 of user contributed programs.
The source code, written in ANSI C, is available as are binaries for CDC, InterGraph, Linux, PC, SGI, and SUN4 platforms at the home site. Ports to other machines are also available at scattered locations. Minimum requirements for this large package are 8 Mb of RAM and 100+ Mb of free disk space. Documentation is extensive and includes several user's and reference manuals in both hypertext and PostScript format as well as several tutorials scattered about on the Web.
[http://www.baylor.edu/~grass/]
GRAV: This is a graphic viewer that runs at the linux console (not X11). It has a user interface to select the images you want. GRAV supports many popular graphics formats including GIF, PCX, LBM, IFF, PPM, PBM, BMP, JPEG and PNG. It requires at least NCurses 1.8 and SVGALIB 0.98.
[http://sunsite.unc.edu/pub/Linux/apps/graphics/viewers/svga/]
[ftp://ftp.cc.gatech.edu/pub/linux/apps/graphics/viewers/]
GrayIP: The Grayscale Image Processing C++ class library is designed for processing grayscale images. The features include:

automatic recognition of input file formats;

reading and writing PGM, XWD and Group G TIFF formats;

elementary pixel operations;

equalizing and image histogram;

computing image extrema, norms and scalar products;

operations on square or rectangular image sections;

squeezing, stretching and coercing images;

iterators to perform image processing sweeps;

lazy images;

optimized image filtration techniques; and

a fractal clouds generator.

[http://www.remotesensing.org/download/g.php3]
Gre: A descendant of the Gri graphics creation language. Gre includes a working parser with Perl-like capabilities and emulation of all relevant Gri commands.
[http://www.phys.ocean.dal.ca/~kelley/gre/gre1.html]
gretl: The GNU Regression, Econometric and Time-series Library is an econometrics package consisting of a shared library, a command-line client program, and a graphical client built using GTK. The features in this currently (2/00) alpha package include:

a variety of least-squares based estimators including two-stage least squares;

an augmented Dickey-Fuller test;

Chow test for structural stability;

vector autoregression;

reading files in several formats;

model output in LaTeX format;

an integrated scripting language; and

a command loop structure for Monte Carlo simulations.

This is available under the GPL.
[http://www.ecn.wfu.edu/gretl/]
GRG: The GNU Report Generator is a program that reads record and file information from a dBase3+ file, a delimited ASCII text file, or an SQL query to an RDBMS and produces a report listing. It is ideal for generating large bodies of text where various parts of the text are substituted with information from a database. GRG was loosely designed to produce TeX/LaTeX formatted output although output in ASCII, Troff, PostScript, HTML or any other kind of ASCII-based output can just as easily be produced.
The GRG formatting process is controlled by a definition file which holds the report, page, and record layouts as well as what fields to display and where to display them. The file also supports other useful functions such as sorting, filtering, and data manipulation. The features that can be used in the definition file include:

multiple input databases;

support for ASCII text, dBase3+, CA-Ingre and GNU SQL Server databases;

sorting of database records;

automatic banner placement at the start of each sorted group;

filters using regular expressions or GRG equates;

five main text bodies, i.e. header, footer, record, 1st page, and Nth page;

user-defined macros and text bodies;

user-defined equations on field contents including conditionals;

user-configurable input parsing patterns (similar to Awk);

include files and environment and system variables;

a general purpose processing language; and

optional Guile support.

A source code distribution of GRG is available under the GPL. It has been compiled on several platforms including Linux Intel. A user manual is available in several popular formats.
[http://www.dai.ed.ac.uk/daidb/grg/]
Gri: A programming language for drawing science-style graphs. It is not mouse-driven nor amenable to business-style applications, but rather can be regarded as the plotting equivalent of the LaTeX document preparation system (with a similar learning curve of an hour or so). Gri can be used either interactively or via a series of commands in an executable command file.
The capabilities of Gri include X-Y plots, contour plots, and image plots, and the user has extensive control over line widths, fonts, grayscales, and other graph components. Rudimentary data analysis functions such as regression, column manipulation, smoothing, etc. is available but it is not intended to be an integrated analysis and graphics package. Gri is also a programming language so new drawing methods can be easily added or customized versions of Gri can be created for specific applications using programming elements like statements, control structures, variables, etc. Gri also allows the use of system calls, making the use of familiar and powerful external tools possible. Online help is available by either command name or topic. Graphical output is in standard PostScript, allowing either viewing or printing via standard methods.
Gri will compile and install on most UNIX platforms (e.g. Sun, HP, IBM, Linux, etc.), PCs, and even VMS platforms. The documentation includes an online texinfo manual, a PostScript manual, a WWW hypertext manual, a cookbook with many examples, and several reference cards. There is a mail-in newsgroup to which questions or comments can be sent. There is also an Emacs Gri major mode package.
[http://www.phys.ocean.dal.ca/~kelley/gri/gri1.html]
GRIB: The GRIdded Binary format is a general purpose, bit-oriented data exchange format developed by the World Meteorological Organization (WMO). It is an efficient vehicle for transmitting large volumes of gridded data to automated centers over high speed telecommunications lines using modern protocols. GRIB can also be used as a data storage format.
[http://wesley.wwb.noaa.gov/index.html]

wgrib

A program to manipulate, inventory, and decode files in GRIB format.
[http://wesley.wwb.noaa.gov/wgrib.html]
grip: A front-end for CD rippers such as cdparanoia. A source code distribution is available which requires GTK for compilation.
[http://www.ling.ed.ac.uk/~oliphant/grip/]
Groff: GNU Troff is an extended version of the UNIX troff and nroff document formatters. (The difference is in the output formats, i.e. troff produces output for typesetting machines, e.g. PostScript, and nroff produces output for line printers.) Groff, like TeX, works using a batch paradigm, i.e. the input files are normal text with special formatting commands embedded and the output files are text typeset for printing on a variety of output devices. The capabilities of Groff include text filling, adjusting and centering, hyphenation, page control, font and character size control, vertical spacing adjustments, indenting, the use of macros to alias lengthy command sequences onto short commands, and much more. Various prepackaged macros are also available for formatting technical documents, man pages, graphics, mathematics, etc.
Various prepackaged Groff macros are available for formatting technical documents, man pages, graphics, mathematics, etc. Drivers are included for PostScript, DVI, X11, and constant width printers. It includes the entire suite of troff preprocessors or filters with the exception of grap. It supports character kerning which is not supported by any of the troff family.
The Groff package is written in C++ and can be configured and compiled via the usual GNU methods. The given URL is to a site that contains links to programs and documentation for the entire *roff family of typesetting programs. A series of AT&T technical reports provide documentation for many parts of the *roff hierarchy. These include Nroff/Troff User's Manual, A Typesetter-Independent Troff, PIC - A Graphics Language for Typesetting, CHEM - A Program for Typesetting Chemical Structure Diagrams, Computers, and Chemistry, and Tools for Printing Indexes. All are available at the given URL. See Dougherty and O'Reilly (1987), Computer Systems Research Group, UC Berkeley (1994), Christian (1987), and McGilton and McNabb (1990).
[http://www.cs.pdx.edu/~trent/gnu/groff/index.html]
Groupkit: A groupware toolkit for developing real-time conferencing applications. Applications such as drawing tools, editors and meeting tools can be shared simultaneously among several users. The goal of this software is to make developing groupware applications only slightly more difficult than single-user applications. It has been used as a research tool for prototyping groupwave systems and investigating multi-user architectures and interaction techniques, and also as a graduate level teaching tool.
A number of conference applications are included in the distribution, including a brainstorming tool, a file viewer, a fisheye, a group sketchpad, a group draw, a hyper node editor, a postit note editor, a simple sketchpad, a text chat and editor, and several simple games. Session managers, the programs used to create, locate and join conferences, can also be constructed using GroupKit.
GroupKit should compile and install on generic UNIX/X11 workstations. It is based on the Tcl/Tk toolkit as well as an extension called Tcl-DP, a Tcl front-end to standard UNIX sockets. The source code is available and should install on the indicated platforms if these tools are first installed. The documentatation consists of a 50-page users manual and several papers, all available in PostScript.
[http://www.cpsc.ucalgary.ca/projects/grouplab/groupkit/]
GROW: This project, which was an attempt to create a Java-like language, was abandoned in 1996.
GRS: The Genome Retrieval and Segment analysis tool is a graphic tool for the retrieval and visualization of genome segments from partially of completely sequenced genes. Genes are color-coded according to their presumed functional roles to facilitate visual identification, and aligned genes can be screened rapidly for potential homology by automatic retrieval and alignment of the corresponding protein sequences. The map location of any genome segment can be visually compared to the position of the same segment in other genomes or to the position of other segments within the same genome. A string analysis option allows the identification of genes which are identically arranged in any pairwise set of genomes. The program also allows the creation of a new gene table format file to enable comparisons of gene order structures in recently determined sequence data to the patterns of genes in already existing microbial and organellar databases.
Binary versions of GRS are available for several platforms including Linux ELF, Sun Solaris, DEC Alpha, and SGI IRIX. Sample datasets are also available. The documentation is thus far (9/97) a bit sketchy.
[http://evolution.bmc.uu.se/~thomas/software/grs/]
GRUB: The GRand Unified Bootloader is an attempt to create a bootloader for PC-compatible machines that is both easy to use for beginners and sufficiently flexible for advanced users to use in diverse environments. It is currently most useful for users of at least one of the various free UNIX-like operating systems although it can be used with almost every PC operating system. The primary goal of GRUB is that is be compliant with the proposed Multiboot Standard.. GRUB has both a simple menu interface for preset options from a configuration file and a highly flexible command line for performing any desired combination of boot commands. It can boot Linux, FreeBSD, NetBSD, Mach and the GNU HURD directly and proprietary OS such as DOS, Windows and OS/2 via a chain-loading function.

Additional features of GRUB include:

support for multiple executable formats, e.g. many a.out variants and ELF;

support for non-multiboot OS, e.g. FreeBSD, NetBSD, and Linux;

full support of loading multiple modules;

support for a configuration file with preset boot commands;

a menu interface listing the preset boot commands with a programmable timeout;

a flexible command-line interface accessible from the menu which can be used to edit any preset commands;

support for multiple filesystem types with the currently (5/97) supported types being BSD FFS, DOS FAT, and Linux extfs;

decompression support for files compressed with gzip;

accessing data on any installed device;

independence from geometry translation; and

detection of all installed RAM.

GRUB can completely replace the primary bootloader on a hard disk or floppy disk and can also be run after some other bootloader capable of chain-loading on the hard disk.
[http://www.uruk.org/grub/]
[http://www.gnu.org/software/grub/grub.html]
GRUUMP: The Generation and Refinement of Unstructured Mixed-element Meshes in Parallel package is a set of C++ libraries for manipulating unstructured finite element meshes as well as a set of executables built using those libraries. The GRUUMP project aims to develop automatic mesh generation software for unstructured meshes with mixed element types.
The GRUUMP programs are:

tri, a 2-D triangular mesh generator;

meshopt2d, a 2-D mesh improvement tool;

tetra, a 3-D tetrahedral mesh generator;

meshopt3d, a 3-D mesh improvement tool;

scat3d, a tool for interpolating scattered 3-D data; and

t2d, which translates 2-D mesh files from one format to another.

A source code distribution of GRUUMP is available. It is written in C++ and known to compile on Linux Intel, Sun SunOS and Solaris, SGI IRIX, and DEC OSF1 platforms. A user's manual is included in PostScript format.
[ftp://tetra.mech.ubc.ca/pub/GRUMMP/]
g77: The GNU Fortran compiler, designed to be a replacement for or alternative to the UNIX f77 command. The g77 compiler consists of several components: a modified version of the gcc command, the g77 command itself, the libf2c run-time library which contains the machine code needed to support capabilities of the Fortran language which are not directly supported by the machine code generated by the g77 compilation phase; and f771, the compiler itself which generates assembly code which is converted to machine code by the assembler as.
The gcc command does several things including preprocessing, compiling (in a variety of languages), assembling, and linking. In a GNU Fortran installation it can by itself recognize Fortran source files and compile them with the f771 command. The g77 command is mainly a front-end for the gcc command which also knows how to specify the libraries needed to link with Fortran programs (libf2c and lm). The libf2c library is not strictly a part of GNU Fortran although just about any useful program needs to link with it. Operations like trig functions are compiled by f771 into machine code that calls on functions in libf2c when it is run, i.e. it is a run-time library. The f771 program contains most of what is unique to GNU Fortran. It consists of two large pieces of code, one being the GNU Back End (GBE) which can generate code for a wide variety of processors (and is used by the C, C++ and Fortran compiler programs). The other piece contains the bits that are unique to GNU Fortran, i.e. the code that knows how to interpret Fortran programs to determine what they want to do and then pass the knowledge to the GBE. This is known as the Fortran Front End (FFE).
The GNU Fortran language is distinct from the GNU Fortran compilation system, i.e. g77. While the primary purpose of the latter is to support the former, it also supports various dialects of Fortran which are not strictly the GNU Fortran language. The language is primarily based on the ANSI FORTRAN 77 standard but also offers some extensions popular among users of UNIX f77 and f2c, users of other compilers such as the DEC Fortran compilers, and some that are unique to GNU Fortran. It also contains a number of features that are part of Fortran 90. In addition to the intrinsic functions defined in ANSI FORTRAN 77, GNU Fortran supports a large number of additional functions, subroutines, types, and arguments. The intrinsics supported by the compiler are divided into several groups: badu77, UNIX intrinsics having inappropriate forms, e.g. functions with intended side effects; gnu, intrinsics support by the GNU Fortran language that are extensions to the Fortran 77 and 90 standards; f2c, intrinsics supported by AT&T's f2c converter and its associated libf2c; f90, Fortran 90 intrinsics; mil, MIL-STD 1753 intrinsics (e.g. MVBITS, IAND, BTEST, etc.); unix, UNIX intrinsics (e.g. IARGC, EXIT, etc.); and vxt, VAX/VMS FORTRAN intrinsics. A complete list is available in the reference manual.
A source code distribution of g77 is available. It must be compiled along with the appropriate accompanying version of GCC since it modifies parts of the GCC source code during compilation. The latest (9/97) version is g77-0.5.20.1 and requires gcc-2.7.3.1. The source code is available at the GNU sites and binaries in ELF format are available at either the Sunsite Linux Fortran or the Linux mirror Fortran directories. A 300+ page reference manual is included in the distribution in Texinfo format.
[http://www.gnu.ai.mit.edu/order/ftp.html]
gsftopk/gsftopkk: A program that uses Ghostscript to render PostScript fonts and convert the resulting bitmaps into PK format for use with xdvi and other DVI viewers. This can handle all types of fonts acceptable to Ghostscript including PFA, PFB and TrueType. The second-listed program is a version of the first modified to work with the kpathsea searching library.
[http://math.berkeley.edu/~vojta/gsftopk.html]
Gsh: A graphical shell that behaves like a normal terminal window with some graphics enhancements. Gsh is designed to be a comfortable environment for those accustomed to using UNIX shells, and also to make operations that are difficult with a normal shell easier by having the shell take advantage of a graphical environment. The features include:

a terminal window consisting of multiple output sections, one for each command, with each output section serving as a complete xterm-like terminal;

multiple independent screens, i.e. a screen bar at the bottom allows the creation of new screens and switching between them as well as shows what is running in each;

a user-configurable menu for keeping commonly-used commands;

a menu for cding to recently accessed directories that is persistent and shared among multiple invocations of the program;

collapsed and expanded displays, with the former displaying only the menus and the command line;

a context-sensitive popup menu with user-definable commands;

graphical interfaces for configuring all options and settings;

filename completion via the tab key;

command history via the up/down arrow keys;

automatic command-line expansion when needed;

automatic reformatting of lines and wrapping when a window is resized;

user-selectable colors for prompts and commands; and

persistent aliases.

A source code distribution of Gsh is available which requires Tcl/Tk 8.0.X.
[http://personal.atl.bellsouth.net/atl/v/c/vcato/gsh/]
GSLIB: A library of Fortran programs to perform various geostatistical tasks. This is composed of various sublibraries including:

Gamlib, routines to calculate the varigram of data on 2-D and 3-D regular and irregular grids;

Kriglib, routines to perform kriging and cokriging on 2D and 3D rectangular gridded data, multiple-indicator kriging, and cross-validation and jackknifing of 2D and 3D data;

Simlib, routines for boolean simulation of 2D ellipses, condition simulation of a 3D rectangular grid (with or without Markov/Bayes extension), 3D simulation by annealing, and unconditional simulation by turning bands;

Postplot, routines for generating grey scale and color PostScript graphs;

Solve, routines for inverting matrices; and

miscellanous routines to perform such tasks as Gaussian back transformation, indicator variograms for bigaussian distributions, 3D cell declustering, calibration for Markov/Bayes simulation, compute normal scores of a data set, univariate transformation.

The GSLIB library is available in source code and also contains example source code driver programs for most programs as well as data for the example programs. The documentation is a bit sparse and is contained in comments within the programs. Complete documentation is available in Deutsch and Journel (1992).
[ftp://banach.stanford.edu/gslib/]
GSM: A suite of programs for using finite state machines (FSM) graphically. GSM consists of several programs including:

gsmedit, a Motif-based graphically oriented FSM editor which allows you to draw a picture of a state machine, define the events that drive it, and enter the code to be executed when each state is entered;

gsm2cc, a compiler which takes files created with gsmedit and generates C++ code to implement the semantics of the state machine, i.e. a header file and a code file containing class declarations and definitions appropriate to the given state machine;

gsm2ps, a program which creates a rendering of the graphical elements of a FSM in PostScript;

gsmcheck, which checks to see if the FSM are created properly; and

gsm2dot, a program which transforms files created by gsmedit to files suitable for input to dot, a directed graph layout program.

GSM was developed on a Linux Intel machine and is available in both source and binary formats and in both .tar.gz and RPM formats. Binary versions both statically and dynamically linked to the Motif libraries can be obtained.
[http://www.slip.net/~andrewm/gsm/]
GSM: The Global System for Mobile communication is an implementation of a lossy speech compression algorithm coder and decoder in C. The implementation consists of a C library and a standalone program. The library is used to create a GSM object which holds the state needed to either encode frames of 160 16-bit PCM samples into 264-bit GSM frames or to decode GSM frames into linear PCM frames. The program is called toast and is modeled after the UNIX compress program, i.e. it former operates on sound files similar to how the latter operates on data files. A difference is that toast losses information with each compression cycle.
The source code for GSM is available. It is written in C and can be compiled and used on generic UNIX platforms. It is documented in a man page.
Packages that incorporate this codec include:

OpenH323, an open source implementation of the H.323 teleconferencing protocol.

[http://kbs.cs.tu-berlin.de/~jutta/toast.html]
GSMP: The General Switch Management Protocol is a general purpose protocol for controlling an ATM switch. It allows a controller to establish and release connections across the switch, add and delete leaves on a point-to-multipoint connection, manage switch ports, request configuration information, and request statistics.
[http://www.faqs.org/rfcs/rfc1987.html]
[http://www.faqs.org/rfcs/rfc2297.html]
GSS: The GNU SQL Server is a free portable multiuser relational database system which supports the full SQL89 dialect with some extensions from SQL92. GSS provides multiuser access and transaction isolation based on predicative locks.
GSS is available as source code and can be easily installed on most UNIX systems using the supplied configure script. The documentation (in English, at least) is fairly scarce at present (4/97), consisting mainly of an ASCII description and installation guide.
[http://www.ispras.ru/~kml/gss/]
Gstat: A program for the multivariable geostatistical modeling, prediction and simulation of variables in 1, 2 or 3 dimensions. The geostatistical data (or some transform thereof) are modeled as a sum of a constant or varying trend and a spatially correlated residual. The modeling portion consists of estimating the spatial correlation given a model for the trend and some assumptions of stationarity. The prediction part (also known as kriging) involves finding the best linear unbiased prediction (i.e. the expected value) and the prediction error for a variable at a specific location given observations and a model for their variations in space. Simulation entails creating randomly drawn realizations of a field given a model for the data which can be conditioned on observations.

Gstat performs prediction and estimation with a model that is the sum of a trend modeled as a linear function of polynomials (of either the coordinates or of user-defined base functions) and an independent (or dependent) geostatistically modeled residual. This allows the performance of simple, ordinary, and universal kriging and cokriging as well as standardized cokriging, kriging with external drift, block kriging, and kriging the trend. Uncorrelated and ordinary or weighted least squares regression prediction is also available. Simulation is done in Gstat by the conditional or unconditional (multi-)Gaussian sequential simulation of point values or block averages or by (multi-)indicator sequential simulation. Other features of Gstat include an interactive user interface for modeling variograms and generalized covariances using the Gnuplot plotting program, support for several ASCII and binary data formats (e.g. ASCII column, GeoEAS, PCRaster, ArcInfo-grid, Idrisi image), a command language that is concise and flexible, user customization of program defaults, and more.
A source code distribution of Gstat is available as are binaries for Linux Intel or MS-DOS platforms. It is written in ANSI C and can be compiled on many generic UNIX flavors with an appropriate compiler, e.g. gcc. It is documented in a 35 page manual in PostScript format.
[http://www.frw.ruu.nl/gstat/]
GStreamer: A streaming media library and set of tools that allow the construction of graphs of media-handling components ranging from simple MP3 playback to complex audio (mixing) and video (non-linear editing) processing. The design allows applications to transparently take advantage of advances in codec and filter technology, and new codecs and filters can be added by writing a plug-in via a clean, generic interface. The features of the comprehensive core library include:

graph-based construction to allow arbitrary pipeline construction;

use of the GTK+ model for object-oriented design and inheritance;

a scheduling system capable of dealing with most pipeline structures;

multi-threaded pipelines;

a clean and simple API for plugin and application developers;

lightweight data passing for high performance;

a complete debugging system; and

clocking to ensure global inter-stream synchronization.

The features of the GStreamer plugin architecture include:

dynamically loaded plug-ins providing elements and types and which are demand-loaded via an XML registry;

an element interface that handles all known types of sources, filters and sinks;

a capabilities system for verifying element compatibility using MIME types and media-specific properties;

autoplugging using caps to automatically complete complex paths; and

pipelines that can be saved to and loaded back from XML.

The development tools available include:

a graphical editor allowing pipelines to be quickly built;

a command-line tool for prototyping and testing;

a GNOME-based media player;

a large selection of test programs and example code.

The plug-ins shipped with the GStreamer distribution include:

an MP3 audio encoder and decoder (mpg123 and lame);

MPEG-1 and -2 video encoders and decoders;

MPEG-2 program stream multiplexers and demultiplexers;

a DVD subtitle decoder;

an AC3 audio decoder;

an Ogg Vorbis encoder and decoder;

an AVI encoder and decoder;

a Windows DLL loader using WINE for DiVX and other codecs;

JPEG and RTJPEG encoders and decoders;

WAV and AU decoders;

V4L video capture;

CD ripping capability;

a LADSPA plug-in wrapper; and

ESD sound output.

[http://gstreamer.sourceforge.net/]
gsumi: A port of the xink program to the GTK interface toolkit. The program allows a user to draw in either black (pen) or white (eraser) on a high resolution bitmap, with the finished drawing filtered down to screen resolution. XInput devices with pressure support can be used and different tools and tool properties can be assigned to each device. This project was a testbed for including XInput support to the GIMP project.
[http://www.gtk.org/~otaylor/gsumi/]
Gt: A collection of C++ classes for creating GUIs under the X Window System based directly on Xlib. It provides low-level encapsulation of X resources and high-level GUI components. The Gt library was created to allow further widgets to be developed with as little effort as possible. It is implemented in an object oriented manner with classes divided into two parts, i.e. low-level classes which provide an object oriented interface to most of the X resources and high-level classes which use the low-level classes to create such components as buttons, frames, and lists.
The classes in the package are:

GtApp, which is a common anchor class for all of the displays and widget created by a program;

GtAppDisp, which extends the GtDisplay class with event distribution to a tree of widgets;

GtBase, an abstract base class for many of the other classes;

GtColormap, which encapsulates the X colormap in a C++ object;

GtCursor, which encapsulates an X cursor;

GtDisplay, which handles the connection to the X server and encapsulates the X display;

GtDrawable, an abstract superclass for the encapsulation of pixmaps and windows;

GtFont, which encapsulates an X font in a shared object;

GtGC, which encapsulates an X GC in a private or shared object;

GtImage, which encapsulates an X image structure;

GtWidget, which is the base class of all widget classes; and

GtWindow, which encapsulates an X window and provides methods involving those window, e.g. mouse pointer handling.

The Gt source code is included in the distribution. It is written in C++ which can be compiled using g++ via the supplied configure file. All of the classes are documented in ASCII text files included in the distribution.
[http://sunsite.unc.edu/pub/Linux/libs/X/]
gtalk: GNU Talk is a complete talk system intended as a plug-in replacement for existing talk systems. It includes a client, a daemon and some utility programs. The features include:

client and server support for talk protocols 0 and 1 comprising an extension to ntalk permitting the concept of a reply as well as call forwarding on NFS environments;

multiple connections;

data transfer;

simple encryption;

shared applications;

auto-answer;

a choice of front-ends including Emacs, Ncurses, Xaw, Motif and GTK;

using the gtalk daemon to connect to any other machine using any client (new or old) regardless of its protocol;

daemon support for MRU tty announcing, announce redirection, blacklisting and tty-bomb filtering; and

utilities including an X application for launching gtalk and another application for drawing pictures.

[ftp://ftp.ultranet.com/pub/zappo/public_html/gtalk.shtml]
GTK/GTK+: The GIMP ToolKit is a small, efficient widget set for creating graphical user interfaces (GUIs) designed with the general look and feel of Motif. GTK is essentially an object-oriented application programmer's interface (API) written in C and using classes and callback functions. It was originally designed for developing the GIMP. It was also originally called GTK with a newer version with additional functionality called GTK+. It allows a programmer to use a variety of standard widgets such as push, radio, and check buttons, menus, lists, and frames as well as several container widgets useful for controlling the layout of the interface elements.
The GTK library is built on top of the GDK or General Drawing Kit, a wrapper library built on top of Xlib. GDK allows a programmer to perform many common operations without having to explicitly call Xlib, e.g. a common interface to both regular and shared memory which allows an application to transparently use the fastest image type available. A third, smaller library called GLIB is also included in the distribution. It contains replacements for a few programs such as printf and malloc which are used to increase the portability of GTK. There is an introductory article about GTK in the March 1998 issue of the Linux Journal.
Some applications built using GTK include:

dbMetrix, a graphical database tool;

Ethereal, a network protocol analyzer;

Fulcrum, a scientific data analysis and visualization package;

gEDA, tools for electrical circuit design;

gEdit, a text editor;

GFit, for displaying and manipulating data;

GIMP, an image creation and processing program;

GLADE, a GTK user interface builder;

Gmp3, a front-end to mpg123;

GRadio;

gsumi, a drawing program;

GtkSQL, a database query tool;

GtkZip, for maintaining Zip drives;

GYVE, a vector drawing editor; and

Mnemonic, a web browser.

[http://www.gimp.org/gtk/]

EasyGTK

A wrapper library around GTK that makes using it quicker and easier.
[http://devplanet.fastethernet.net/easygtk.html]

eGTK

A binding between Eiffel and GTK.
[http://www.netlabs.net/hp/richieb/gtk_eiffel.html]

EPINGLE

EPIngle is Not GLadE is a GTK builder featuring an integrated editor with compilation and support for drag and drop.
[http://www.epita.fr/~theber_s/epingle/epingle.html]

GCK

The General Convenience Kit is a package of general purpose routines for GIMP plug-in writers and users of the GTK library. The GCK routine collection contains routines for UI construction, color and image handling, vector operations, and math functions. The UI routines include general, listbox, color selector, notebook, and tooltips widget routines. The color routines include those for visual and colormap handling, RGB to GDK conversions, interpolation, color operations, colorspace conversions, and supersampling/antialiasing. The vector functions include those for 2-D and 3-D fucntions as well as for projections.
A source code version of GCK 1.0.0 is available (3/98) which can be used with GTK 0.99.7. Documentation consists of online descriptions of each function created from the source code versions.
[http://www.ii.uib.no/~tomb/gck.html]

GLADE

A GTK+ user interface builder.
[http://glade.pn.org/]

GOB

The GTK+ Object Builder is a preprocessor for easily creating GTK+ objects with inline C code so the generated files are not edited. It doesn't parse C code and ignores any C errors, and is similar to things like lex and yacc.
[http://www.5z.com/jirka/gob.html]

GPK (GTK)

The General Proxy Kit is an add-on library that permits thread-safe access to GTK. GPK is a library that turns main GTK event loop threads into server threads that listen for requests from other threads. This is one solution to the problem of integrating threads with event-driven libraries.
[http://www.humanfactor.com/gpk/]

GtkAda

An Ada95 binding for GTK+.
[http://ada.eu.org/gtkada/]

GTK-

A C++ wrapper for the GTK widget library. This allows the creation of GUIs within the flexible, object-oriented framework of GTK. The features include:

type safe callbacks;

extensibility of widgets via inheritance; and

over 100 classes that can be combined to quickly create complex user interfaces.

[http://lazy.ton.tut.fi/gtk-/]

GTK-Draw

A set of widgets and functions that enhance the GTK- toolkit with simple facilities for drawing lines, circles, rectangles, text and components of plots such as axes, tic marks, regression lines, etc.
[http://www.gnome.org/guppi/]

GtkExtra

A set of widgets for creating GUIs with GTK+. The available widgets include:

GtkSheet, a matrix widget consisting of a scrollable grid of cells in which text can be allocated;

GtkPlot, a widget for drawing high quality 2-D scientific plots;

GtklconList, a GtkLayout subclass for displaying a table of xpm icons with editable labels;

GtkDirTree, a GtkCTree subclass for file system navigation;

GtkFileList, a GtklconList subclass for displaying the contents of a given directory using icons;

GtklconFileSelection, a file selection dialog using icons;

GtkItemEntry, a subclass for entering items;

GtkFontCombo, a widget for selecting among the 35 standard Adobe PostScript fonts;

GtkComboBox, a composite widget with two buttons, one with an arrow for displaying a popdown window;

GtkColorCombo, a widget displaying a palette of colors in a popdown window;

GtkBorderCombo, a subclass widget with a variety of border styles displayed in a popdown window; and

GtkCheckItem, a widget with the look and feel of the Redmond95 theme.

[http://www.ifir.edu.ar/grupos/gtk/]

GtkGLArea

An OpenGL widget for the GTK+ GUI toolkit. This is derived from the GtkDrawingArea widget and adds only a few extra functions. This is available under the LGPL.
[http://www.student.oulu.fi/~jlof/gtkglarea/]

GtkGraph

A simple graphing calculator written using GTK+. It can plot functions and solve arithmetic expressions using double precision arithmetic. The input syntax is infix, e.g. y=-.5+.3*sin(3x), and over 20 standard functions are available.
[http://gtkgraph.linuxbox.com/]

GtkHTML

A lightweight HTML rendering, printing and editing engine.
[http://cvs.gnome.org/lxr/source/gtkhtml/]

GTKML

An XML markup language for describing GTK+ user interfaces using files rather than hard-coding. The goal is to make this a standard for describing the GTK+ widget hierarchy of a widget interface, thus allowing GTKML-compliant visual editors and application frameworks to be independently developed yet interoperable. Applications would load their user interfaces at runtime from GTKML files, and end-users could use the same or other editors to edit these files and customize the appearance and layout of an application.
[http://www.k-3d.com/libraries/gtkml/]

Gtk-Perl

Perl bindings for the GTK widget set.
[ftp://ftp.gtk.org/pub/gtk/perl/]

GtkPlot

A GTK widget for drawing high quality scientific plots in 2-D with some similarity to those produced by Microcal Origin for Windoze.
[http://www.ifir.edu.ar/grupos/gtk/]

GtkSheet

A matrix widget for GTK consisting of a scrollable grid of cells in which text can be entered and interactively edited. It is also a container class so buttons, curves, pixmaps and other widgets can be displayed in it.
[http://www.ifir.edu.ar/grupos/gtk/]

GTKstep

A patch to replace the standard GTK look and feel with a NEXTSTEP look and feel.
[http://www-info2.informatik.uni-wuerzburg.de/mitarbeiter/ulli/gtkstep/]

GUBI

The GTK+ User Interface Builder is a GUI builder which uses the GTK+ toolkit as an underyling widget set.
[http://www.SoftHome.net/pub/users/timj/gubi/index.htm]

guile-gtk

A package of glue code to make GTK accessible from Guile.
[http://www.ping.de/sites/zagadka/guile-gtk/]

PyGTK

A set of Python bindings for the GTK widget set.
[http://www.daa.com.au/~james/pygtk/]

SDPGTK

A static library that wraps most of GTK+ using C++ architecture. Most of the classes are simple wrappers for GTK+ widgets that use a straightforward class hierarchy. One interesting feature is a class implementing a proposed GTKML standard that would enable at GTK+ user interface to be loaded and bound to events at runtime from an XML document, thus allowing user customization. This is available under the GPL.
[http://www.k-3d.com/libraries/sdpgtk/]

VDK

The Visual Development Kit is a C++ framework for wrapping the GTK+ library. The features of VDK include:

a signal/events dispatching strategy that makes a clear distinction between interface and application;

support for properties like those used by modern RAD tools as well as for user-defined properties; and

similar to Borland OWL and/or VCL libraries.

The VDK distribution is available under the LGPL and includes the VDK core library containing all the GTK+ wrapped widgets as well as a components library containing new widgets not present in GTK+. See also the VDKBuilder.
[http://vdkbuilder.sourceforge.net/]

VDKBuilder

A rapid application development (RAD) tool based on VDK for constructing GUI interfaces, editing, compiling, linking and debugging within an integrated environment. The components and features of VDKBuilder include:

a project manager that creates new projects, open existing projects, and automatically generates and maintains updated GUI source files and the related makefile;

a source editor with syntax coloring, undo, and jump to errors;

a GUI editor for interactively constructing GUI interfaces and and automatically generating all related code; and

a widget inspector for perusing widget properties.

A source code distribution is available under the GPL.
[http://vdkbuilder.sourceforge.net/]

wxGTK

A port of the wxWindows cross-platform GUI toolkit to the GTK widget set.
[http://www.freiburg.linux.de/~wxxt/]
GtkZip: A program for maintaining Iomega Zip drive disks under Linux. It is based on the command line program ziptool and uses the GTK widget set. The features include:

customized Skin support;

summarization of disk space;

support for parallel, SCSI and ATAPI drives;

mounting and unmounting disks;

ejecting disks;

support for password write protection; and

changing the write protection status of a disk.

[http://home.netvigator.com/~sallymak/gtkzip/]
GTL: The Graph Template Library is a C++ graph library based on STL. GTL contains the classes needed to work with graphs, nodes, edges and algorithms as building blocks for more complex graph algorithms. A source code distribution is available.
[http://www.fmi.uni-passau.de/Graphlet/GTL/]
GTM: The implementation as a Matlab toolbox of a mathematical model for density modeling and visualization called Generative Topographic Mapping. This method generates a constrained mixture of Gaussians in the data space that is fitted to the data using a modified form of the expectation-maximization (EM) algorithm. The model is constrained by confining the centers of the mixture to a low-dimensional manifold embedded in the data space. This is accomplished via a latent variable model approach wherein a low-dimensional latent variable space is mapped into the data space using a parametric nonlinear mapping. The toolbox contains a set of Matlab functions with the functionality needed to generate GTMs and use them for the visualization of data. It is documented in a 40+ page user's and reference manual available in PostScript format.
[http://www.ncrg.aston.ac.uk/GTM/]
gtml: An HTML preprocessor which adds some extra features designed for maintaining multiple Web pages. The gtml commands are embedded in HTML documents and then the program processes them while leaving the rest of the file unchanged. Thus it is compatible with all versions of HTML and can be used immediately on any HTML pages.
The gtml program capabilities include:

creating a project file with the names of all your Web pages so they can be simultaneously updated;

specifying a tree-like hierarchy of Web pages so Next, Previous, and Up links can be automatically added;

the use of constants for HTML fragments to save typing and ensure consistency;

the inclusion of header, footer and other common files into all your HTML files;

the inclusion of a timestamp to show the time of last update;

the use of conditional commands to create different output versions under different circumstances; and

diversion of output to different directories to generate different versions (e.g. frames and non-frames versions).

The gtml program is a Perl script and can be used on any platform with a Perl installation. The program is documented at the Web site.
[http://www.lifl.fr/~beaufils/gtml/]
GTS: The GNU Triangulated Surface library is an open source project intended to provided a set of useful functions for dealing with 3-D surfaces meshed with interconnected triangles. The initial goal is to provide a simple and efficient library to scientists dealing with 3-D computational surface meshes. The features of GTS include:

a simple property-oriented sructure that gives easy access to topological properties;

metric operations (e.g. area, volume, curvature, etc.);

2-D Delaunay and constrained Delaunay triangulations;

robust geometric predicates that use fast adaptive floating point arithmetic;

robust set operations on surfaces (e.g. union, intersection, difference, etc.);

surface refinement and coarsening, i.e. for multiresolution models; and

bounding-box trees and Kd trees for efficient point location and collision/intersection detection.

The code is written in C with an object-oriented approache based on the design of GTK+.
[http://gts.sourceforge.net/]
g2: A portable graphics library that provides a comprehensive set of functions for the simultaneous generation of graphical output on different types of devices including PostScript, X11, GIF and Win32. The drawing functions include those for pixels and quasipixels, lines, triangles, rectangles, polygons, circles, ellipses, arcs, text and images. Style functions are available for colors, line styles and text. This is written in C and also has Fortran and Perl interfaces. A source code distribution is available.
[http://www.ap.univie.ac.at/users/ljubo/g2/g2.shtml]

pyG2

A set of Python wrappers for the g2 graphics library.
[http://www.geocities.com/SiliconValley/Peaks/4673/pyg2.html]
Guavac: A portable compiler for the Java language. All materials needed to compile a HotJava/Netscape compliant applet are included in the distribution, and no proprietary code from Sun is needed. It was written in C++ to compile on any UNIX system and will compile with gcc-2.7.2.
[http://http.cs.berkeley.edu/~engberg/guavac]
guichooser: A tool for easily changing from one window manager to another. A window manager is chosen via a pushbutton menu after which a customizable shell script will run to start the selected window manager and other programs.
[http://www.open-systems.com/guichooser.html]
GUI builders: Packages for building Graphical User Interfaces include:

Amulet

AUIS

Cvo

DIRT

EZWGL

Finesse

fltk

FOX

Fresco

GINA++

GLUI

Grafix

GraphApp

GTK

Hv

ivtools

JX

LessTif

lxb

Marx

MET++

MGUI

MrEd

OPaC

OffiX

Qt

Snapix

STk

SWIG

Tk

TOAD

V

VXP

Wafe

WCL

Winterp

wxWindows

xclass

Xclasses

XF

XForms

XIT

XPCE

XPIP

xtpanel

XView

Xvisual

YACL
Guide: A rule-based servlet system that lets you process forms without becoming a UNIX or Perl hacker. This is written in Perl. See Levy (1998).
[http://www.csr.uvic.ca/home/mlevy/Guide/]
guido-utils: A collection of useful shell and Perl scripts for common tasks including:

kill, kill a number of processes by name;

base64decode, decodes those annoying base64 mail attachments;

cn, converts numbers between different bases;

grepfind, search files by content;

ispell-filter, run ispell from within vi;

lsperl, list the contents of a directory tree in a pleasing way;

ren, rename multiple files;

rename, another script to rename multiple files;

unix2dos, converts UNIX newline to DOS carriagereturn/newline;

dos2unix, reverses what the previous script does;

xtitelbar, change the string in the titlebar of an xterm window; and

tux, print an ANSI color ASCII picture of the Linux penguin.

I took the liberty of naming this collection of utilites after the author's first name, seeing how it's such a spiffy one.
[http://www.linuxfocus.org/~guido.socher/]
Guile: GNU's Ubiquitous Intelligent Language for Extension which includes an embeddable Scheme interpreter, several graphics options, other languages that can be used along with Scheme, a formalism for applets, and hooks for much more. The Guile project originated out of the dissatisfaction of some with Tcl/Tk as an extension language, and was designed and built to overcome the perceived limitations of that language.
The Scheme interpreter will interpret almost all standard scheme programs, with about the only difference between Guile and the R4RS standard being that Guile is case sensitive. One of the graphics options is the use of the Tk toolkit to create widgets or groups of widgets for a GUI, while another is an interface to OpenGL via the almost complete Mesa implementation of GL. Other languages can also be used to extend programs via translators that convert them into Scheme. At present the only other language available is Tcl, but converters are also planned for Python, Perl, C, etc. Libguile is a library that can be linked to C programs and which allows the C programs to start a Scheme interpreter and execute Scheme code.
Guile has a protocol for writing applets, i.e. programs that execute in the context of a parent program, in Tcl. These applets will currently run on the SurfIt browser analogously to how Java applets run on Netscape browsers (or at least the Netscape browsers for operating systems other than Linux). Guile also includes Goonix, an interface to Posix, and can be configured to use threads on the platforms that support them. Regular expressions are implemented via the rx library. There is also a PLUGIN system that defines an orderly way of adding packages to the Guile tree.
The source code for Guile is now available from the standard GNU FTP sites Mark Galassi's Guile documentation site may also be of some interest. Guile is also being used as the implementation language for the GNUDL project.
[http://www.red-bean.com/guile/]
GUISDAP: A set of Matlab programs for performing calculations related to the European Incoherent Scatter (EISCAT) radar facility. The Grand Unified Incoherent Scatter Design and Analysis Package can be used to perform a wide range of incoherent scatter experiments. Many experiments are included in the package which also has to capability to design new experiments. Documentation is available in PDF format.
[http://spaceweb.oulu.fi/projects/guisdap/]
Guppi: A Gnome application that provides a GUI for plotting data and performing simple statistical manipulations. A source code distribution is available.
[http://www.gnome.org/guppi/]
GV: A PostScript viewer developed using Ghostview as a base. It is easier to use than Ghostview and has some additional features such as the capability of viewing PDF files.
[http://wwwthep.physik.uni-mainz.de/~plass/gv/]
GWM: The Generic Window Manager is an extensible window manager for the X Window System. It is based on a Window Object Oriented Language (WOOL) kernel which is an interpreted dialect of Lisp with specific window management primitives. A window manager is built by writing WOOL files which describe objects on the screen, including a finite state machine (FSM) which triggers WOOL actions in reponse to X events on objects. The objects can be used as decorations around X applications windows, as pop-up menus, or as independent windows. GWM can be used to efficiently emulate other window managers and play the same role for window managers that Emacs does for text editors. The distribution includes some pre-defined profiles for various popular window managers.
A source code distribution of GWM is available as are binaries for DEC Alpha, Linux Intel, and Sun SunOS and Solaris platforms. A 120 page user's manual is available in PostScript format.
[http://zenon.inria.fr/koala/gwm/]
g-wrap: An interface code generator designed to provide access to C libraries from within the Guile and RScheme interpreters, although the package is designed for the more general case of accessing many foreign APIs from within many languages. This packages allows access to C functions, types and constants from within a Scheme interpreter. It consists of three parts:

a Scheme interface for describing a library to be interfaced with the interpreter;

an engine for each supported interpreter that generates the interface code from a library specification to interface the library to the interpreter; and

a small library for each supported interpreter that maps a small set of C functions to the interpreter back-end for throwing errors, writing to a port, etc.

[ftp://ftp.gnucash.org/pub/g-wrap/]
gwstat: This processes the HTML output files from wwwstat and generates a set of GIF graphics that illustrate the httpd traffic by hour, day, week, month, year, calling country/domain and accessed archives. In addition to wwwstat this requires Perl, ACEgr, Ghostscript, and ImageMagick to work correctly. Luckily, all of these packages compile and run on Linux boxes.
[http://dis.cs.umass.edu/stats/gwstat.html]
GWT: The Gadget Windowing Toolkit is a complete windowing toolkit for Java graphical user interface (GUI) applications. It was built to improve upon and replace the Abstract Windowing Toolkit (AWT) that comes installed with typical Java Virtual Machines (JVM). A gadget is a software object with the API and functionality of a standard GUI component, but instead of having its own AWT-managed Canvas or Panel in which to draw it is drawn in a shared Canvas or Panel along with other gadgets.
Other advantages and features of the GWT include:

support for transparent components, e.g. background images that are visible through all of the gadgets in a window;

the capability of passing mouse events through a transparent component to any component beneath which allows the drawing of overlays like tips, pop-up windows for combo components, and pop-up menus;

a high software re-use capability obtained via configurability, flexibility, and extensibility;

automated support for keyboard focus management wherein the tab key can be used to traverse the focus chain forward or backward between any gadgets which are transversable;

built-in on-line help support;

emulation of the Java 1.1 API and event model; and

the capability of supporting a mixture of AWT and GWT objects.

A source code distribution of GWT is available under the GPL. Documentation is included in the distribution.
[http://www.dtai.com/products/gwt/]
gwTTS: The grounds wide Tele-Tutoring System is a set of interactive multimedia tools which enable instructors and students to interact and collaborate remotely over a computer network. GwTTS is a multi-platform system which runs on UNIX workstations, Intel PCs, and Macs. It is easy to use and can be started from a web browser nad takes advantage of the MBone to allow a large number of users to simultaneously interact through a gwTTS application.
The gwTTS system consists of a set of applications. In Electronic Office Hours instructors and students can communicate electronically in a manner similar to the traditional office hour scenario. This supports bidirectional compressed digital video and audio, a shared whiteboard, and joint browsing of Web documents. Digital Video Broadcast of Lectures enables a grounds-wide dissemination of course lectures. In the Virtual Classroom the instructor and students are at different geographic locations but interact as if they were in the same classroom. This supports a simultaneous exchange of motion video, voice, data, and graphical images. Remote Study Groups enables groups of students to join and communicate via their desktop workstations. It supports audio and visual communication, the joint editing of files, and a whiteboard.
The gwTTS system is available in binary form for IBM AIX, FreeBSD, SGI IRIX, Linux Intel, and Sun SunOS and Solaris platforms. It consists of separate teacher and student application binaries as well as some resource files. Additional required software packages are nv, vat, wb, and Mosaic. Ghostscript is also recommended. A list of recommended hardware options is available at the site. The package is documented in installation and user's guides.
[http://www.cs.virginia.edu/~gwtts/]
Gwydion Dylan: An implementation of most of Apple's Dylan programming language for UNIX systems. The distribution includes a bytecode interpreter and a Dylan-to-C compiler. It currently (9/98) ``features'' a number of bugs and a lack of shared library support. Source and binary distributions are available.
[http://www.gwydiondylan.org/]
GXF-3: A C library providing functions to read GXF-3 raster files as well as an example program using them to convert GXF data to GeoTIFF format. The Grid eXchange Format is a standard ASCII file format for exchanging gridded data. It is an adopted standard of the Gravity/Magnetics Committee of the Society of Exploration Geophysicists (SEG).
[http://gdal.velocet.ca/projects/gxf/]
GYVE: The GNU Yellow Vector Editor is a vector-based drawing program in the spirit of Adobe Illustrator and Corel Draw. GYVE is planned to be an extensible drawing editor which will use Guile as an extension language and Objective-C to implement GYVE and an array of plug-in modules. It will also use Display PostScript (DPS) as the drawing engine and GTK to construct the GUI.
[http://bandits.aist-nara.ac.jp/~masata-y/]
gzip: The GNU zip package is a compression utility designed to replace the classic UNIX compress utility, and it is better in that is has much better compression and it doesn't use any patented algorithms. A source code distribution is available which can be installed on a wide variety of platforms with the usual GNU tools.
[http://www.gzip.org/]
[http://www.gnu.org/software/gzip/gzip.html]

[ home / linux ]

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

Manbreaker Crag 2001-03-08