Demos

How this section is laid out

The demos section keeps the same shape as the original Ubigraph distribution. The exact historical pages still resolve. This page sits on top as a modern entry point and points at the same destinations.

If you came to look at the examples directly, the demo index page is the right destination. The pages below cover each demo in turn.

• Random graph
• Random binary tree
• Animation

What the demos are for

A demo set for a graph viewer is not a portfolio. Each example is built around one behaviour that is hard to see in a single still picture. You learn most from the demos when you read them as small experiments.

There are three behaviours the demos cover well:

• Layout under density. How does the viewer respond when there are more edges than the layout can comfortably separate? Where does the picture stop being readable?
• Layout under structure. Trees, near-trees, and graphs with strong hierarchy behave differently from random graphs. The viewer has to decide how much hierarchy to expose visually.
• Layout under change. A live graph keeps moving. The viewer has to keep the picture stable enough to read while still showing meaningful changes.

The Random graph, Random binary tree, and Animation demos each emphasise one of those.

Random graph in one paragraph

The random graph demo builds a graph from a fixed set of vertices and adds edges with a probability you can adjust. The interesting bit is the change in the picture, not the picture at any one moment. As edge probability climbs, the layout struggles to keep the graph readable. Past a certain density, the viewer falls back on a kind of hairball. That transition - from a sparse, ring-like layout to a dense cluster - is something most graph visualisation tools have to handle, and it is worth seeing more than once. The longer write-up is on the random graph page.

Random binary tree in one paragraph

The random binary tree demo grows a tree by picking a random existing leaf and giving it a new child. The result is not a balanced tree, and that is the point. You watch the layout decide how to handle a structure that is technically a tree but is uneven enough to behave like a general graph in places. Force-directed layouts and layered layouts both have failure modes here, and the demo makes them easy to see. Full discussion lives on the random binary tree page.

Animation in one paragraph

The animation demo changes the graph in motion. It adds nodes, removes nodes, adds edges, and removes edges, while the viewer is trying to keep up. The point is not the choreography. The point is that a graph viewer in this style has to balance two competing pressures: keep enough movement that meaningful changes are visible, but not so much that the picture loses stability. The animation page goes through that trade-off in detail.

Reading layout behaviour

A few things to pay attention to while watching any of the demos:

• Where is the centre of the graph? A stable layout will keep a recognisable centre. An over-reactive layout will keep moving it.
• Where does new structure go? When a new node appears, does the layout slot it in near related nodes, or does it shove the whole graph aside to make room?
• What happens to edge crossings? A good layout will reduce crossings opportunistically. A poor one will let them accumulate.
• What happens after a change? Does the viewer settle, or does it ring like a struck bell?

Most layout problems in production graph viewers come down to one of those four behaviours going wrong. The demos are short enough that you can compare them directly.

Where the demos fit in the wider toolchain

The demos are also a small lesson in how a graph viewer with a remote control protocol differs from a static plot. In a static plot, the layout choice is fixed and you draw once. In a viewer like this one, every demo is also a sequence of instructions - add this, remove that, change this attribute. The viewer reacts. The picture is the response, not the input.

That is one reason graph visualisation history overlaps with the wider history of graph drawing as a field. The demos are not just pretty pictures of graphs. They are small experiments in how to communicate structure visually when the structure keeps moving.

Practical notes on running the demos today

You do not need to run the original binaries to get value out of the demos. Each demo page is written to stand on its own. If you want to reproduce something similar in your own work, the patterns are simple enough to translate to a modern graph drawing library, and the graph visualisation alternatives lab note covers the substitutes worth knowing about.

If you do want to run the original code, the downloads page is honest about what to expect on a modern system, including the parts that are likely to need work.

Next steps

• Start at the demo index for the full set in their original layout.
• Read the random graph page if you want to see how a viewer handles density.
• Read the random binary tree page if you want to see how a viewer handles structure.
• Read the animation page if you want to see how a viewer handles change.