Contents
Short Descriptions
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 

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

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

draws graphs using a circular layout 

takes a graph in DOT format as input, finds node clusters and then augments the graph with this information 

(needs GD Library) generates an image where each pixel is the difference between the corresponding pixel in each of the two source images 

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

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 

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


performs edge coloring to disambiguate crossing edges 

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

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 

converts a graph specified in the GML format to a graph in the GV (formerly DOT) format 

converts a graph specified in the GRAPHML format to a graph in the GV (formerly DOT) format 

converts a graph specified in the GV format to a graph in the GML format 

converts a graph specified in the GV format to a graph in the GXL format 

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 

provides a simple graph editor and viewer. It allows many graphs to be viewed at the same time. The text of each graph is displayed in its own text window 

generates a variety of simple, regularlystructured abstract graphs 

takes as input a graph in DOT format, finds node clusters and produces a rendering of the graph as a geographicstyle map, with clusters highlighted, in xdot format 

is a pipeline for running gvmap 

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 

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 

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


converts between graphs represented in GXL and in the GV language 

converts a sparse matrix of the Matrix Market format to a graph in the GV (formerly DOT) format 

draws undirected graphs using “spring” models. Input files must be formatted in the dot attributed graph language. By default, the output of neato is the input graph with layout coordinates appended 

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

draws clustered graphs. It takes any graph in DOT format as input 

draws clustered graphs using a squarified treemap layout. It takes any graph in DOT format as input 

reads directed graphs in the same format used by dot and removes subgraphs rooted at nodes specified on the command line via options 

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 stdout 

draws undirected graphs using the “spring” model, but it uses a multiscale approach to produce layouts of large graphs in a reasonably short time 

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 

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 

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 

is a simple script which launches the gvim or vim editor along with a GUI window showing the dot output of the edited file 

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

supports graph programming by maintaining graphs in memory and reading and writing graph files. Graphs are composed of nodes, edges, and nested subgraphs 

provides a context for applications wishing to manipulate and render graphs. It provides command line parsing interfaces, common rendering code, and a plugin mechanism for renderers 

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

provides support for parsing and deparsing graphical operations specified by the xdot language 