acyclic

is a filter that takes a directed graph as input and
outputs a copy of the graph with sufficient edges
reversed to make the graph acyclic. The reversed edge
inherits all of the attributes of the original edge.

bcomps

decomposes graphs into their biconnected components,
printing the components to standard output.

ccomps

decomposes graphs into their connected components,
printing the components to standard output.

circo

draws graphs using a circular layout. The tool identifies
biconnected components and draws the nodes of the
component on a circle. The blockcutpoint tree is then
laid out using a recursive radial algorithm. Edge
crossings within a circle are minimized by placing as
many edges on the circle's perimeter as possible. In
particular, if the component is outerplanar, the
component will have a planar layout.

dijkstra

reads a stream of graphs and for each computes the
distance of every node from sourcenode.

dot

draws directed graphs. It works well on DAGs and other
graphs that can be drawn as hierarchies. It reads
attributed graph files and writes drawings. By default,
the output format dot is the input file with layout
coordinates appended.

dot2gxl

converts between graphs represented in GXL and in the DOT
language. Unless a conversion type is specified using a
flag, gxl2dot will deduce the type of
conversion from the suffix of the input file, a
.dot suffix causing a
conversion from DOT to GXL, and a .gxl suffix causing a conversion from GXL
to DOT.

dot_static

is a version of dotthat has all the
Graphviz libraries
compiled statically.

dotty

is a graph editor for the X Window System. It may be run
as a standalone editor, or as a front end for
applications that use graphs. It can control multiple
windows viewing different graphs.

fdp

draws undirected graphs using a “spring” model. It relies on a
forcedirected approach in the spirit of Fruchterman and
Reingold.

gc

is a graph analogue to wc in that it prints to
standard output the number of nodes, edges, connected
components or clusters contained in the input files. It
also prints a total count for all graphs if more than one
graph is given.

gvcolor

is a filter that sets node colors from initial seed
values. Colors flow along edges from tail to head, and
are averaged (as HSB vectors) at nodes. The graph must
already have been processed by dot.

gvpack

reads in a stream of graphs, combines the graphs into a
single layout, and produces a single graph serving as the
union of the input graphs. The input graphs must be in
dot format,
and must have all necessary layout information.

gvpr

is a graph stream editor inspired by awk. It copies input graphs to
its output, possibly transforming their structure and
attributes, creating new graphs, or printing arbitrary
information.

gxl2dot

converts between graphs represented in GXL and in the DOT
language. Unless a conversion type is specified using a
flag, gxl2dot will deduce the type of
conversion from the suffix of the input file, a
.dot suffix causing a
conversion from DOT to GXL, and a .gxl suffix causing a conversion from GXL
to DOT.

lefty

is a twoview graphics editor for technical pictures.

lneato

is a graph editor for the X Window System. It may be run
as a standalone editor, or as a front end for
applications that use graphs. It can control multiple
windows viewing different graphs.

nop

reads a stream of graphs and prints each in
prettyprinted (canonical) format on stdout. If no files
are given, it reads from stdin.

prune

reads directed graphs in the same format used by
dot and
removes subgraphs rooted at nodes specified on the
command line via options. These nodes themselves will not
be removed, but can be given attributes so that they can
be easily located by a graph stream editor such as
gpr.
prune
correctly handles cycles, loops and multiedges.

sccmap

decomposes digraphs into strongly connected components
and an auxiliary map of the relationship between
components. In this map, each component is collapsed into
a node. The resulting graphs are printed to standard out.
The number of nodes, edges and strongly connected
components are printed to standard error.
sccmap is a
way of partitioning large graphs into more manageable
pieces.

tred

computes the transitive reduction of directed graphs, and
prints the resulting graphs to standard output. This
removes edges implied by transitivity. Nodes and
subgraphs are not otherwise affected. The
“meaning” and
validity of the reduced graphs is application dependent.
tred is
particularly useful as a preprocessor to
dot to
reduce clutter in dense layouts.

twopi

draws graphs using a radial layout. Basically, one node
is chosen as the center and put at the origin. The
remaining nodes are placed on a sequence of concentric
circles centered about the origin, each a fixed radial
distance from the previous circle.

unflatten

is a preprocessor to dot that is used to improve the
aspect ratio of graphs having many leaves or disconnected
nodes. The usual layout for such a graph is generally
very wide or tall. unflatten inserts invisible
edges or adjusts the minlen on edges to improve layout
compaction.

libagraph.{so,a}

supports graph programming by maintaining graphs in
memory and reading and writing graph files. Graphs, nodes
and edges may be attributed with programmerdefined
records and string namevalue pairs. Graphs are composed
of nodes, edges, and nested subgraphs. Internally,
libagraph depends extensively
on libcdt (formerly libdict) for set representation.

libcdt.{so,a}

manages runtime dictionaries using standard container
data types: unordered set/multiset, ordered set/multiset,
list, stack, and queue.

libexpr.{so,a}

is a Clike expression library.

libgraph.{so,a}

maintains directed and undirected attributed graphs in
memory and reads and writes graph files. Graphs are
composed of nodes, edges, and nested subgraphs. A
subgraph may contain any nodes and edges of its parents,
and may be passed to any libgraph function taking a graph pointer,
except the three that create new attributes (where a main
graph is required).

libpack.{so,a}

supports the use of connected components in the context
of laying out graphs using other Graphviz libraries. One set of
functions can be used to take a single graph and break it
apart into connected components. A complementary set of
functions takes a collection of graphs (not necessarily
components of a single graph) which have been laid out
separately, and packs them together moderately tightly.
The packing is done using the polyomino algorithm of K.
Freivalds et al.

libpathplan.{so,a}

contains functions to find the shortest path between two
points in a simple polygon.
