networkflow is a research pipeline for studying networks built from tabular data. Research data rarely come as networks: they come as tables of links between two kinds of entities, such as articles and the references they cite, authors and the papers they sign, or even social media accounts and what they share. networkflow turns such tables into networks, finds the communities they contain, follows these communities over time, and helps name, draw and explore them.
The pipeline is not specific to citations: any table of links between two kinds of entities can be projected onto one of them. Besides bibliographic coupling, the guides show co-citation (cited works linked when they are cited together), the coupling of authors instead of articles, and co-authorship; the same logic applies to accounts and the hashtags they use, or to members and the boards they sit on.
The package was written for, and used in, research on the history and sociology of sciences, where bibliographic coupling networks (articles linked by the references they share) map the research fronts of a literature (Kessler 1963; Boyack and Klavans 2010). Its central feature is the dynamic workflow: one network per time window, clusters in each window, and a rule that links the clusters of successive windows (building “intertemporal” or “dynamic” clusters), so that a literature can be seen being born, growing, splitting and fading. Each step is a documented function whose choices (similarity measure, threshold, time window, clustering algorithm, resolution, matching rule) are explicit arguments that can be varied and reported. Everything returns tbl_graph objects from tidygraph, or lists of them, which can be manipulated with dplyr and drawn with ggraph.
Installation
You can install the development version of networkflow from GitHub:
# install.packages("remotes")
remotes::install_github("agoutsmedt/networkflow")The package imports only what the core pipeline needs. Some steps use packages that are suggested, not imported, and the function that needs one asks to install it: ggalluvial for plot_alluvial(), tidytext for the tf-idf names of name_clusters() and extract_tfidf(), textstem to lemmatise terms, backbone for the statistical backbones (method = "sdsm"…).
A first look
The package includes the corpus of Goutsmedt (2021): the books and articles that explained the US stagflation of the 1970s, published between 1975 and 2013, and the references they cite. build_network() links two explanations when they cite the same references (bibliographic coupling), add_clusters() detects groups of explanations that share a literature, and name_clusters() labels each group with the words that distinguish its titles.
library(networkflow)
nodes <- subset(Nodes_stagflation, source_type == "Stagflation")
network <- build_network(
nodes = nodes,
directed_edges = Ref_stagflation,
source_id = "source_id",
target_id = "target_id",
method = "similarity",
edges_threshold = 1
)
network <- add_clusters(
network,
clustering_method = "leiden",
objective_function = "modularity",
seed = 123,
verbose = FALSE
)
network <- name_clusters(
network,
method = "tf-idf",
cluster_id = "cluster_leiden",
text_columns = "source_title",
nb_terms_label = 3,
clean_word_method = "lemmatize"
)layout_networks(), color_networks() and plot_networks() then draw it:
The clusters already sketch the history that Goutsmedt (2021) tells: explanations of the late 1970s centred on productivity, oil and wages, and a literature of the 2000s on the “great inflation” and monetary policy rules. The guides below show how to follow this change window by window.
Guides
Five guides, written around the same example, follow the steps of a study. Each explains the method behind the step, with the literature it comes from, before showing the code.
- From references to networks explains what a projected network is, how bibliographic coupling is measured, which threshold or statistical backbone to choose, and how to cut a corpus into time windows.
- Finding and reading clusters presents community detection with the Leiden algorithm, the role of the resolution and of the random seed, and how to name clusters and characterise the role of their members.
- Drawing networks explains what a layout does and compares the force-directed layouts (Fruchterman-Reingold, Kamada-Kawai, ForceAtlas2) with UMAP, then shows how to colour, label and draw the clusters.
- Following clusters over time links the clusters of successive windows into dynamic clusters and draws their history as an alluvial plot.
- Beyond bibliographic coupling uses the same pipeline for co-citation, for authors instead of articles and for any two-mode table, and explains why the identifiers of references matter.
What is in the package
Building networks. build_network() and build_dynamic_networks() project a two-mode table (e.g. articles and their references) onto a network of the first entities, for the whole corpus or one network per time window (in years, months or days, sliding by any step). Ties are weighted with one of the five bibliometric similarity measures of biblionetwork (Goutsmedt, Truc, and Claveau 2023), or kept only when they are statistically significant under a null model, with the backbone package (Neal 2022). filter_components() keeps the main component(s).
Finding and reading clusters. add_clusters() detects communities with Leiden (Traag, Waltman, and Eck 2019), Louvain, Infomap, walktrap or fast greedy. merge_dynamic_clusters() links the clusters of successive windows, and merge_diagnostics() shows how the result depends on the threshold. name_clusters() and extract_tfidf() describe them by their most distinctive words or most central members, and add_node_roles() places each node with the within-module degree and participation coefficient of Guimerà and Nunes Amaral (2005).
Drawing and exploring. layout_networks() computes coordinates, with an option to keep them stable across windows; color_networks(), prepare_label_networks() and plot_networks() draw networks; networks_to_alluv(), minimize_crossing_alluvial() and plot_alluvial() draw the history of dynamic clusters.
The reference lists every function.
Speed
bench/benchmark_functions.R runs the dynamic pipeline (six sliding five-year windows) on samples of a Scopus corpus of economics articles (1995-2004) and compares it with the former version of the package. On 20,000 articles, building the six networks takes about 26 s and 1.1 GB, and Leiden with a fixed 1,000 iterations (the former default) about 200 s. The default is now n_iterations = -1 (iterate until the partition is stable), which gives the same modularity in a fraction of that time. Colouring edges is now about 90 times faster (0.7 s instead of 59 s). The other steps take a few seconds, and the results are identical to those of the former version, except for the intended changes listed in NEWS.md.
Research using networkflow
networkflow grew out of, and was used in, the following studies:
- Goutsmedt (2021) on the explanations of the 1970s US stagflation, whose data are the examples of the package;
- Goutsmedt and Truc (2023) on European macroeconomics and the European Economic Review;
- Delcey, Goutsmedt, and Truc (2026) on the history of rationality in economic thought;
- Duluins et al. (2026) on the scientific reception of the Livestock’s Long Shadow report;
- the Digital History of Macroeconomics project (Goutsmedt and Truc 2025), which maps the macroeconomics literature since the 1970s and whose deliverable is archived on Zenodo;
- Boucher and Fan (2025) on productivity and citations in the field of contemporary China studies.
Authors
networkflow was developed by Aurélien Goutsmedt, Thomas Delcey and Alexandre Truc. Alexandre Truc initiated the alluvial method for following clusters over time (networks_to_alluv(), minimize_crossing_alluvial(), plot_alluvial()). The package is maintained by Thomas Delcey and Aurélien Goutsmedt.