Appearance
To visualise a large historical network, do the opposite of plotting everything: filter and aggregate first, pick a layout built for scale, then label sparingly. A graph of tens of thousands of nodes drawn raw becomes an unreadable "hairball" that hides exactly the structure you want. This practical guide walks the full workflow — reduce, lay out, style, export — with concrete settings for Gephi and Python.
When does a historical network count as "large"?
Scale changes the toolset. Use this rough guide:
| Nodes | What works | Watch for |
|---|---|---|
< 1,000 | NetworkX + matplotlib, Gephi | nothing serious |
1,000-50,000 | Gephi, ForceAtlas2 | layout time, hairballs |
> 50,000 | graph-tool, GPU tools (graphistry, cosmograph) | memory, screen legibility |
Above a few thousand nodes a naive force-directed layout lags and the picture stops being readable, so the first move is always reduction, not a bigger screen.
How do I avoid the dreaded hairball?
The hairball comes from drawing every node at once. Reduce first, using one or more of:
- Keep the giant component — drop disconnected fragments that add noise.
- Prune by degree — remove nodes below a degree threshold; the structural backbone usually survives.
- Aggregate into communities — collapse each detected community into a single super-node.
python
import networkx as nx
# 1. giant component only
giant = G.subgraph(max(nx.connected_components(G), key=len)).copy()
# 2. prune degree-1 nodes (often single-mention people)
core = giant.subgraph([n for n, d in giant.degree() if d > 1]).copy()
print(core.number_of_nodes(), "nodes after pruning")Visualise the reduced core, and state in your caption exactly what you removed.
Which layout and settings actually scale?
In Gephi, use ForceAtlas2 with Approximate Repulsion enabled (Barnes-Hut), Scaling around 10-20, and Prevent Overlap turned on only for the final pass. It comfortably handles tens of thousands of nodes interactively. For hundreds of thousands of nodes, switch to the GPU-backed graphistry or cosmograph, or render in Python with graph-tool, whose C++ core draws very large graphs far faster than NetworkX.
How do I keep labels readable at scale?
Never label every node — that alone creates a hairball of text. Instead:
- Label only the top N nodes by degree or betweenness.
- Scale label and node size by the same metric so the eye lands on hubs.
- Colour nodes by community to encode structure without clutter.
python
import networkx as nx
bc = nx.betweenness_centrality(core, k=300, seed=1)
top = sorted(bc, key=bc.get, reverse=True)[:25] # only these get labelsTwenty-five labels on a 20,000-node graph reads cleanly; twenty thousand does not.
Should I export to screen, SVG, or PNG?
Explore interactively, but choose the export format by size. For small, finished figures, SVG or PDF give crisp vector output you can edit. For large graphs, vector files become enormous and slow — export a high-resolution PNG (300+ dpi) instead. In Gephi's Preview tab, set edge opacity low (around 0.1-0.2) so dense regions reveal density rather than flooding to solid black.
Can I do this without writing code?
Yes. Gephi is fully point-and-click: import a CSV or GEXF, run ForceAtlas2, apply a degree filter from the Filters panel, colour by modularity class, then export from Preview. It is the standard no-code path for historians and archivists working at scale, and it scales to graphs Python's default tools cannot draw interactively.
Key Takeaways
- Reduce before you draw: giant component, degree pruning, or community aggregation.
- Treat anything above a few thousand nodes as "large" and change tools accordingly.
- Use ForceAtlas2 with approximate repulsion in Gephi; switch to GPU tools or graph-tool past ~50k nodes.
- Label only the top nodes by a centrality metric and scale size to match.
- Lower edge opacity so dense areas show as density, not a black mass.
- Export finished small figures as SVG/PDF, but use high-resolution PNG for huge graphs.
Frequently Asked Questions
At what size does a historical network become 'large'?
Around 5,000 nodes a force-directed layout starts to lag and a screen-filling hairball stops being readable. Beyond roughly 50,000 nodes you need GPU layouts, filtering or aggregation rather than plotting every node.
How do I avoid the dreaded hairball?
Filter before you draw — keep the giant component, prune low-degree nodes, or collapse the graph into communities — and choose a layout tuned for scale like ForceAtlas2 with the approximate-repulsion option enabled.
Which tool is best for large historical networks?
Gephi handles tens of thousands of nodes interactively, the graphistry and cosmograph tools use the GPU for hundreds of thousands, and Python with graph-tool renders very large graphs to file faster than NetworkX.
Should I render to screen or to a vector file?
Explore interactively on screen, but export the final figure as SVG or PDF only for graphs small enough that vector output stays manageable; for huge graphs export a high-resolution PNG instead.
How do I keep labels readable on a big graph?
Never label every node. Show labels only for the top nodes by degree or betweenness, scale label size by that metric, and let the rest stay unlabelled to preserve legibility.
Can I visualise a large network without coding?
Yes — Gephi is point-and-click for import, layout, filtering, colouring by community and export, making it the standard no-code route for historians working at scale.