Up: Linux Software Encyclopedia
Last checked or modified: Feb. 28, 1997
- 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
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
- 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
See also the GLADE package.
- 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:
A source code distribution is available under the
- 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 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:
A source code distribution is available under the
- TCP client and server sockets;
- non-blocking TCP sockets;
- IP Multicast; and
- Internet address abstraction.
- 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.
- 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
but based entirely on free software.
The three main components of the project are:
Several features are planned to enhance the standard X11 environment
- CORBA for the network object interface;
- GTK for the graphical toolkit; and
- Guile for the extension language.
- 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:
These packages exist in various stages of completion. See the GNOME
home site for further information.
- 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
- 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.
A source code distribution of GNOME is available. THe
current (3/98) alpha release is version 0.13.
The requirements for compilation include
- 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)
- 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.
- GNOME Office
- A suite of productivity applications for the
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
- 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
- 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:
This is available under the GPL.
- 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
- 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.
- 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:
This is part of the GNOME project basic
- 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.
- 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
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
- 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
- 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
- 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
- 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
- Exim, an experimental mail transfer agent;
- Generic-NQS, a network queueing system;
- GNAT, an Ada compiler suite;
- Guavac, a compiler for the
- 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.
- A personal finance accounting application whose features include:
A source code distribution is available under the
This is written in C with support for
Perl, Scheme and
Tcl for configuration and extensibility.
A prototype user's guide is available.
- an easy-to-use interface no more difficult than using a check
- 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
- 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.
- 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.
- 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
- GNU-Win32 Project
- This was renamed cygwin.
- A set of programs that run under the GNU bc
program for interactively performing arbitrary precision integer
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
- 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
- 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.
- 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.
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
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
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.
- 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.
- 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
The features of GNUPG include:
- can be used as a filter program;
- implements the PGP format described in RFC 1991 with some
- 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.
- A KDE shell for
- A wrapper around GPG that takes
PGP 2.6 command-line options, translates them
into appropriate GPG commands, and then performs the desired actions.
- A Gnome front-end for
- A Tk shell for
- 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.
- A C compiler for Microchip PIC and Scenic SX microcontrollers.
The Linux version is free for non-profit usage.
- A project to provide an open source replacement for the Microchip
This supports all instruction sets of the PIC microcontrollers except
for the 17Cxx, and also recognizes the Scenix extensions to the PIC
- 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.
- A multitasking microcore for PIC16C84-based systems.
- A Pascal compiler for PIC and Scenix
The Linux version is free for non-profit use.
- 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.
- A Python interface to
- An X11 GUI front-end to the
Gnuplot package. It is written in
C++ and uses the
Qt widget set.
- 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
It additionally offers a classical interactive top-level interpreter
with a debugger.
The features include:
A source code distribution is available as is a user's and reference
manual in the usual formats.
- 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 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,
- The GNU
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
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
- 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
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
- The Java Interface to GnuStep integrates
Objective-C, with the goal being to allow
Java programmers to use the
Since the two languages are very similar, JIGS makes it possible to
use Objective-C classes from Java using exactly the same API and
JIGS can also automatically generate wrappers for newly created
Objective-C GNUstep libraries.
- 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
- 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,
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
See Garzik (2000).
Useful sites and documents include:
- Glibc Test Tool
- A tool developed to examine the internationalization (I18N) APIs provided
This tool was developed to conform to or support the following standards
This requires Glibc 2.1.X or above, and is currently (10/00) optimized
for Glibc 2.2.
- ISO/IEC 9945-1;
- ISO/IEC 9945-2;
- ISO/IEC 9899;
- ISO/IEC 9899 Amendment 1;
- cultural convention specification PDTR (future ISO/IEC Technical
- X/Open Portability Guide Issue 4; and
- LI18NUX 2000 Globalization Specification.
- 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
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
- 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.
- 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
- 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
version 2.1 or later
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).
- 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).
- 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).
- 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
- An object-oriented
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.
- 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
A source code distribution is available.
It is documented in a user's manual and an API reference.
- 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
A future (5/99) goal of the project is to include a complete set of
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
- 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.
- 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
- 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
- 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
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.
- 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
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.
- 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
- 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.
- A library for performing polygon set operations such as clipping for
use with C applications. The features include:
A source code distribution is available which includes a user's
A GUI for this called gpctool is also available.
See Vatti (1992).
- 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.
- 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
- a parameter study showing the influence of every important
- internal parameter checks that can be turned off by a compiler
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.
- 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
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.
- 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:
A source code distribution is available which requires
GTK+ for the GUI.
- 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.
- See Linux-GPIB.
- The Genetic Programming Kernel is an
easy-to-use C++ class library for performing genetic programming
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
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
- 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.
- 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.
- 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,
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
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.
- A CGM graphics metafile interpreter which
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.
- 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.
- 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
- safe interfaces to common libraries such as
- 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.
- A program which produces an execution profile of
C, Pascal for
Fortran 77 programs.
See the binutils package for
- 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.
- 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.
- 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.
- 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
This is TOMS algorithm 754 and is documented
in Resende et al. (1996).
- A front-end for mpg123 with playlist support
that can be used to play MPEG files.
The source code requires Imlib
- A image viewer for Linux whose features include single click
file viewing, external editor support, thumbnail previewing, and
It supports most file types if the libraries are already resident
on the system.
The source code distribution requires GTK
and Imlib for compilation.
- A 2-D WYSIWYG plotting program descended from
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).
- A GTK-based application for interfacing with
any Video4Linux-supported radio
cards in kernels 2.1.106 or greater.
- 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:
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
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.
- 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
- a large variety of graphical output techniques.
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
- 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.
- 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
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:
Several example programs are included to demonstrate the basic
functions available in the package as well as to demonstrate
a complete numerical integration procedure.
- 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.
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.
- 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.
- 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:
The finite language (FL) 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.
- 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.
- A program for transferring audio signals from vinyl records onto
CDs. The features include:
A source code distribution is available.
- 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
- 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
- a text-mode user interface; and
- use of WAV files for easy interchange.
- 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
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
- 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
An extensive user's guide is available both online and in
the usual printable formats.
- A toolkit for platform-independent GUI programming in
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
- 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
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
- anim, a system for algorithm animation;
- blender, a package of 3-D design and
- Crystal Space, a 3-D graphics and
- DAVID, an interactive visualization environment;
- EcoSim, an ecological modeling package with
- Egon Animator, a animation development
tool written in Scheme;
- FElt, a finite element analysis tool with
- 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
- 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
2-D plotting packages or package which contain such
- 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
- Gri, a language for drawing scientific graphs;
- GYVE, a planned vector-based drawing program;
- Hvplot, a scientific plotting package for
- 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
- 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
- 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
- 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
- VOPL, a plotting library built on top of
- WIP, an interactive scientific graphics package
built on top of PGPLOT;
- xdang, a data visualization and viewing
- XFarbe, a contouring program for isolines;
- xfig, an interactive tool for drawing and
- XGraph, an interactive program for creating
line and restricted surface plots;
- Xgraphic, an interactive package for
- Xlisp-Stat, an extensible statistical
computing environment with graph creation capabilities;
- XmdvTool, a package for visually exploring
- XploRe, an interactive statistical computing
environment with graph creation capabilities; and
- YPLOT, a tool for creating 2-D scientific
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
- DEM Tools, for working with Digital Elevation Model
- 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
- 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
- LinkWinds, a visual data exploration system for
- MAGE, a viewer for 3-D scientific images;
- MAM/VRS, a toolkit for animated, interactive 3-D
- 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
- 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
- Vis5D, a system for visualizing numerical weather
- xdang, a data visualization package;
- XDataSlice, a color imaging and data analysis tool;
- Zone, a library of 3-D PostScript operators;
- 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++,
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.
- A Java application for demonstrating
various graph theories.
The features include:
A source code distribution is available.
- comparing and contrasting breadth first seach with depth first
- 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 Java application that supports the interactive
editing of simple graphs with labels.
A source code distribution is available.
- 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
A source code distribution is available.
Extended versions of this are IPP and
See Blum and Furst (1995).
- 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
The documentation is a bit sketchy.
- 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:
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.
- 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.
A source code distribution of graphviz is available as
Binaries are also available for several platforms
including Linux Intel.
User's guides for some of the programs are available in
The program suite is also documented in Krishnamurthy (1995).
- 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
- 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.
- 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,
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,
- 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
Documentation is both included in the distribution and available
- The Geographic Resources
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.
- 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,
JPEG and PNG. It requires at least NCurses 1.8 and
- 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.
- A descendant of the Gri graphics creation
Gre includes a working parser with Perl-like
capabilities and emulation of all relevant Gri commands.
- 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
The features in this currently (2/00) alpha package include:
This is available under the GPL.
- 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.
- 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
GRG was loosely designed to produce
output although output in ASCII, Troff,
or any other kind of ASCII-based output can just as easily be
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.
- 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.
- 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.
- A program to manipulate, inventory, and decode files in
- A front-end for CD rippers such as
A source code distribution is available which requires
GTK for compilation.
- 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
See Dougherty and O'Reilly (1987),
Computer Systems Research Group, UC Berkeley (1994),
Christian (1987), and
McGilton and McNabb (1990).
- 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.
- This project, which was an attempt to create a
Java-like language, was abandoned in 1996.
- 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
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.
- 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,
Mach and the
GNU HURD directly
and proprietary OS such as DOS, Windows and OS/2 via a chain-loading
Additional features of GRUB include:
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.
- support for multiple executable formats, e.g. many a.out variants
- 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
- 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.
- 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
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
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.
- 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
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
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,
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
The source code
is available at the GNU sites and binaries in
format are available at either the
Sunsite Linux Fortran
Linux mirror Fortran
A 300+ page reference manual is included in the distribution
in Texinfo format.
- 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.
- 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 source code distribution of Gsh is available which requires
- a terminal window consisting of multiple output sections, one for
each command, with each output section serving as a complete
- 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 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
- 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).
- 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
- 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
Binary versions both statically and dynamically linked to
the Motif libraries can be obtained.
- 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
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
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
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.
- 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
- 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.
- 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.
- 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:
The development tools available 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.
- 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
- 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.
- A port of the xink program to the GTK
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.
- 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.
- 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;
- a choice of front-ends including Emacs,
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.
- The GIMP ToolKit is a small, efficient
widget set for creating graphical user interfaces
(GUIs) designed with the general look and feel of
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
- 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
- gsumi, a drawing program;
- GtkSQL, a database query tool;
- GtkZip, for maintaining Zip drives;
- GYVE, a vector drawing editor; and
- Mnemonic, a web browser.
- A wrapper library around GTK that makes
using it quicker and easier.
- A binding between Eiffel and
- EPIngle is Not GLadE is
a GTK builder featuring an integrated editor with
compilation and support for drag and drop.
- 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.
- A GTK+ user interface builder.
- 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.
- 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
- An Ada95 binding for 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.
- 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.
- A set of widgets for creating GUIs with
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
- 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
- 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
- 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.
- A simple graphing calculator written using GTK+.
It can plot functions and solve arithmetic expressions using double
The input syntax is infix, e.g. y=-.5+.3*sin(3x), and over
20 standard functions are available.
- A lightweight HTML rendering, printing and
- An XML markup language for describing
GTK+ user interfaces using files rather
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
- Perl bindings for the
GTK widget set.
- A GTK widget for drawing high quality scientific
plots in 2-D with some similarity to those produced by Microcal
Origin for Windoze.
- 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.
- A patch to replace the standard GTK look and feel
with a NEXTSTEP look and feel.
- The GTK+ User Interface Builder
is a GUI builder which uses the GTK+
toolkit as an underyling widget set.
- A package of glue code to make GTK accessible
- A set of Python bindings for the GTK widget set.
- 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
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
This is available under the GPL.
- The Visual Development Kit is a C++
framework for wrapping the GTK+ library.
The features of VDK include:
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.
- 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.
- A rapid application development (RAD) tool based on
for constructing GUI
interfaces, editing, compiling, linking and debugging within
an integrated environment.
The components and features of VDKBuilder include:
A source code distribution is available under the
- 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 port of the wxWindows cross-platform
GUI toolkit to the GTK widget set.
- 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
- 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.
- 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.
- 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.
- 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
- 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.
- 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:
The code is written in C with an object-oriented
approache based on the design of GTK+.
- a simple property-oriented sructure that gives easy access to
- metric operations (e.g. area, volume, curvature, etc.);
- 2-D Delaunay and constrained Delaunay triangulations;
- robust geometric predicates that use fast adaptive floating
- robust set operations on surfaces (e.g. union, intersection,
- surface refinement and coarsening, i.e. for multiresolution models; and
- bounding-box trees and Kd trees for efficient point location and
- 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.
- A set of Python wrappers for the
g2 graphics library.
- 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.
- 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.
- GUI builders
- Packages for building Graphical User
- 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).
- A collection of useful shell and
Perl scripts for common tasks including:
I took the liberty of naming this collection of utilites after the
author's first name, seeing how it's such a spiffy one.
- 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
- 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.
- GNU's Ubiquitous Intelligent
Language for Extension
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
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
Guile documentation site
may also be of some interest.
Guile is also being used as the implementation language for
the GNUDL project.
- A set of Matlab programs for performing
calculations related to the European Incoherent Scatter (EISCAT)
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.
- A Gnome application that provides a GUI
for plotting data and performing simple statistical
A source code distribution is available.
- 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.
- 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
- An interface code generator designed to provide access to
C libraries from within the
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
- an engine for each supported interpreter that generates the interface
code from a library specification to interface the library to the
- 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.
- 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,
to work correctly. Luckily, all of these packages compile and
run on Linux boxes.
- 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
- 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
Documentation is included in the distribution.
- 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
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,
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
is also recommended. A list of recommended hardware options is
available at the site.
The package is documented in installation and user's guides.
- 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.
- 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
- 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.
- 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
A source code distribution is available which can be installed
on a wide variety of platforms with the usual
[ home /
Up: Linux Software Encyclopedia