The following packages are subroutine libraries for performing
various graphics and visualization tasks. These are called
from within separate programs written by the user.
Generally a program is written (in C or Fortran or occasionally
some other language), compiled, linked with the appropriate
library, and executed to perform a desired task. These types
of graphics/analysis packages are usually a wee bit more difficult
to use than the separately listed
collections of utilities
or integrated systems with
GUIs since you actually have to write some source code in order
to invoke or use them.
Links last updated and checked on Mar. 24, 2004 only eights years after
the previous update on Aug. 28, 1996.
Go to a specific package or browse
An environment for image processing. It is a library primary
dealing with storing and retrieving images in files and accessing the
images in memory. It includes support for many different display
systems, and offers a continuously growing set of image processing
routines on top of the basic system. It is part of a larger
Distribution but can be obtained separately. It is apparently
written in C to run on UNIX/X-Windows platforms and comes with
predefined configuration files for Sun platforms, although they
mention that it can be compiled on other systems by simply
running the supplied configure file.
Coin is a high-level 3D graphics library with a C++ Application Programming Interface. Coin uses scenegraph data structures to render real-time graphics suitable for mostly all kinds of scientific and engineering visualization applications.
Coin is portable over a wide range of platforms: any UNIX / Linux / *BSD platform, all Microsoft Windows operating systems, and Mac OS X.
Coin is built on the industry-standard OpenGL immediate mode rendering library, and adds abstractions for higher-level primitives, provides 3D interactivity, immensely increases programmer convenience and productivity, and contains many complex optimization features for fast rendering that are transparent for the application programmer.
Coin implements the SGI Open Inventor API. Open Inventor, for those who are not familiar with it, has long since become the de facto standard graphics library for 3D visualization and visual simulation software in the scientific and engineering community. It has proved it's worth over a period of more than 10 years, it's maturity contributing to it's success as a major building block in thousands of large-scale engineering applications around the world.
A high-level library of subroutines and functions that
display data graphically. It is available as either a C or
Fortran library, and stores the graphics information in a device
independent metafile that is converted by a device driver program
for plotting on various devices. Features include several fonts
for annotations, plotting of 2- and 3-D axis plots, plotting of
curves, elementary routines for lines, vectors, and outlined
or filled regions, 3-D graphics, contouring, and geographical
projections. The Linux version of this software is freely available
in binary form (as of 12/15/95). Versions for other platforms
are available but cost a bit more.
DIVERSE is a cross-platform, open source, API for developing virtual reality applications that can run almost anywhere. DIVERSE currently runs on Linux, IRIX, Mac OS X, and Windows XP. The goal of DIVERSE is to enable developers to quickly build applications that will run on the desktop as well as various immersive systems. To avoid hindering development DIVERSE is designed without the "center of the universe" paradigm; you only use the parts of DIVERSE that you need. This allows DIVERSE to interact with many other APIs and toolkits like, OpenGL, Open Scene Graph, SGI Open GL Performer, Coin, and fmod.
A 3D graphics subroutine library that provides a comprehensive
set of tools for creating graphics applications. It is easy to
use, portable, and extendable. It has interfaces/drivers to
X11, PEX, IrisGL,
PostScript and more, and has been
ported onto most UNIX systems, including FreeBSD and Linux.
A library that allows you to quickly draw images complete with
lines, arcs, text, multiple colors, cut and paste from other
images, and flood fills, and to write out the result as a .GIF
file. This supplies most of the commonly requested features
for a 2D graphics package, and support for the PNG graphics format
is forthcoming. It is written in C but can also be used from
either Perl or Tcl via extensions.
A collection of routines for drawing sweeps and extrusions, i.e.
a 2D contour (polyline) that is swept or extruded along a 3D
path (polyline). An example would be sweeping a circle along
a straight line to generate a cylinder. Other extruded surfaces
include surfaces of revolution, sweeps, tubes, polycones, polycylinders
and helicoids. The extrusions can be texture mapped in a variety of
ways. The library itself generates 3D triangle coordinates, lighting
normal vectors and texture coordinates as output, with GL or
OpenGL APIs performing the actual rendering. The freely available
library is compatible with
the GLE Extrusion Library. The library comes with several demos
that require the
GLUT windowing and utility
library to be installed. The documentation is in hypertext
format and comes with the package.
A library of C++ classes which implement a real-time 3-D
rendering library. It features Gouraud shading, support for
different color depths and palettes, and color dithering.
Development emphasis was primarily on portability and readability
and secondarily on speed. It has been ported to Macintosh and
generic UNIX/X Windows systems.
A package for image and signal processing applications. It contains
KarmaLib (a structured library and API) and a large number of modules
(applications) to perform many standard tasks. The library is
partitioned into several sections including routines to simplify
the interface to the operating system, routines for a highly extensible
and hierarchical data structure, and routines to display and manipulate
images. It is written in C and the source code is available along
with binaries for DEC Alpha, Convex, HP, Linux, SGI, DEC Ultrix, IBM,
and Sun platforms.
Libsx (the Simple X library) v1.1 is a library that sits on top of and
to the side of the Athena widget set. Its purpose is to make writing
graphical applications (particularly those that want to draw graphics)
quite simple. A hello world program is 2 lines of code. A program
that opens a window and draws some graphics is about 5 lines. The
library doesn't limit programs to a single canned style however, and
supports building sophisticated interfaces with the same ease as a
All widgets can be created with a single function call of a few
arguments. Another function call positions widgets by specifying
logical relationships. Once this is done, the interface is created
and user specified callbacks are called as appropriate. Multiple
windows are possible, as are modal windows.
Libsx provides encapsulation of label, button, slider, toggle/radio
button, text, form, scrolled lists, and menu widgets. It also
provides a separate drawing area widget (for drawing graphics and
getting user input) as well as a clean single-line text entry widget.
Management of color is also provided.
A 3-D graphics library with an API which is very similar to
Most programs which use the OpenGL tk, aux or
tookits will work with Mesa without changing the source
code. The primary goal in the development of Mesa was correctness
rather than speed, with optimizations being the focus of most future
work. Mesa works on most UNIX workstations with ANSI C and X11,
and installed as part of Vis5D on my Linux box.
OpenGL is a low-level graphics library specification. OpenGL makes available to the programmer a small set of geometric primitives - points, lines, polygons, images, and bitmaps. OpenGL provides a set of commands that allow the specification of geometric objects in two or three dimensions, using the provided primitives, together with commands that control how these objects are rendered into the frame buffer.
OpenGL draws primitives?points, line segments, or polygons - subject to several selectable modes. You can control modes independently of each other; that is, setting one mode doesn't affect whether other modes are set (although many modes may interact to determine what eventually ends up in the frame buffer). Primitives are specified, modes are set, and other OpenGL operations are described by issuing commands in the form of function calls.
OpenGL provides you with fairly direct control over the fundamental operations of two- and three-dimensional graphics. This includes specification of such parameters as transformation matrices, lighting equation coefficients, antialiasing methods, and pixel update operators. However, it doesn't provide you with a means for describing or modeling complex geometric objects. Thus, the OpenGL commands you issue specify how a certain result should be produced (what procedure should be followed) rather than what exactly that result should look like. That is, OpenGL is fundamentally procedural rather than descriptive.
Open InventorTM is an object-oriented 3D toolkit offering a comprehensive
solution to interactive graphics programming problems. It presents a
programming model based on a 3D scene database that dramatically simplifies
graphics programming. It includes a rich set of objects such as cubes,
polygons, text, materials, cameras, lights, trackballs, handle boxes, 3D
viewers, and editors that speed up your programming
time and extend your 3D programming capabilities.
Cpw is a application framework library for OpenGL applications and games. It is designed with speed, simplicity, and portability in mind. The source is true "free software", there are no restrictions on it's use
The Cpw interface API is modeled after the GLUT API but is not compatible with it. The core library includes support for windowing and events, user input, menuing, full screen rendering, performance timing, anti-aliased TrueType font rendering, basic image loading and saving, timers, primitive drawing, and more.
Cpw supports additional functionality through Cpw Add-ons. Add-ons are complimentary api's written by developers which give Cpw applications and games access to additional functionality beyond the score of the core Cpw API.
Current add-ons include support for Audio via the OpenAL audio library, and automatic initialization of OpenGL 1.2, OpenGL 1.3, and popular extension API's including NVidia pixel and vertex shaders.
A completely OpenSourced alternative to the OpenGL Utility Toolkit (GLUT) library.
GLUT was originally written by Mark Kilgard to support the sample programs in the
second edition OpenGL 'RedBook'. Since then, GLUT has been used in a wide variety
of practical applications because it is simple, widely available and highly portable.
The original GLUT library seems to have been abandoned with the most recent version
(3.7) dating back to August 1998. Its license does not allow anyone to distribute
modified library code. This would be OK, if not for the fact that GLUT is getting
old and really needs improvement. Also, GLUT's license is incompatible with some
software distributions (e.g., XFree86).
The goal of the OpenGL Extension Wrangler Library (GLEW) is to assist C/C++
OpenGL developers with two tedious tasks: initializing and using extensions
and writing portable applications. GLEW provides an efficient run-time mechanism
to determine whether a certain extension is supported by the driver or not.
OpenGL core and extension functionality is exposed via a single header file.
GLEW currently supports a variety of platforms and operating systems, including
Windows, Linux, Darwin, Irix, and Solaris.
This also contains the WGL and GLX extensions.
GLUT (pronounced like the glut in gluttony) is the OpenGL Utility Toolkit,
a window system independent toolkit for writing OpenGL programs. It
implements a simple windowing application programming interface (API) for
OpenGL. GLUT makes it considerably easier to learn about and explore OpenGL
programming. GLUT provides a portable API so you can write a single OpenGL
program that works on across all PC and workstation OS platforms.
GLUT is designed for constructing small to medium sized OpenGL programs.
While GLUT is well-suited to learning OpenGL and developing simple OpenGL
applications, GLUT is not a full-featured toolkit so large applications
requiring sophisticated user interfaces are better off using native
window system toolkits. GLUT is simple, easy, and small.
The GLUT library has both C, C++ (same as C), FORTRAN, and Ada programming
bindings. The GLUT source code distribution is portable to nearly all OpenGL
implementations and platforms.
Open Inventor is a toolkit at a higher level than OpenGL. Beginning
graphics programmers who would find it difficult to write programs
by manipulating down to the graphics primitive level of OpenGL, find
they can quickly create 3D graphics applications using the Open Inventor
Open Inventor is designed for use in modelling and animation systems by
providing a full-featured scene graph with easy X Window system integration
and interactive graphics widgets. These qualities allow users to develop
The Open Scene Graph is a open source high peformance 3D graphics toolkit, used by application developers in fields such as visual simulation, games, virtual reality, scientific visualization and modelling. Written entirely in Standard C++ and OpenGL it runs on all Windows platforms, OSX, Linux, IRIX, Solaris and FreeBSD operating systems.
The OpenSceneGraph is an portable, high level graphics toolkit for the development of high peformance graphics applications such as flight simulators, games, virtual reality or scientific visualization. Providing an object orientated framework on top of OpenGL, it frees the developer from implementing and optimizing low level graphics calls, and provide many additional utilities for rapid development of graphics applications.
The PGPLOT Graphics Subroutine Library is a Fortran- or C-callable, device-independent graphics package for making simple scientific graphs. It is intended for making graphical images of publication quality with minimum effort on the part of the user. For most applications, the program can be device-independent, and the output can be directed to the appropriate device at run time.
The PGPLOT library consists of two major parts: a device-independent part and a set of device-dependent ``device handler'' subroutines for output on various terminals, image displays, dot-matrix printers, laser printers, and pen plotters. Common file formats supported include PostScript and GIF.
PGPLOT itself is written mostly in standard Fortran-77, with a few non-standard, system-dependent subroutines. PGPLOT subroutines can be called directly from a Fortran-77 or Fortran-90 program. A C binding library (cpgplot) and header file (cpgplot.h) are provided that allow PGPLOT to be called from a C or C++ program; the binding library handles conversion between C and Fortran argument-passing conventions.
The GNU plotutils package contains software for both programmers and technical users. Its centerpiece is libplot, a powerful C/C++ function library for exporting 2-D vector graphics in many file formats, both vector and raster. It can also do vector graphics animations.
libplot is device-independent in the sense that its API (application programming interface) does not depend on the type of graphics file to be exported.
Besides libplot, the package contains command-line programs for plotting scientific data. Many of them use libplot to export graphics.
GNU libplot, a C/C++ function library for device-independent 2-D vector graphics. GNU libplot is compatible with the traditional Unix libplot library, but is far more powerful. It is installed as part of the package. On systems that support shared libraries, it is installed as a shared library. A C++ class library called libplotter, which provides an object-oriented interface to libplot's functionality, is optionally installed as well.
GNU libplot and libplotter support all the output formats mentioned above (X11, SVG, PNG, PNM, pseudo-GIF, WebCGM, Illustrator format, idraw-editable Postscript, PCL 5, Fig format, HP-GL/2, ReGIS, Tektronix, and GNU Metafile). They can produce animated pseudo-GIFs, and smooth, double-buffered animations on any X Window System display. The libplot imaging model is similar to Postscript's. In any output format, they can draw the following.
- Graphical objects such as lines, circles and ellipses, points, and marker symbols; also paths. A path is defined as in Postscript as a sequence of line segments, arcs (either circular or elliptic), or Bezier curve segments (either quadratic or cubic). Paths may be open or closed, and they may be dashed. The filling of paths is supported (fill color, as well as pen color, may be set arbitrarily).
- Text strings, in many fonts. Text strings may include subscripts and superscripts, and may include characters chosen from more than one font in a typeface. The X11, SVG, WebCGM, Illustrator, Postscript, and xfig drivers support the 35 standard Postscript fonts, and the SVG, Illustrator, PCL 5 and HP-GL/2 drivers support the 45 standard PCL 5 fonts. All drivers support a set of 22 Hershey vector fonts. This includes HersheyCyrillic, a Russian font that uses the KOI8-R encoding, and HersheyEUC, a Japanese font that uses the 8-bit EUC-JP encoding. Japanese text strings may include both syllabic characters (Hiragana and Katakana) and ideographic characters (Kanji). A library of over 600 Kanji is built in.
When using libplot or libplotter, a programmer draws vector graphics in a `user frame', rather than in the device frame. As in Postscript, the user frame may be transformed into the device frame by an arbitrary affine map. Scaling, rotation, shearing, and translation are all supported.
A library of C functions that are useful for making scientific
plots from a program written in C or Fortran. PLplot can be used
to create x-y, log, semilog, loglog, contour, and mesh plots as well
as bar and pie charts. The kernel of PLplot was based on
pgplot but the code was
not derived from it. The authors have designed it to be an
inexpensive and portable way to create scientific graphics.
PLplot capabilities include placing multiple graphics on the
same page with multiple lines on each; support for many different
types of line styles, widths and colors; many kinds of area
fill patterns; a generous choice of fonts and font sizes
including Greek letters and mathematical symbols; and support
for a wide number of output devices including X Windows,
Tektronix, PostScript, etc. It also has an interactive
driver written in
Tcl/Tk that can be used
to manipulate a graph, e.g. zooming, panning, scaling, orienting,
changing colors, etc. PLplot has bindings that allow it to be
used in both Fortran and C programs.
zoom, pan, scale, orient, and change colors
on the same page with multiple lines on each. A wide variety of
line styles, widths, colors and fill patterns are available as well
as many characters in an extended character set. Many different
output device drivers are available, including a portable metafile
format and renderer. A Tcl/Tk
GUI is currently being developed.
The source code is available and has been compiled on generic
UNIX platforms as well as on VMS, Amiga, MS-DOS and NeXT platforms.
There is a user's and reference
guide available in PostScript format that describes how to use
the package and details the individual subroutines, although
the most recent version lags behind the software itself.
The Programmer's Reusable Library is a famility of compatible
software libraries intended to promote software reuse. It consists
of a layered set of seven libraries with a strong emphasis on
computer graphics. These libraries provide a POSIX system interface,
programming language primitive data types, graphical device drivers,
low-level graphics, graphical function plotting, graphical surface
plotting, and graphical cartographic map plotting. The PRL is available
for several platforms and as of 12/15/95 were freely available in
binary form for Linux platforms. A user's manual and reference
guide in PostScript come with the package.
A library of cartographic projections.
A library of Fortran-callable
subroutines for generating two-dimensional technical drawings
or graphics in PostScript format. It supports black and white and
color graphics, and contains 75 subroutines for performing
all the basic operations that are needed for creating
technical graphs. PSPLOT is written in Fortran 77, supports the
standard 35 PostScript fonts, and is platform independent.
QwtPlot3D is not a program, but a feature-rich Qt/OpenGL-based C++ programming library. She provides essentially a bunch of 3D-widgets for programmers.
The features include:
- parametric surfaces;
- user-defined visual objects;
- scaling, rotating, shifting and zooming of data sets and mathematical functions;
- interactive mouse handling;
- changing resolution on the fly;
- reading from MESH data files;
- data structures providing nodes and triangulation;
- autoscalable axes; and
- vector and pixmap output.
A library widget capable of plotting cartesian or polar graphs,
including logarithmic axes in cartesian plots. Features include
automatic scaling, legend drawing, axis labeling, PostScript
output, multiple plotted lines, color support, user font
specification, dashed lines, symbols drawn at points, and more.
It does not depend on any other widget set and thus may be freely
used with any of them. It compiles and runs on generic UNIX/X11
platforms with an ANSI C compiler, including Linux boxes (one one
of which it is currently maintained).
The Threedee Advanced Graphics Library is a
graphics library that provides a subset of
Its features include a portable framebuffer class, virtual
constructors, convex polygon clipping, polygon shading, dithering,
RGB emulation, ZBuffer, and much more. It was designed to be
portable and extensible and was developed on a Linux platform
using C++. It should compile on generic UNIX/X11 systems with
GCC/G++ with little effort.
VisAD is a Java component library for interactive and collaborative visualization and analysis of numerical data. The name VisAD is an acronym for "Visualization for Algorithm Development". The system combines:
- The use of pure Java for platform independence and to support data sharing and real-time collaboration among geographically distributed users. Support for distributed computing is integrated at the lowest levels of the system using Java RMI distributed objects.
- A general mathematical data model that can be adapted to virtually any numerical data, that supports data sharing among different users, different data sources and different scientific disciplines, and that provides transparent access to data independent of storage format and location (i.e., memory, disk or remote). The data model has been adapted to netCDF, HDF-5, FITS, HDF-EOS, McIDAS, Vis5D, GIF, JPEG, TIFF, QuickTime, ASCII and many other file formats.
- A general display model that supports interactive 3-D, data fusion, multiple data views, direct manipulation, collaboration, and virtual reality. The display model has been adapted to Java3D and Java2D and used in an ImmersaDesk virtual reality display.
- Data analysis and computation integrated with visualization to support computational steering and other complex interaction modes.
- Support for two distinct communities: developers who create domain- specific systems based on VisAD, and users of those domain-specific systems. VisAD is designed to support a wide variety of user interfaces, ranging from simple data browser applets to complex applications that allow groups of scientists to collaboratively develop data analysis algorithms.
- Developer extensibility in as many ways as possible.
The very ordinary GL-like library is a library of C routines
which try to allow a programmer to write programs which can be moved
to machines with
on them. It is based entirely on the
VOGLE graphics library, so peruse that
entry for further details.
The Very Ordinary Graphics Learning Environment is a library
of C routines for doing line drawings and polygon fills in 2 and
3 dimensions. It handles circles, curves, arcs, patches,
polygons, and software text in a device independent manner. In
addition to the C interface there is also a Fortran interface.
Output devices supported include PostScript, X11, Tektronix,
HPGL, HPGT, several PC graphics cards, and more. It should
install easily on generic UNIX/X11 systems.
The Very Ordinary Plotting Library is a library of C routines
for doing graph plots. It handles a variety of fits and scalings
together with providing defaults for positioning graph titles,
axis titles, and labels. It may be called from C or FORTRAN
and uses and requires the VOGLE graphics
A Fortran callable 2-D graphics library formerly known as
Volksgrapher. It runs on PCs and Sun UNIX workstations and produces
output to the screen and Epson, PostScript and QMS printers,
HPGL plotters and Tektronix 4010 terminals. I've no experience
with this one.
The Virtual Rendering System is a computer graphics software library for constructing interactive 3D applications. It provides a large collection of 3D rendering components which facilitate implementing 3D graphics applications and experimenting with 3D graphics and imaging algorithms.
VRS is implemented as a C++ library. Applications can incorporate VRS as C++ library based on the C++ API. In addition, we provide a complete Tcl/Tk binding of the C++ API, called iVRS. You can deploy VRS on common platforms such as X11/Unix and Windows 95/98/NT. It is distributed under the GNU Lesser General Public License.
The features include:
- a large collection of 2- and 3-D shapes;
- hierarchical scene modeling based on scene graphs;
- innovative rendering techniques, e.g. multipass rendering;
- support for multiple low-level rendering systems such as OpenGL and RenderMan; and
- support for 2-D imaging.
A library for 3D computer graphics and visualization. It
includes a C++ class library and a Tcl implementation based
on the class library, and as such applications can be written
in either C++ or Tcl. Vtk is a true visualization system that
lets you do more than just visualize geometry, supporting a wide
variety of algorithms such as scalar, vector, and tensor
visualization, and techniques such as implicit modeling and
polygon reduction. It has been implemented on many UNIX
platforms (including Linux) and on PCs running Windows NT and 95.
The documentation is contained in a separate textbook that is
described at the site.
The Athena Widget Set. Xaw3d is a replacement for the
original Xaw which provides a 3-D appearance by using
top and bottom shadows for several widgets. The given location
has versions of Xaw3d that implement several bug fixes as
performed by Gustaf Neumann.
The Eurobridge widget set for multimedia applications.
It includes widgets for text, text editing, displaying raster
images (GIF, TIFF, JPEG, etc.), playing audio files, playing
MPEG video files, and managing geometry. These are supported
by the Wafe
GUI building package.
The X Window Graphical
Kernel System is an X11
version of the ANSI GKS. This is a full level 2C GKS system.
This has been installed on several UNIX/X Window platforms and
special instructions for installation on Linux platforms are
given in the indicated distribution.
The documentation consists of a set of man pages, a manual
describing the C language binding used by XGKS, and a manual
explaining the implementation-specific aspects of GKS that
are particular to XGKS.
A graphics library that emulates SGI's
routines under X Windows.
It includes most of the 2-D graphics routines, the queue device
routines, some query routines, doublebuffering, RGB mode with
dithering and some window attribute routines.
On at least one machine Ygl is up to twenty times faster than
GL, and 2-D graphics will run on non-GL hardware and on
remote X servers. Ygl has interfaces for both C and
Ygl uses several environment variables to control such
behavior as specifying private colormaps, adjusting graphics
pipeline flushing times, controlling the parent window, controlling
dithering in RGB mode, etc. It also supports doublebuffering.
Ygl supports GL window related routines (e.g. minsize, maxsize,
gconfig, winmove, winpop, swinopen, etc.), color related
routines (e.g. RGBmode, RGBcolor, mapcolor, getplanes,
getcolor, c3s, etc.), device related routines (e.g. qdevice,
qreset, qread, etc.), menu routines (defpup, newpup, dopup, etc.),
font routines (e.g. loadXfont, font, strwidth, etc.), doublebuffer
routines (e.g. doublebuffer, swapbuffers, etc.),
miscellaneous routines (e.g. gversion, rectcopy,
readpixels, getgdesc, etc.), coordinate transformation
routines (viewport, ortho2, getmatrix, etc.) and
drawing routines (pnt2s, circ, endline, sbox, rects, etc.).
It also has some routine not included in standard GL.
The source code is available and is known to compile under AIX,
HP-UX, Linux, SunOS, ConvexOS and others. An ANSI-C compiler
(such as GCC) is needed. I've compiled it successfully on
my Linux box. The documentation is mostly online in
hypertext format as well as in the manuals for the standard
GL that Ygl replicates.