TGM: A Modular and Efficient Library for Machine Learning on Temporal Graphs

## Abstract

Abstract Well-designed open-source software drives progress in Machine Learning (ML) research. While static graph ML enjoys mature frameworks like PyTorch Geometric and DGL, ML for temporal graphs (TG), networks that evolve over time, lacks comparable infrastructure. Existing TG libraries are often tailored to specific architectures, hindering support for diverse models in this rapidly evolving field. Additionally, the divide between continuous- and discrete-time dynamic graph methods (CTDG and DTDG) limits direct comparisons and idea transfer. To address these gaps, we introduce Temporal Graph Modelling (TGM), a research-oriented library for ML on temporal graphs, the first to unify CTDG and DTDG approaches. TGM offers first-class support for dynamic node features, time-granularity conversions, and native handling of link-, node-, and graph-level tasks. Empirically, TGM achieves an average 7.8× speedup across multiple models, datasets, and tasks compared to the widely used DyGLib, and an average 175× speedup on graph discretization relative to available implementations. Beyond efficiency, we show in our experiments how TGM unlocks entirely new research possibilities by enabling dynamic graph property prediction and time-driven training paradigms, opening the door to questions previously impractical to study. Code: tgm-team/tgm Documentation: tgm.readthedocs.io

## 1 Introduction and Motivation

Advances in machine learning are driven by open, easy-to-use libraries that let researchers focus on developing frontier architectures. For example, deep learning research was propelled by Caffe (Jia et al., 2014), TensorFlow (Abadi et al., 2016) and PyTorch (Paszke et al., 2019). Similarly, developments in graph machine learning (Kipf & Welling, 2016; Veličković et al., 2017; Dwivedi & Bresson, 2020; Rampášek et al., 2022) are accelerated by libraries such as PyG (Fey & Lenssen, 2019; Fey et al., 2025) and DGL (Wang et al., 2019). However, both PyG and DGL are designed for static graphs and cannot capture the temporal dynamics of networks, known as Temporal Graphs (TGs). Real-world examples include transaction (Shamsi et al., 2022), social (Huang et al., 2023a), trade (Poursafaei et al., 2022b), and communication networks (Yoon et al., 2020) among others.

Recently, Temporal Graph Learning (TGL) has emerged to capture both spatial and temporal dependencies in networks (Cornell et al., 2025; Cao et al., 2020; Han et al., 2014). The field has seen growth with high-impact, cross-domain applications, such as LinkedIn’s LiGNN system (Borisyuk et al., 2024) for user recommendations and mobility modelling that informed COVID-19 policy decisions (Chang et al., 2021). Unlike static graph ML, TGL must treat time as a first-class signal, making timestamps central to modelling and data processing. Despite research progress, software infrastructure has not kept pace.

Limitations of existing libraries. Current TG libraries (Yu et al., 2023a; Rozemberczki et al., 2021) are narrow in scope: many implement only a single algorithm family (Wang & Mendis, 2024; Zhou et al., 2023b) and most lack extensibility, resulting in a fragmented ecosystem. For instance, TGL (Zhou et al., 2022a), DistTGL (Zhou et al., 2023b) and TGLite (Wang & Mendis, 2024) are optimized for temporal message passing architectures (Rossi et al., 2020; da Xu et al., 2020) but do not support emerging transformer-based approaches (Yu et al., 2023a; Gao et al., 2025). Also, none provide time conversion operations which are critical for analyzing temporal granularity in TGs (Huang et al., 2024). Finally, existing libraries fall short on usability features needed to foster reproducible research such as profiling tools, test suites, and modular abstractions (see Table [1](https://arxiv.org/html/2510.07586v1#S2.T1)).

Motivation for a unified framework. Unlike NLP, where the transformer serves as a canonical architecture (Vaswani et al., 2017), TGL lacks a standard model family. This leads to fragmented and error-prone experimentation: continuous- and discrete-time models require entirely different data pipelines, while core operations such as temporal neighbor sampling and negative edge construction are implemented inconsistently. Without a unified framework, the community faces difficulties in fair benchmarking, rapid prototyping, and combining ideas across approaches.

Our solution. We introduce TGM, a modular and efficient framework for TGL research. TGM introduces several firsts: native support for node events, a generic hook mechanism that standardizes TG transformations, and unified support for both continuous- and discrete-time graphs, ending the long-standing separation between the two lines of research (Rossi et al., 2020; You et al., 2022). Node events naturally capture phenomena like social media posts or other user activity in real-world networks (Kazemi et al., 2020). These abstractions unify diverse TG pipelines, lowering the barrier for practitioners and accelerating innovation. Beyond flexibility, TGM delivers efficiency: $7.8\times$ faster than DyGLib on standard TG models and an average speedup of $175\times$ on graph discretization.

[Uncaptioned image]: x1.png

Figure: Figure 1: Overview of TGM features. TGM has native support for node events and unified continuous- and discrete-time graph iteration (left). Generic hooks formalize common TG transformations (top-right). TGM supports a broad range of temporal graph learning methods (bottom-right).
Refer to caption: x2.png

In summary, the key properties of TGM are:

- •
First unified library for TG. TGM is the first library to support both continuous- and discrete-time graphs, treating them as distinct views of the same underlying data. We implement 8 methods from both CTDG and DTDG literature, including frontier models.
- •
Time as a first-class citizen. Time operations are central to TGs. TGM natively incorporates time granularity into its API, with built-in support for graph discretization and snapshot iteration.
- •
Efficiency. Our experiments show that TGM achieves an average $7.8\times$ faster end-to-end training than DyGLib, and $175\times$ faster graph discretization compared with existing implementations.
- •
Research-oriented. Designed for rapid prototyping, TGM emphasizes modularity and ease-of-use. Its novel hook mechanism standardizes temporal graph transformations while supporting the broadest range of TG tasks: link, node, and graph-level prediction.

## 2 Related Work

CTDG Methods.
Continuous-time Dynamic Graph (CTDG) methods process temporal graphs as streams of timestamped edge events. TGAT (da Xu et al., 2020) pioneered inductive representation learning on temporal graphs, and TGN (Rossi et al., 2020) generalized this approach into a widely adopted framework, with TGAT as a special case. Both rely on temporal neighbor sampling for message passing. More recently, DyGLib (Yu et al., 2023a) emerged as a popular library, introducing DyGFormer, one of the first transformer-based CTDG architectures inspired by their success in time series, NLP, and vision (Vaswani et al., 2017; Devlin et al., 2019; Dosovitskiy et al., 2021). Despite these advances, Poursafaei et al. (2022a) exposed flaws in prior evaluation and proposed EdgeBank, a strong heuristic baseline for link prediction. To address reproducibility, Huang et al. (2023a) introduced the large-scale Temporal Graph Benchmark (TGB), which we adopt for evaluating TGM. Recently, TPNet (Lu et al., 2024b) further advanced state-of-the-art link prediction by introducing temporal walk matrices with time decay, and is fully supported in TGM.

DTDG Methods.
Discrete-time Dynamic Graph (DTDG) or snapshot-based methods represent temporal evolution as a sequence of static graph snapshots, adapting GNNs like GCN (Kipf & Welling, 2017) to this setting. GCLSTM (Chen et al., 2018) integrates GCNs with LSTMs (Hochreiter & Schmidhuber, 1997) to capture spatial and temporal dependencies, while PyG Temporal (Rozemberczki et al., 2021) provides a library of DTDG architectures for spatiotemporal graph learning. However, PyG Temporal lacks recent methods and standardized benchmarks like TGB. More recently, Unified Temporal Graph (UTG) (Huang et al., 2024) demonstrated a proof-of-concept for comparing CTDG and DTDG approaches via graph discretization. While UTG offers useful insights, its implementation is slow, limited to a few datasets, and not designed for reuse. In contrast, TGM supports fully vectorized graph discretization and time-iteration operations, unifying CTDG and DTDG within a single, robust framework and closing a long-standing gap in TGL.

TGL Libraries.
Several libraries support temporal graph learning including DyGLib (Yu et al., 2023b), TGL (Zhou et al., 2022b), DistTGL (Zhou et al., 2023a), TGLite (Wang & Mendis, 2024), and TSL (Cini & Marisca, 2022). DyGLib provides pipelines for continuous-time models but is limited by scalability, lack of modularity, and weak support for discrete-time methods (Gastinger et al., 2024). TGL and DistTGL offer large-scale sampling and multi-GPU execution but lack a researcher-friendly interface and have seen few recent updates. TGLite focuses on continuous-time message-flow models, while TSL addresses spatiotemporal modelling on static graphs.

[Table 1](https://arxiv.org/html/2510.07586v1#S2.T1) summarizes key aspects of these libraries. TGM stands out as the only library that supports both CTDG and DTDG methods, bridging continuous- and discrete-time research paradigms. Its efficient and modular design facilitates flexible experimentation, while support for time conversion and dynamic node events enables diverse temporal graph learning tasks. Additionally, comprehensive tests and system profiling ensure reproducibility and provide research-ready infrastructure.

**Table 1: Comparison of TGL libraries. TGM is the only library that meets all desirable criteria for TGL research while other libraries lack one or more criteria.**
|  | TGL Features | Software Infrastructure |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Library | CTDG | DTDG | Time Ops. | Node Events | Modular | Efficient | Unit Tests | Profiling |
| TGM (ours) | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| DyGLib | ✓ | × | × | × | × | × | × | × |
| TGL | ✓ | × | × | × | × | ✓ | × | ✓ |
| TGLite | ✓ | × | × | × | ✓ | ✓ | ✓ | ✓ |
| PyG Temporal | × | ✓ | × | × | ✓ | ✓ | ✓ | × |

## 3 TGM Framework

In this section, we present the formal foundations of TGM. We unify continuous- and discrete-time formulations into a common representation, define graph discretization as a principled mapping from continuous events to snapshots, and introduce the hook formalism, a modular abstraction for composing graph operations. Together, these elements inform the software design in Section [4](https://arxiv.org/html/2510.07586v1#S4).

TGM Temporal Graph Formulation.
First, we introduce the notation and treatment of temporal graphs in TGM. On temporal graphs, events are the fundamental unit for representing the network’s evolution (Kazemi et al., 2020). To capture changes in graph structure and features, we distinguish between event types:

###### Definition 3.1 (Node and Edge Events) .

An edge event $(t,s,d,\mathbf{x}_{edge})$ is an interaction between two nodes $s$ and $d$ at time $t$ where $\mathbf{x}_{edge}\in\mathbb{R}^{d_{edge}}$ is the associated edge feature vector. A node event $(t,s,\mathbf{x}_{node})$ represents the arrival of new features $\mathbf{x}_{node}\in\mathbb{R}^{d_{node}}$ at node $s$ and timestamp $t$.

###### Definition 3.2 (Temporal Graph) .

A temporal graph is a sequence of time-ordered events: $\mathcal{G}=\{e_{0},...,e_{T}\}$. Each event $e_{i}$ can be an edge event or a node event. Also, $\mathcal{G}$ can be associated with a static node feature matrix $\mathbf{X}\in\mathbb{R}^{n\times d_{static}}$ where $n$ is the number of unique nodes in $\mathcal{G}$. For any time interval $\mathcal{T}\subset\mathbb{R}^{+}$, the temporal sub-graph $\mathcal{G}|_{\mathcal{T}}$ contains all events in $\mathcal{G}$ intersecting $\mathcal{T}$.

Figure: Figure 2: TGM supports iteration by events and time. Discretization maps fine-grained timestamps (e.g., hourly) to coarser timestamps (e.g., daily), aggregating duplicated edges in the process.
Refer to caption: x3.png

Representing Continuous-Time and Discrete-Time Graphs. In TGM, we represent temporal graphs as event sequences without distinguishing between CTDG and DTDG formulations. We argue that any temporal graph admits a native time granularity $\tau$: the coarsest unit of time (e.g., seconds) that still discriminates between all event timestamps. If real-world time is unavailable (e.g., due to privacy), TGM employs a special event-ordered granularity $\tau_{\text{event}}$, preserving only the relative order of events but lacks correspondence to a real-world time granularity, thus $\tau_{\text{event}}$ is excluded from any time operations. Lastly, note that time granularities can be compared: $\hat{\tau}\leq\tau\iff\tau\textit{ is coarser than }\hat{\tau}$. This view unifies CTDG and DTDG as alternative ways of iterating over the same event stream:

###### Definition 3.3 (CTDG: Event-based iteration) .

A CTDG is often expressed as a stream of events (Kazemi et al., 2020; Huang et al., 2023b; Rossi et al., 2020; You et al., 2022). In TGM, iterating a CTDG corresponds to using the event-ordered granularity $\tau_{\text{event}}$. Each batch contains a fixed number of events, independent of real-world time.

###### Definition 3.4 (DTDG: Time-based iteration) .

A DTDG is often expressed as a sequence of static graph snapshots sampled at regularly-spaced time intervals, i.e. as $\{\mathbf{G}_{0},\mathbf{G}_{1},...,\}$, where $\mathbf{G}_{i}=\{\mathbf{V}_{i},\mathbf{E}_{i}\}$ is a static graph at snapshot $i$ (Huang et al., 2024).
In TGM, we achieve this by iterating with a time granularity $\hat{\tau}$ that is coarser than the native graph granularity. Iterating by time produces batches $\mathcal{G}|_{[t_{0},t_{i}]},\mathcal{G}|_{[t_{i},t_{i+1}]},\cdots$ where $|t_{i}-t_{0}|=|t_{i+1}-t_{i}|=\hat{\tau}$.

Discretizing Temporal Graphs. For snapshot-based models, it is often useful to process the graph at a coarser granularity than the native $\tau$ (e.g., daily instead of second-wise). Discretization converts the underlying network to this coarser timeline by collapsing duplicate edges within each time interval:

###### Definition 3.5 (Time Granularity Discretization.) .

Let $\mathcal{G}$ be a temporal graph with native time granularity $\tau$. For any $\hat{\tau}\geq\tau$, the discretization operator:

$$ $\displaystyle\mathcal{\psi}_{r}:(\mathcal{G},\tau)\mapsto(\hat{\mathcal{G}},\hat{\tau})$ (1) $$

maps $\mathcal{G}$ to coarser granularity $\hat{\tau}$, groups events into equivalence classes induced by $\hat{\tau}$ and applies a reduction operator $r$ to each class. The resulting graph
$\hat{\mathcal{G}}$ contains one representative event per class. Figure [2](https://arxiv.org/html/2510.07586v1#S3.F2) illustrates these time operations in TGM.

TGM Learning Tasks
The common goal in TG is to forecast the structure or property of the graph in the future. TGM supports ML on all levels of the graph, namely link, node and graph tasks:

- •
Dynamic Link Property Prediction. Given the temporal sub-graph $\mathcal{G}|_{[t_{0},t_{i}]}$, predict some property (or existence) of a link between a node pair $(s,d)$ at a future timestamp $t$ where $t>t_{i}$.
- •
Dynamic Node Property Prediction. Given the temporal sub-graph $\mathcal{G}|_{[t_{0},t_{i}]}$, predict some property of a node $s$ at a future timestamp $t$ where $t>t_{i}$.
- •
Dynamic Graph Property Prediction. Given the temporal sub-graph $\mathcal{G}|_{[t_{0},t_{i}]}$, predict some property of $\mathcal{G}|_{[t^{\prime},t^{\prime\prime}]}$ over a future time interval $[t^{\prime},t^{\prime\prime}]$ where $t_{i}<t^{\prime}\leq t^{\prime\prime}$.

TGM Hooks and Recipes. We formalize a TGL workflow as a composition of transformations called hooks. Each hook specifies a typed contract on batch attributes, and recipes are valid precisely when their signatures compose.

###### Definition 3.6 (Materialized Batch) .

Let $G|_{\mathcal{T}}$ be a temporal subgraph. We denote by $B|_{\mathcal{T},\mathcal{A}}$ the materialized batch associated with a set of properties $\mathcal{A}$. Intuitively, $\mathcal{A}$ captures the attributes that enrich the slice of data, typically tensors required by a model (e.g. neighborhood information in message-passing architectures).

###### Definition 3.7 (Hook) .

A hook $\phi_{\mathcal{R},\mathcal{P}}$ is a transformation on a materialized batch:

$$ $\displaystyle\phi_{\mathcal{R},\mathcal{P}}:\mathcal{B}|_{\mathcal{T},\mathcal{A}}\mapsto\mathcal{B}|_{\mathcal{T},\mathcal{A}\cup\mathcal{P}}$ (2) $$

which declares a contract based on the attributes required on the input $\mathcal{R}\subset\mathcal{A}$, and the attributes produced $\mathcal{P}$, so that the batch transformed by $\phi$ has attributes $\mathcal{A}\cup\mathcal{P}$. Table [2](https://arxiv.org/html/2510.07586v1#S3.T2) illustrates several common temporal graph operations expressed as hooks using the notation introduced here.

The real power of hooks is unlocked by composing their transformations to express complete temporal graph workflows. The notion of a hook recipe formalizes this.

###### Definition 3.8 (Hook Recipe) .

A set of hooks $\{\phi^{1}_{\mathcal{R}_{1},\mathcal{P}_{1}},...,\phi^{k}_{\mathcal{R}_{k},\mathcal{P}_{k}}\}$ induces an ordering given by their dependencies:

$$ $\displaystyle\phi^{i}\to\phi^{j}\iff\mathcal{P}_{i}\cap\mathcal{R}_{j}\neq\emptyset$ (3) $$

We call this a hook recipe if this dependency graph is acyclic and every required is satisfied, i.e. $\forall j,\mathcal{R}_{j}\subset\bigcup_{i<j}\mathcal{P}_{i}$. Thus, any hook recipe admits a valid ordering by topological sort.
With this framework, exploring new research is simpler as complex workflows can be expressed with minimal boilerplate. Figure [3](https://arxiv.org/html/2510.07586v1#S3.F3) illustrates how ML and analytics pipelines are represented as recipes in TGM.

**Table 2: Examples of common temporal graph operations represented as hooks, and their attributes.**
| Hook Type | Neighbor Sampling | Evaluation | Device Ops. | Analytics |  |
| --- | --- | --- | --- | --- | --- |
|  | Recency | Uniform | TGB Eval | GPU Transfer | DOS Estimate |
| $\mathcal{R}$ (Requires) | $\{\text{negatives}\}$ | $\{\text{negatives}\}$ | $\emptyset$ | $\emptyset$ | $\emptyset$ |
| $\mathcal{P}$ (Produces) | $\{\text{neighbors}\}$ | $\{\text{neighbors}\}$ | $\{\text{negatives}\}$ | $\emptyset$ | $\{\text{DOS}\}$ |

Figure: Figure 3: Example recipes in TGM: TGAT link prediction and Density of States Analysis. TGM provides a unified ecosystem supporting both representation learning and temporal graph analytics. The constituent hooks are modular, enabling reuse across different workflows within the community.
Refer to caption: x4.png

###### Definition 3.1 (Node and Edge Events) .

###### Definition 3.2 (Temporal Graph) .

###### Definition 3.3 (CTDG: Event-based iteration) .

###### Definition 3.4 (DTDG: Time-based iteration) .

###### Definition 3.5 (Time Granularity Discretization.) .

###### Definition 3.6 (Materialized Batch) .

###### Definition 3.7 (Hook) .

###### Definition 3.8 (Hook Recipe) .

## 4 TGM Software Library

We now describe the software implementation that realizes the framework described in the previous section. Figure [4](https://arxiv.org/html/2510.07586v1#S4.F4) presents the high-level system design: the data layer is an immutable time-sorted coordinate format (COO) storage with lightweight graph views for efficient slicing; the execution layer is built around a hook manager that transparently performs complex transformations (e.g., temporal neighbors); and the ML layer materializes batches on-device for model computation. This separation of concerns yields workflows that are efficient and extensible, as we show in Section [5.2](https://arxiv.org/html/2510.07586v1#S5.SS2).

IO Adaptors and Data Preprocessing. TGM streamlines experimentation by integrating the widely-used benchmark dataset: TGB (Huang et al., 2023a; Gastinger et al., 2024), in the form of IO Adapters, including loading, preprocessing, and train/validation/test splits. This allows researchers to start experiments immediately and compare models consistently with minimal overhead. Custom adapters are also supported via CSV and Pandas. Our design makes it straightforward to incorporate new benchmarks while ensuring consistent evaluation across all datasets (see Appendix [C](https://arxiv.org/html/2510.07586v1#A3)).

Graph Storage and Graph Views. The storage exposes an interface for graph queries, implemented using a time-sorted COO with a cached index. This enables binary search over timestamps, which is critical for recent-neighbor retrieval. The backend is designed for extension, allowing alternative layouts (Zhang et al., 2021; Sha et al., 2017) so future models can use the most efficient data structures for their workload. Backed by the storage, graph views provide lightweight, concurrency-safe access to temporal sub-graphs. Each view tracks time boundaries and encodes read-access through the time granularity abstraction. This enables TGM to perform both CTDG and DTDG-style loading, making it straightforward to study the effects of snapshot resolutions, as illustrated in Section [5.2](https://arxiv.org/html/2510.07586v1#S5.SS2). Our discretization is fully vectorized, enabling efficient snapshot creation, as demonstrated in Table [5](https://arxiv.org/html/2510.07586v1#S5.T5).

Figure: Figure 4: Three Layer Architecture of TGM: data layer (left), with IO adaptors and preprocessing, immutable COO graph storage, and lightweight sub-graph views; execution layer (middle), where users register custom hooks or apply pre-built recipes through the hook manager and dataloader to inject execution logic; and ML layer (right), where batches are materialized on device and used for node-, link-, or graph-level prediction. Light blue elements denote user-facing APIs.
Refer to caption: x5.png

Hook Registry and Management.
Building on the graph abstractions, hooks are transformations that can be combined to create complex workflows (see Section s [3](https://arxiv.org/html/2510.07586v1#S3)). The HookManager handles shared state, resolves dependencies, and executes transparently during data loading. A key-value interface allows hooks to be registered under specific conditions (e.g., analytics hooks, training hooks). We provide pre-defined recipes for common tasks such as TGB link prediction, helping new practitioners avoid common pitfalls like mismanaging state across data splits or using incorrect negatives.

Diverse Model and Task Support.
TGM provides PyTorch modules tailored for TGL, including memory units, attention layers, and link decoders. With this, TGM implements a range of TG methods, from baselines like EdgeBank (Poursafaei et al., 2022a), to message passing-based models like TGAT (da Xu et al., 2020), and frontier models like DyGFormer (Yu et al., 2023a) and TPNet (Lu et al., 2024b). Crucially, learnable components are decoupled from graph management, making it easy for researchers to prototype new models.

Figure: Figure 5: Example workflow in TGM. Left: dataset loading, graph creation, and hook registration; Right: manager injection, model setup, and training loop with automatic hook activation. Highlighted code maps to system components from Figure [4](https://arxiv.org/html/2510.07586v1#S4.F4).
Refer to caption: x6.png

Streamlined TGL Workflows. Figure [5](https://arxiv.org/html/2510.07586v1#S4.F5) provides a high-level overview of a typical workflow in TGM, illustrating how data preparation, graph creation, hook registration, and model training are orchestrated. Loading a temporal graph is straightforward, and hook registration can be shared and reused across different workflows, enabling code reuse. Registered hooks dynamically inject behaviour during data loading, ensuring models automatically receive the appropriate tensors. This unifies the model interface and explicitly defines which batch attributes each model consumes. The manager’s reset method exposes a single API for clearing the state of all active hooks. More complex workflows can be implemented by registering hooks under key-value pairs.

Robust and Research-Ready Infrastructure.
Finally, TGM is built following modern software engineering practices to ensure reliability, maintainability, and ease of use. We use type hinting throughout the codebase, which unifies model APIs and improve usability. Continuous integration pipelines run end-to-end tests on all layers, hooks, and graph APIs with test coverage to ensure correctness. Performance monitoring utilities can track GPU usage with support for tools such as FlameProf (Bobrov, 2017) to help identify bottlenecks. We also provide detailed tutorials, documentation, and examples for link, node and graph tasks. Overall, TGM provides a high-quality, research-ready platform that lowers the barrier to TG research while supporting efficient experimentation.

## 5 Experiments

In this section, we evaluate TGM along two dimensions central to its design: efficiency and research extensibility. Correctness results are deferred to Appendix [A.4](https://arxiv.org/html/2510.07586v1#A1.SS4), where we show that TGM faithfully reproduces prior library performance. The appendix also includes peak memory measurements ( [A.2](https://arxiv.org/html/2510.07586v1#A1.SS2)) and a detailed runtime breakdown ( [A.3](https://arxiv.org/html/2510.07586v1#A1.SS3)) collected with TGM ’s profiling tools.

### 5.1 Efficiency Benchmark

We evaluate TGM on two standard TGL tasks: dynamic link property prediction and dynamic node property prediction. Because graph discretization is a core operation in DTDG methods, we additionally benchmark the efficiency of TGM in this setting. All datasets are stored in CPU host memory and transferred to GPU when required. Full experimental details, including model hyperparameters and compute resources, are provided in Appendix [E](https://arxiv.org/html/2510.07586v1#A5).

**Table 3: Training time per epoch (seconds, ↓) for link property prediction. The first and second best results are highlighted (✕ marks unsupported). TGM achieves competitive performance to the system-optimized TGLite library on TGAT and TGN models while supporting a broader range of architectures, and consistently outperforms the widely used research library DyGLib across all datasets and models, delivering a $4.4\times$ speedup on the transformer-based DyGFormer architecture.**
| Model | Wikipedia | Reddit | LastFM |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| TGM | DyGLib | TGLite | TGL | TGM | DyGLib | TGLite | TGL | TGM | DyGLib | TGLite | TGL |  |
| TGAT | 6.97 | 41.24 | 4.85 | 10.00 | 28.23 | 182.21 | 25.00 | 53.25 | 55.32 | 349.31 | 38.00 | 85.12 |
| TGN | 10.59 | 63.37 | 6.80 | 23.32 | 61.25 | 287.06 | 60.50 | 125.23 | 91.23 | 392.98 | 92.93 | 250.00 |
| DyGFormer | 17.00 | 75.10 | ✕ | ✕ | 72.29 | 326.60 | ✕ | ✕ | 142.40 | 633.99 | ✕ | ✕ |
| TPNet | 12.28 | ✕ | ✕ | ✕ | 49.79 | ✕ | ✕ | ✕ | 97.23 | ✕ | ✕ | ✕ |
| GCLSTM | 3.56 | ✕ | ✕ | ✕ | 9.17 | ✕ | ✕ | ✕ | 140.69 | ✕ | ✕ | ✕ |
| GCN | 2.50 | ✕ | ✕ | ✕ | 7.88 | ✕ | ✕ | ✕ | 96.89 | ✕ | ✕ | ✕ |

Link Property Prediction. We benchmark TGM against state-of-the-art libraries on the dynamic link property prediction task using three standard datasets: Wikipedia, Reddit, and LastFM (^1^11Referred to as tgbl-wiki, tgbl-subreddit, and tgbl-lastfm in TGB.). Competing baselines include DyGLib (Yu et al., 2023a), TGL (Zhou et al., 2022b), and TGLite (Wang & Mendis, 2024), all of which are designed primarily for continuous-time models.
Table [3](https://arxiv.org/html/2510.07586v1#S5.T3) reports training time per epoch across models implemented in TGM and competing libraries. First, TGM uniquely supports the widest range of architectures, spanning both CTDG and DTDG methods. In particular, DTDG models such as GCLSTM and GCN are supported via graph discretization and iterate-by-time functionality, and TGM is the only library with native support for TPNet (Lu et al., 2024a), the state-of-the-art link prediction model on TGB as of September 2025. Second, TGM consistently ranks among the top two fastest implementations across datasets and models. It outperforms DyGLib and TGL in all cases, and is only slightly behind the highly specialized TGLite on TGAT and TGN. For example, TGM achieves a $4.4\times$ speedup over the alternative DyGFormer implementation on Wikipedia. A key driver of performance is our fully vectorized recency sampler, implemented with a circular buffer in PyTorch-native code, which enables cache-friendly memory access. Finally, TGM offers native support for TGB evaluation, the standard benchmark protocol. Appendix [A](https://arxiv.org/html/2510.07586v1#A1) shows that TGM can be up to $246\times$ than DyGLib for TGN on Wikipedia, owing to batch-level de-duplication and efficient data handling: while DyGLib repeatedly samples neighbors for each prediction, TGM samples once per batch. By contrast, TGL and TGLite do not support this one-vs-many evaluation, limiting their benchmarking robustness compared to TGM.

Node Property Prediction. We benchmark TGM on the dynamic node property prediction task, comparing against both DyGLib and the native TGB implementations on the Trade and Genre datasets. TGL and TGLite do not support this task. Table [4](https://arxiv.org/html/2510.07586v1#S5.T4) reports training time per epoch. Compared to DyGLib, TGM achieves up to a $10\times$ speedup for TGN on Trade while reducing training time by 80 seconds on Genre. Moreover, TGM is the only library supporting node property prediction for DTDG models: GCLSTM, GCN, and TGCN. Note, we encountered an OOM while running DyGLib on Genre with our 64GB RAM allocation (see Appendix [E](https://arxiv.org/html/2510.07586v1#A5)), requiring 256GB of memory to produce the results reported in Table [4](https://arxiv.org/html/2510.07586v1#S5.T4).

Table: Table 4: Training time per epoch (seconds, ↓) for dynamic node property prediction. The first and second best results are highlighted (✕ marks unsupported). TGM has the best all-around performance and uniquely supports message-passing (TGN), snapshots-based (e.g. TGCN), and transformer-based (DyGFormer) models.

| Model | Trade | Genre |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| TGM | DyGLib | TGB | TGM | DyGLib | TGB |  |
| TGN | 12.94 | 19.37 | 11.07 | 208.88 | 918.46 | 281.36 |
| DyGFormer | 16.24 | 117.13 | ✕ | 70.89 | 3539.95 | ✕ |
| P.F. | 0.41 | 2.09 | 0.78 | 38.15 | 41.73 | 35.58 |
| TGCN | 0.85 | ✕ | ✕ | 17.27 | ✕ | ✕ |
| GCLSTM | 0.88 | ✕ | ✕ | 17.71 | ✕ | ✕ |
| GCN | 0.80 | ✕ | ✕ | 17.21 | ✕ | ✕ |

Graph Discretization. Enabling DTDG models on CTDG tasks requires discretizing the original graph into snapshots. We compare TGM’s implementation with that of UTG (Huang et al., 2024). Table [5](https://arxiv.org/html/2510.07586v1#S5.T5) shows that TGM achieves dramatic speedups, up to $433\times$ on LastFM. This improvement stems from a fully vectorized, PyTorch-native implementation that avoids cache-unfriendly Python dictionaries and other overheads common in prior repositories. This result underscores our commitment to high-performance, research-ready tooling, setting TGM apart from existing libraries in efficiency and engineering standards.

Table: Table 5: Discretization Latency to Hourly Snapshots (seconds, ↓). TGM has substantial speedups due to our vectorized, PyTorch-native implementation.

| Dataset | UTG | TGM | Speedup |
| --- | --- | --- | --- |
| Wikipedia | 1.94 | 0.04 | 49.62× |
| Reddit | 8.83 | 0.21 | 41.63× |
| LastFM | 19.94 | 0.05 | 433.39× |

**Table 6: The choice of snapshot time granularity significantly affects link prediction performance. Reported metric is MRR (↑) with the first and second best result for each dataset highlighted.**
| Time Gran. | Wikipedia | Reddit |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| GCN | T-GCN | GCLSTM | GCN | T-GCN | GCLSTM |  |
| Hourly | 0.510 $\pm$ 0.001 | 0.509 $\pm$ 0.004 | 0.395 $\pm$ 0.022 | 0.529 $\pm$ 0.012 | 0.374 $\pm$ 0.004 | 0.219 $\pm$ 0.003 |
| Daily | 0.702 $\pm$ 0.007 | 0.540 $\pm$ 0.008 | 0.372 $\pm$ 0.017 | 0.266 $\pm$ 0.007 | 0.231 $\pm$ 0.003 | 0.212 $\pm$ 0.004 |
| Weekly | 0.393 $\pm$ 0.005 | 0.330 $\pm$ 0.009 | 0.323 $\pm$ 0.010 | 0.191 $\pm$ 0.002 | 0.212 $\pm$ 0.001 | 0.206 $\pm$ 0.004 |

### 5.2 TGM Research Experiments

In addition to its efficiency, TGM is designed as a flexible framework for exploring research questions in temporal graph learning. By supporting both CTDG and DTDG methods, along with native time conversions and composable hooks, TGM allows researchers to implement and test novel ideas effortlessly. We ran all three example experiments using a single script, which we include in our anonymized code release. These experiments investigate the following questions: RQ1: How accurately can we predict the future evolution of a graph property? RQ2: How does the time granularity of graph snapshots impact DTDG performance on a continuous-time graph? RQ3: How do batching strategies, by fixed edges versus by time, affect the performance of a CTDG model?

RQ1: Dynamic Graph Property Prediction.
Graph-level tasks require grouping edges into snapshots. The ability to natively support iteration by time is unique to TGM framework, thus allowing researchers to effortlessly explore research questions in dynamic graph property prediction. As shown in Table [7](https://arxiv.org/html/2510.07586v1#S5.T7), we leverage this capability to benchmark models on predicting whether a future transaction network snapshot will grow, a key problem for understanding network evolution. The results highlight the sensitivity of model performance to temporal granularity: T-GCN performs best on weekly snapshots with an AUC of 0.800, while GCLSTM excels at the daily scale with an AUC of 0.589.

Table: Table 7: Binary classification task predicting whether the next daily snapshot will see an increase in the number of edges. Reported metric is AUC (↑) with the first and second best result for each dataset highlighted.

| Model | Wikipedia | Reddit |
| --- | --- | --- |
| P.F. | 0.018 $\pm$ 0.058 | 0.617 $\pm$ 0.047 |
| T-GCN | 0.667 $\pm$ 0.083 | 0.600 $\pm$ 0.147 |
| GCLSTM | 0.567 $\pm$ 0.047 | 0.526 $\pm$ 0.020 |
| GCN | 0.577 $\pm$ 0.053 | 0.200 $\pm$ 0.000 |

RQ2: Effect of Time Granularity for DTDG methods.
Table [6](https://arxiv.org/html/2510.07586v1#S5.T6) demonstrates that the choice of snapshot granularity, i.e. hourly, daily, or weekly, has a substantial impact on the performance of snapshot-based temporal graph models. On the Wikipedia dataset, the impact is particularly pronounced: GCN’s MRR increases by 30% when moving from weekly to daily snapshots, while T-GCN and GCLSTM improve by 21% and 5%, respectively. On Reddit, the same trend is observed, though less extreme: GCN achieves 0.529 MRR with hourly snapshots, dropping to 0.191 with weekly snapshots. These results underscore the importance of selecting an appropriate snapshot granularity for DTDG models. TGM makes this process effortless, allowing users to adjust the time granularity with a single line of code, treating it effectively as a hyperparameter.

RQ3: Effect of Batch Size for CTDG methods. Our analysis reveals that the configuration of the evaluation process itself is a critical, yet previously overlooked, hyperparameter in temporal graph learning. As demonstrated in Table [8](https://arxiv.org/html/2510.07586v1#S5.T8), the choice of validation batch size and temporal unit significantly impacts the reported performance of the TGAT model on link prediction. Note that when iterating by time, the number of edges in each batch is different, however, each batch spans a fixed amount of time instead. We observe a pronounced degradation in MRR with larger batch sizes and coarser temporal units (e.g., Day versus Hour). TGM supports flexible temporal batching via our graph formulation, enabling the investigation of batch size at test time.

Table: Table 8: The choice of validation batch size and batch unit affects the performance of TGAT link prediction on Wikipedia dataset. first and second are highlighted.

|  | Size/Unit | Test MRR (↑) |
| --- | --- | --- |
| Batch size | 1 | 0.449 $\pm$ 0.001 |
| 50 | 0.414 $\pm$ 0.006 |  |
| 100 | 0.414 $\pm$ 0.004 |  |
|  | 200 | 0.403 $\pm$ 0.004 |
| Batch unit | Hour | 0.402 $\pm$ 0.012 |
| Day | 0.349 $\pm$ 0.004 |  |

## 6 Conclusion

We present TGM, a modular and efficient framework for temporal graph learning built around a novel hook formalism. By decoupling graph operations from model logic, TGM enables rapid prototyping and code reuse, unifying CTDG and DTDG methods under a single research-ready library. Efficiency-wise, TGM is highly competitive and on average $7.8\times$ faster in training than the widely used DyGLib.
We ultimately envision TGM as a foundation for a shared ecosystem where models, hooks, and analytics can be seamlessly composed and reused, accelerating TGL research.

## Reproducibility

The TGM code repo is publicly available at [https://github.com/tgm-team/tgm](https://github.com/tgm-team/tgm). The package is also available via PyPI install at [https://pypi.org/project/tgm-lib/](https://pypi.org/project/tgm-lib/). All experiments use fixed random seeds, and full hyperparameters are listed in Table [14](https://arxiv.org/html/2510.07586v1#A5.T14). The Python environment was built deterministically and managed with the uv package manager. Benchmarks were conducted in isolated SLURM jobs, and additional details on compute resources and experimental setup is provided in Appendix [E](https://arxiv.org/html/2510.07586v1#A5).

#### Acknowledgments

This research was supported by the Canadian Institute for Advanced Research (CIFAR AI chair program) and the AI Security Institute (AISI) grant: Towards Trustworthy AI Agents for Information Veracity and the EPSRC Turing AI World-Leading Research Fellowship No. EP/X040062/1 and EPSRC AI Hub No. EP/Y028872/1. Shenyang Huang was supported by the Natural Sciences and Engineering Research Council of Canada (NSERC) Postgraduate Scholarship Doctoral (PGS D) Award and Fonds de recherche du Québec - Nature et Technologies (FRQNT) Doctoral Award. This research was also enabled in part by compute resources provided by Mila (mila.quebec).

## References

- Abadi et al. (2016)
Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek Gordon Murray, Benoit Steiner, Paul A. Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng.
Tensorflow: A system for large-scale machine learning.
In Kimberly Keeton and Timothy Roscoe (eds.), *12th USENIX Symposium on Operating Systems Design and Implementation, OSDI 2016, Savannah, GA, USA, November 2-4, 2016*, pp. 265–283. USENIX Association, 2016.
URL [https://www.usenix.org/conference/osdi16/technical-sessions/presentation/abadi](https://www.usenix.org/conference/osdi16/technical-sessions/presentation/abadi).
- Bobrov (2017)
Anton Bobrov.
Flameprof, 2017.
URL [https://github.com/baverman/flameprof](https://github.com/baverman/flameprof).
- Borisyuk et al. (2024)
Fedor Borisyuk, Shihai He, Yunbo Ouyang, Morteza Ramezani, Peng Du, Xiaochen Hou, Chengming Jiang, Nitin Pasumarthy, Priya Bannur, Birjodh Tiwana, et al.
Lignn: Graph neural networks at linkedin.
In *Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining*, pp. 4793–4803, 2024.
- Cao et al. (2020)
Defu Cao, Yujing Wang, Juanyong Duan, Ce Zhang, Xia Zhu, Congrui Huang, Yunhai Tong, Bixiong Xu, Jing Bai, Jie Tong, et al.
Spectral temporal graph neural network for multivariate time-series forecasting.
*Advances in neural information processing systems*, 33:17766–17778, 2020.
- Chang et al. (2021)
Serina Chang, Emma Pierson, Pang Wei Koh, Jaline Gerardin, Beth Redbird, David Grusky, and Jure Leskovec.
Mobility network models of covid-19 explain inequities and inform reopening.
*Nature*, 589(7840):82–87, 2021.
- Chen et al. (2018)
Da Chen, Yanfeng Li, Yilun He, Xiaojun Jin, and Jie Tang.
Gc-lstm: Graph convolution embedded lstm for dynamic link prediction.
In *Proceedings of the 2018 IEEE International Conference on Data Mining (ICDM)*, pp. 243–252. IEEE, 2018.
doi: 10.1109/ICDM.2018.00038.
- Cini & Marisca (2022)
Andrea Cini and Ivan Marisca.
Torch Spatiotemporal, 3 2022.
URL [https://github.com/TorchSpatiotemporal/tsl](https://github.com/TorchSpatiotemporal/tsl).
- Cornell et al. (2025)
Filip Cornell, Oleg Smirnov, Gabriela Zarzar Gandler, and Lele Cao.
On the power of heuristics in temporal graphs.
*arXiv preprint arXiv:2502.04910*, 2025.
- da Xu et al. (2020)
da Xu, chuanwei ruan, evren korpeoglu, sushant kumar, and kannan achan.
Inductive representation learning on temporal graphs.
In *International Conference on Learning Representations (ICLR)*, 2020.
- Devlin et al. (2019)
Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova.
BERT: pre-training of deep bidirectional transformers for language understanding.
In Jill Burstein, Christy Doran, and Thamar Solorio (eds.), *Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2019, Minneapolis, MN, USA, June 2-7, 2019, Volume 1 (Long and Short Papers)*, pp. 4171–4186. Association for Computational Linguistics, 2019.
doi: 10.18653/V1/N19-1423.
URL [https://doi.org/10.18653/v1/n19-1423](https://doi.org/10.18653/v1/n19-1423).
- Ding et al. (2024)
Zifeng Ding, Yifeng Li, Yuan He, Antonio Norelli, Jingcheng Wu, Volker Tresp, Michael Bronstein, and Yunpu Ma.
Dygmamba: Efficiently modeling long-term temporal dependency on continuous-time dynamic graphs with state space models.
*arXiv preprint arXiv:2408.04713*, 2024.
- Dosovitskiy et al. (2021)
Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, and Neil Houlsby.
An image is worth 16x16 words: Transformers for image recognition at scale.
In *9th International Conference on Learning Representations, ICLR 2021, Virtual Event, Austria, May 3-7, 2021*. OpenReview.net, 2021.
URL [https://openreview.net/forum?id=YicbFdNTTy](https://openreview.net/forum?id=YicbFdNTTy).
- Dwivedi & Bresson (2020)
Vijay Prakash Dwivedi and Xavier Bresson.
A generalization of transformer networks to graphs.
*CoRR*, abs/2012.09699, 2020.
URL [https://arxiv.org/abs/2012.09699](https://arxiv.org/abs/2012.09699).
- Fey & Lenssen (2019)
Matthias Fey and Jan Eric Lenssen.
Fast graph representation learning with pytorch geometric.
*CoRR*, abs/1903.02428, 2019.
URL [http://arxiv.org/abs/1903.02428](http://arxiv.org/abs/1903.02428).
- Fey et al. (2025)
Matthias Fey, Jinu Sunil, Akihiro Nitta, Rishi Puri, Manan Shah, Blaz Stojanovic, Ramona Bendias, Alexandria Barghi, Vid Kocijan, Zecheng Zhang, Xinwei He, Jan Eric Lenssen, and Jure Leskovec.
Pyg 2.0: Scalable learning on real world graphs.
*CoRR*, abs/2507.16991, 2025.
doi: 10.48550/ARXIV.2507.16991.
URL [https://doi.org/10.48550/arXiv.2507.16991](https://doi.org/10.48550/arXiv.2507.16991).
- Gao et al. (2025)
Jian Gao, Jianshe Wu, and Jingyi Ding.
Hyperevent:learning cohesive events for large-scale dynamic link prediction.
*CoRR*, abs/2507.11836, 2025.
doi: 10.48550/ARXIV.2507.11836.
URL [https://doi.org/10.48550/arXiv.2507.11836](https://doi.org/10.48550/arXiv.2507.11836).
- Gastinger et al. (2024)
Julia Gastinger, Shenyang Huang, Mikhail Galkin, Erfan Loghmani, Ali Parviz, Farimah Poursafaei, Jacob Danovitch, Emanuele Rossi, Ioannis Koutis, Heiner Stuckenschmidt, Reihaneh Rabbany, and Guillaume Rabusseau.
Tgb 2.0: A benchmark for learning on temporal knowledge graphs and heterogeneous graphs.
In A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, J. Tomczak, and C. Zhang (eds.), *Advances in Neural Information Processing Systems*, volume 37, pp. 140199–140229. Curran Associates, Inc., 2024.
URL [https://proceedings.neurips.cc/paper_files/paper/2024/file/fda026cf2423a01fcbcf1e1e43ee9a50-Paper-Datasets_and_Benchmarks_Track.pdf](https://proceedings.neurips.cc/paper_files/paper/2024/file/fda026cf2423a01fcbcf1e1e43ee9a50-Paper-Datasets_and_Benchmarks_Track.pdf).
- Han et al. (2014)
Wentao Han, Youshan Miao, Kaiwei Li, Ming Wu, Fan Yang, Lidong Zhou, Vijayan Prabhakaran, Wenguang Chen, and Enhong Chen.
Chronos: a graph engine for temporal graph analysis.
In *Proceedings of the Ninth European Conference on Computer Systems*, pp. 1–14, 2014.
- Hochreiter & Schmidhuber (1997)
Sepp Hochreiter and Jürgen Schmidhuber.
Long short-term memory.
*Neural computation*, 9(8):1735–1780, 1997.
- Huang et al. (2023a)
Shenyang Huang, Farimah Poursafaei, Jacob Danovitch, Matthias Fey, Weihua Hu, Emanuele Rossi, Jure Leskovec, Michael Bronstein, Guillaume Rabusseau, and Reihaneh Rabbany.
Temporal graph benchmark for machine learning on temporal graphs.
*Advances in Neural Information Processing Systems*, 36:2056–2073, 2023a.
- Huang et al. (2023b)
Shenyang Huang, Farimah Poursafaei, Jacob Danovitch, Matthias Fey, Weihua Hu, Emanuele Rossi, Jure Leskovec, Michael M. Bronstein, Guillaume Rabusseau, and Reihaneh Rabbany.
Temporal graph benchmark for machine learning on temporal graphs.
In Alice Oh, Tristan Naumann, Amir Globerson, Kate Saenko, Moritz Hardt, and Sergey Levine (eds.), *Advances in Neural Information Processing Systems 36: Annual Conference on Neural Information Processing Systems 2023, NeurIPS 2023, New Orleans, LA, USA, December 10 - 16, 2023*, 2023b.
URL [http://papers.nips.cc/paper_files/paper/2023/hash/066b98e63313162f6562b35962671288-Abstract-Datasets_and_Benchmarks.html](http://papers.nips.cc/paper_files/paper/2023/hash/066b98e63313162f6562b35962671288-Abstract-Datasets_and_Benchmarks.html).
- Huang et al. (2024)
Shenyang Huang, Farimah Poursafaei, Reihaneh Rabbany, Guillaume Rabusseau, and Emanuele Rossi.
UTG: towards a unified view of snapshot and event based models for temporal graphs.
In Guy Wolf and Smita Krishnaswamy (eds.), *Learning on Graphs Conference, 26-29 November 2024, Virtual*, volume 269 of *Proceedings of Machine Learning Research*, pp.  28. PMLR, 2024.
URL [https://proceedings.mlr.press/v269/huang25a.html](https://proceedings.mlr.press/v269/huang25a.html).
- Jia et al. (2014)
Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross B. Girshick, Sergio Guadarrama, and Trevor Darrell.
Caffe: Convolutional architecture for fast feature embedding.
In Kien A. Hua, Yong Rui, Ralf Steinmetz, Alan Hanjalic, Apostol Natsev, and Wenwu Zhu (eds.), *Proceedings of the ACM International Conference on Multimedia, MM ’14, Orlando, FL, USA, November 03 - 07, 2014*, pp. 675–678. ACM, 2014.
doi: 10.1145/2647868.2654889.
URL [https://doi.org/10.1145/2647868.2654889](https://doi.org/10.1145/2647868.2654889).
- Kazemi et al. (2019)
Seyed Mehran Kazemi, Rishab Goel, Sepehr Eghbali, Janahan Ramanan, Jaspreet Sahota, Sanjay Thakur, Stella Wu, Cathal Smyth, Pascal Poupart, and Marcus Brubaker.
Time2vec: Learning a vector representation of time.
*arXiv preprint arXiv:1907.05321*, 2019.
- Kazemi et al. (2020)
Seyed Mehran Kazemi, Rishab Goel, Kshitij Jain, Ivan Kobyzev, Akshay Sethi, Peter Forsyth, and Pascal Poupart.
Representation learning for dynamic graphs: A survey.
*J. Mach. Learn. Res.*, 21:70:1–70:73, 2020.
URL [https://jmlr.org/papers/v21/19-447.html](https://jmlr.org/papers/v21/19-447.html).
- Kipf & Welling (2016)
Thomas N Kipf and Max Welling.
Semi-supervised classification with graph convolutional networks.
In *International Conference on Learning Representations*, 2016.
- Kipf & Welling (2017)
Thomas N. Kipf and Max Welling.
Semi-supervised classification with graph convolutional networks.
In *International Conference on Learning Representations (ICLR)*, 2017.
URL [https://arxiv.org/abs/1609.02907](https://arxiv.org/abs/1609.02907).
- Lu et al. (2024a)
Xiaodong Lu, Leilei Sun, Tongyu Zhu, and Weifeng Lv.
Improving temporal link prediction via temporal walk matrix projection.
In Amir Globersons, Lester Mackey, Danielle Belgrave, Angela Fan, Ulrich Paquet, Jakub M. Tomczak, and Cheng Zhang (eds.), *Advances in Neural Information Processing Systems 38: Annual Conference on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, December 10 - 15, 2024*, 2024a.
URL [http://papers.nips.cc/paper_files/paper/2024/hash/ff7bf6014f7826da531aa50f4538ee19-Abstract-Conference.html](http://papers.nips.cc/paper_files/paper/2024/hash/ff7bf6014f7826da531aa50f4538ee19-Abstract-Conference.html).
- Lu et al. (2024b)
Xiaodong Lu, Leilei Sun, Tongyu Zhu, and Weifeng Lv.
Improving temporal link prediction via temporal walk matrix projection.
In Amir Globersons, Lester Mackey, Danielle Belgrave, Angela Fan, Ulrich Paquet, Jakub M. Tomczak, and Cheng Zhang (eds.), *Advances in Neural Information Processing Systems 38: Annual Conference on Neural Information Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, December 10 - 15, 2024*, 2024b.
URL [http://papers.nips.cc/paper_files/paper/2024/hash/ff7bf6014f7826da531aa50f4538ee19-Abstract-Conference.html](http://papers.nips.cc/paper_files/paper/2024/hash/ff7bf6014f7826da531aa50f4538ee19-Abstract-Conference.html).
- Luo & Li (2022)
Yuhong Luo and Pan Li.
Neighborhood-aware scalable temporal network representation learning.
*Learning on Graphs Conference*, 2022.
- Pareja et al. (2020)
Aldo Pareja, Giacomo Domeniconi, Jie Chen, Tengfei Ma, Toyotaro Suzumura, Hiroki Kanezashi, Tim Kaler, Tao B. Schardl, and Charles E. Leiserson.
Evolvegcn: Evolving graph convolutional networks for dynamic graphs.
In *The Thirty-Fourth AAAI Conference on Artificial Intelligence, AAAI 2020, The Thirty-Second Innovative Applications of Artificial Intelligence Conference, IAAI 2020, The Tenth AAAI Symposium on Educational Advances in Artificial Intelligence, EAAI 2020, New York, NY, USA, February 7-12, 2020*, pp. 5363–5370. AAAI Press, 2020.
doi: 10.1609/AAAI.V34I04.5984.
URL [https://doi.org/10.1609/aaai.v34i04.5984](https://doi.org/10.1609/aaai.v34i04.5984).
- Paszke et al. (2019)
Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf, Edward Z. Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala.
Pytorch: An imperative style, high-performance deep learning library.
In Hanna M. Wallach, Hugo Larochelle, Alina Beygelzimer, Florence d’Alché-Buc, Emily B. Fox, and Roman Garnett (eds.), *Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada*, pp. 8024–8035, 2019.
URL [https://proceedings.neurips.cc/paper/2019/hash/bdbca288fee7f92f2bfa9f7012727740-Abstract.html](https://proceedings.neurips.cc/paper/2019/hash/bdbca288fee7f92f2bfa9f7012727740-Abstract.html).
- Poursafaei et al. (2022a)
Farimah Poursafaei, Shenyang Huang, Kellin Pelrine, and Reihaneh Rabbany.
Towards better evaluation for dynamic link prediction.
*Advances in Neural Information Processing Systems*, 35:32928–32941, 2022a.
- Poursafaei et al. (2022b)
Farimah Poursafaei, Shenyang Huang, Kellin Pelrine, and Reihaneh Rabbany.
Towards better evaluation for dynamic link prediction.
*Advances in Neural Information Processing Systems*, 35:32928–32941, 2022b.
- Rampášek et al. (2022)
Ladislav Rampášek, Michael Galkin, Vijay Prakash Dwivedi, Anh Tuan Luu, Guy Wolf, and Dominique Beaini.
Recipe for a general, powerful, scalable graph transformer.
*Advances in Neural Information Processing Systems*, 35:14501–14515, 2022.
- Rossi et al. (2020)
Emanuele Rossi, Ben Chambers, Rex Ying, Michael Bronstein, and Federico Monti.
Temporal graph networks for deep learning on dynamic graphs.
In *Proceedings of the 2020 ICML Workshop on Graph Representation Learning and Beyond*, 2020.
URL [https://arxiv.org/abs/2006.10637](https://arxiv.org/abs/2006.10637).
- Rozemberczki et al. (2021)
Benedek Rozemberczki, Paul Scherer, Yixuan He, George Panagopoulos, Alexander Riedel, Maria Sinziana Astefanoaei, Oliver Kiss, Ferenc Béres, Guzmán López, Nicolas Collignon, and Rik Sarkar.
Pytorch geometric temporal: Spatiotemporal signal processing with neural machine learning models.
In Gianluca Demartini, Guido Zuccon, J. Shane Culpepper, Zi Huang, and Hanghang Tong (eds.), *CIKM ’21: The 30th ACM International Conference on Information and Knowledge Management, Virtual Event, Queensland, Australia, November 1 - 5, 2021*, pp. 4564–4573. ACM, 2021.
doi: 10.1145/3459637.3482014.
URL [https://doi.org/10.1145/3459637.3482014](https://doi.org/10.1145/3459637.3482014).
- Sarıgün (2023)
Ahmet Sarıgün.
Graph mixer networks.
*arXiv preprint arXiv:2301.12493*, 2023.
- Sha et al. (2017)
Mo Sha, Yuchen Li, Bingsheng He, and Kian-Lee Tan.
Accelerating dynamic graph analytics on gpus.
*Proceedings of the VLDB Endowment*, 11(1), 2017.
- Shamsi et al. (2022)
Kiarash Shamsi, Friedhelm Victor, Murat Kantarcioglu, Yulia R. Gel, and Cuneyt Gurcan Akcora.
Chartalist: Labeled graph datasets for UTXO and account-based blockchains.
In Sanmi Koyejo, S. Mohamed, A. Agarwal, Danielle Belgrave, K. Cho, and A. Oh (eds.), *Advances in Neural Information Processing Systems 35: Annual Conference on Neural Information Processing Systems 2022, NeurIPS 2022, New Orleans, LA, USA, November 28 - December 9, 2022*, 2022.
URL [http://papers.nips.cc/paper_files/paper/2022/hash/e245189a86310b6667ac633dbb922d50-Abstract-Datasets_and_Benchmarks.html](http://papers.nips.cc/paper_files/paper/2022/hash/e245189a86310b6667ac633dbb922d50-Abstract-Datasets_and_Benchmarks.html).
- Shamsi et al. (2024)
Kiarash Shamsi, Farimah Poursafaei, Shenyang Huang, Tran Gia Bao Ngo, Baris Coskunuzer, and Cuneyt Gurcan Akcora.
Graphpulse: Topological representations for temporal graph property prediction.
In *The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024*. OpenReview.net, 2024.
URL [https://openreview.net/forum?id=DZqic2sPTY](https://openreview.net/forum?id=DZqic2sPTY).
- (42)
Benedict Aaron Tjandra, Federico Barbero, and Michael Bronstein.
Enhancing the expressivity of temporal graph networks through source-target identification, 2024.
*URL https://arxiv. org/abs/2411.03596*.
- Vaswani et al. (2017)
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin.
Attention is all you need.
*Advances in neural information processing systems*, 30, 2017.
- Veličković et al. (2017)
Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio.
Graph attention networks.
*arXiv preprint arXiv:1710.10903*, 2017.
- Wang et al. (2019)
Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma, Lingfan Yu, Yu Gai, et al.
Deep graph library: A graph-centric, highly-performant package for graph neural networks.
*arXiv preprint arXiv:1909.01315*, 2019.
- Wang & Mendis (2024)
Yufeng Wang and Charith Mendis.
Tglite: A lightweight programming framework for continuous-time temporal graph neural networks.
In *Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2*, ASPLOS ’24, pp. 1183–1199, New York, NY, USA, 2024. Association for Computing Machinery.
ISBN 9798400703850.
doi: 10.1145/3620665.3640414.
URL [https://doi.org/10.1145/3620665.3640414](https://doi.org/10.1145/3620665.3640414).
- Yoon et al. (2020)
Minji Yoon, Bryan Hooi, Kijung Shin, and Christos Faloutsos.
Fast and accurate anomaly detection in dynamic graphs with a two-pronged approach.
*CoRR*, abs/2011.13085, 2020.
URL [https://arxiv.org/abs/2011.13085](https://arxiv.org/abs/2011.13085).
- You et al. (2022)
Jiaxuan You, Tianyu Du, and Jure Leskovec.
ROLAND: graph learning framework for dynamic graphs.
In Aidong Zhang and Huzefa Rangwala (eds.), *KDD ’22: The 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, Washington, DC, USA, August 14 - 18, 2022*, pp. 2358–2366. ACM, 2022.
doi: 10.1145/3534678.3539300.
URL [https://doi.org/10.1145/3534678.3539300](https://doi.org/10.1145/3534678.3539300).
- Yu et al. (2023a)
Le Yu, Leilei Sun, Bowen Du, and Weifeng Lv.
Towards better dynamic graph learning: New architecture and unified library.
*Advances in Neural Information Processing Systems*, 2023a.
- Yu et al. (2023b)
Le Yu, Leilei Sun, Bowen Du, and Weifeng Lv.
Towards better dynamic graph learning: New architecture and unified library.
*Advances in Neural Information Processing Systems*, 2023b.
- Zhang et al. (2021)
Fan Zhang, Lei Zou, and Yanpeng Yu.
Lpma - an efficient data structure for dynamic graph on gpus.
In Wenjie Zhang, Lei Zou, Zakaria Maamar, and Lu Chen (eds.), *Web Information Systems Engineering – WISE 2021*, pp. 469–484, Cham, 2021. Springer International Publishing.
ISBN 978-3-030-90888-1.
- (52)
Xiaohui Zhang, Yanbo Wang, Xiyuan Wang, and Muhan Zhang.
Efficient neural common neighbor for temporal graph link prediction, 2024.
*URL https://arxiv. org/abs/2406.07926*.
- Zhao et al. (2019)
Ling Zhao, Yujiao Song, Chao Zhang, Yu Liu, Pu Wang, Tao Lin, Min Deng, and Haifeng Li.
T-gcn: A temporal graph convolutional network for traffic prediction.
*IEEE transactions on intelligent transportation systems*, 21(9):3848–3858, 2019.
- Zhou et al. (2022a)
Hongkuan Zhou, Da Zheng, Israt Nisa, Vasileios Ioannidis, Xiang Song, and George Karypis.
TGL: A general framework for temporal GNN training on billion-scale graphs.
*CoRR*, abs/2203.14883, 2022a.
doi: 10.48550/ARXIV.2203.14883.
URL [https://doi.org/10.48550/arXiv.2203.14883](https://doi.org/10.48550/arXiv.2203.14883).
- Zhou et al. (2022b)
Hongkuan Zhou, Da Zheng, Israt Nisa, Vasileios Ioannidis, Xiang Song, and George Karypis.
Tgl: a general framework for temporal gnn training on billion-scale graphs.
*Proc. VLDB Endow.*, 15(8):1572–1580, April 2022b.
ISSN 2150-8097.
doi: 10.14778/3529337.3529342.
URL [https://doi.org/10.14778/3529337.3529342](https://doi.org/10.14778/3529337.3529342).
- Zhou et al. (2023a)
Hongkuan Zhou, Da Zheng, Xiang Song, George Karypis, and Viktor Prasanna.
Disttgl: Distributed memory-based temporal graph neural network training.
In *Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis*, SC ’23, New York, NY, USA, 2023a. Association for Computing Machinery.
ISBN 9798400701092.
doi: 10.1145/3581784.3607056.
URL [https://doi.org/10.1145/3581784.3607056](https://doi.org/10.1145/3581784.3607056).
- Zhou et al. (2023b)
Hongkuan Zhou, Da Zheng, Xiang Song, George Karypis, and Viktor K. Prasanna.
Disttgl: Distributed memory-based temporal graph neural network training.
In Dorian Arnold, Rosa M. Badia, and Kathryn M. Mohror (eds.), *Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, SC 2023, Denver, CO, USA, November 12-17, 2023*, pp. 39:1–39:12. ACM, 2023b.
doi: 10.1145/3581784.3607056.
URL [https://doi.org/10.1145/3581784.3607056](https://doi.org/10.1145/3581784.3607056).

## Appendix A Additional Results

### A.1 Validation Latency Benchmarks

In Table [9](https://arxiv.org/html/2510.07586v1#A1.T9), we report the TGB validation evaluation time per epoch for TGM and other libraries. Note that TGM supports highly optimized evaluation time for the robust TGB link prediction evaluation when compared to DyGLib. TGM consistently outperforms the widely used research library DyGLib across datasets and models. TGLite and TGL do not support the one-vs-many TGB-based link prediction evaluation  (Gastinger et al., 2024).

**Table 9: Validation time per epoch (seconds, ↓) for link property prediction (top) and node property prediction (bottom). The first and second best results are highlighted (✕ marks unsupported). OOT indicates that a single validation epoch did not complete after 3 hours.**
| Model | Wikipedia | Reddit | LastFM |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| TGM | DyGLib | TGLite | TGL | TGM | DyGLib | TGLite | TGL | TGM | DyGLib | TGLite | TGL |  |
| EdgeBank | 11.08 | 950.05 | ✕ | ✕ | 50.01 | 134.55 | ✕ | ✕ | 223.01 | 470.08 | ✕ | ✕ |
| TGAT | 532.89 | 2898.53 | ✕ | ✕ | 2241.70 | OOT | ✕ | ✕ | 4163.20 | OOT | ✕ | ✕ |
| TGN | 13.84 | 3404.82 | ✕ | ✕ | 60.30 | OOT | ✕ | ✕ | 112.23 | OOT | ✕ | ✕ |
| DyGFormer | 6.97 | 6125.05 | ✕ | ✕ | 1856.78 | OOT | ✕ | ✕ | 3554.252 | OOT | ✕ | ✕ |
| TPNet | 408.91 | ✕ | ✕ | ✕ | 1735.71 | ✕ | ✕ | ✕ | 3308.91 | ✕ | ✕ | ✕ |
| GCLSTM | 11.92 | ✕ | ✕ | ✕ | 51.68 | ✕ | ✕ | ✕ | 110.16 | ✕ | ✕ | ✕ |
| GCN | 11.70 | ✕ | ✕ | ✕ | 50.88 | ✕ | ✕ | ✕ | 102.56 | ✕ | ✕ | ✕ |

### A.2 Peak GPU Usage

Table [A.2](https://arxiv.org/html/2510.07586v1#A1.SS2) shows the peak GPU memory usage of each model across three standard datasets. Lightweight models such as GCN and GCLSTM consume minimal memory, making them efficient choices for resource-constrained environments, whereas larger architectures like GraphMixer and DyGFormer require significantly more GPU memory. This comparison highlights the trade-offs between model size and memory efficiency, providing a practical reference for selecting models in temporal graph learning tasks.

Table: Table 10: Peak GPU memory usage (GB) per model on different datasets.

| Model | Wikipedia | Reddit | LastFM |
| --- | --- | --- | --- |
| TGAT | 0.55 | 0.57 | 0.30 |
| TGN | 0.67 | 0.81 | 0.11 |
| GraphMixer | 2.61 | 2.62 | 2.62 |
| DyGFormer | 1.34 | 1.36 | 1.03 |
| TPNet | 1.37 | 1.47 | 1.15 |
| GCLSTM | 0.01 | 0.18 | 0.07 |
| GCN | 0.01 | 0.09 | 0.05 |

### A.3 CProfiler Model Breakdown

Table [11](https://arxiv.org/html/2510.07586v1#A1.T11) shows a runtime decomposition of TGAT on the LastFM dataset. The largest costs arise from the backward pass (25.8%), model forward (26.5%), and optimizer updates (19.1%), together accounting for over 70% of total runtime. Within data loading (26.5%), hook execution (15.1%) and graph materialization (11.4%) dominate, with the recency sampler alone contributing 13.2%. Inside TGAT forward, attention layers (14.7%) and MLPs (6.0%) form the bulk of computation, while time encoding adds 3.5%. Using a profiler in this way helps researchers and practitioners identify which components are the main bottlenecks and prioritize optimizations accordingly.

**Table 11: Breakdown of TGAT runtime on LastFM dataset.**
| Category | Component | Percent (%) |
| --- | --- | --- |
| Data Loading | Hook execution | 15.09 |
| |-- Recency sampler | 13.19 |  |
| | |-- Get neighbors | 7.76 |  |
| | |-- Update circular buffer | 5.43 |  |
| |-- Other hooks | 1.90 |  |
| Graph materialization | 11.40 |  |
| Model Forward | TGAT forward | 24.20 |
| |-- Attention layers | 14.70 |  |
| |-- MLP layers | 5.96 |  |
| |-- Time encoding | 3.54 |  |
|  | Other forward (decoders) | 2.30 |
| Optimization | Backward pass | 25.80 |
| Optimizer (Adam) | 19.10 |  |
| Loss computation | 0.62 |  |
| Other | - | 1.61 |

### A.4 Correctness Tests

Table [12](https://arxiv.org/html/2510.07586v1#A1.T12) reports validation and MRR performance on Wikipedia for dynamic link property prediction, as well as validation NDCG and test NDCG on Trade for node property prediction. We cross-reference these results with TGB-reported performance and find that all models fall within the expected range. Note that we did not perform hyperparameter optimization, early stopping, or tuning, but instead used the hyperparameters listed in Table [14](https://arxiv.org/html/2510.07586v1#A5.T14).

**Table 12: Performance on Wikipedia and Trade datasets. Numbers are mean $\pm$ std over 3 runs.**
| Category | Model | Wikipedia | Trade |  |  |
| --- | --- | --- | --- | --- | --- |
|  |  | Validation MRR (↑) | Test MRR (↑) | Validation NDCG (↑) | Test NDCG (↑) |
| Baselines | Edgebank | $0.495$ | $0.527$ | — | — |
| P.F. | — | — | $0.860$ | $0.855$ |  |
| DTDG | GCN | $0.465\pm$ 0.013 | $0.410\pm$ 0.019 | 0.670 $\pm$ 0.013 | 0.629 $\pm$ 0.009 |
| GCLSTM | $0.402\pm$ 0.016 | $0.364\pm$ 0.015 | 0.761 $\pm$ 0.003 | 0.692 $\pm$ 0.002 |  |
| TGCN | — | — | $0.515\pm$0.006 | $0.458\pm$ 0.007 |  |
| CTDG | TGAT | $0.380\pm$ 0.013 | $0.322\pm$ 0.013 | — | — |
| TGN | $0.210\pm$ 0.186 | $0.244\pm$ 0.061 | $0.394$ | $0.329$ |  |
| GraphMixer | $0.610\pm$ 0.010 | $0.567\pm$ 0.018 | — | — |  |
| DyGFormer | 0.743 $\pm$ 0.006 | 0.712 $\pm$ 0.009 | $0.386\pm$ 0.0012 | $0.312\pm$ 0.0003 |  |
| TPNet | 0.771 $\pm$ 0.033 | 0.747 $\pm$ 0.037 | — | — |  |

## Appendix B Additional Background: DTDG vs. CTDG

As defined in Section [3](https://arxiv.org/html/2510.07586v1#S3), a temporal graph is a graph whose structure and attributes evolve over time, capturing not only the relationships between entities but also the dynamics of their interactions. Unlike static graphs, which provide a single snapshot of connectivity, temporal graphs represent edges (and sometimes nodes) as time-stamped events or intervals, enabling modelling of when and how relationships form, change, or disappear. Temporal graph neural networks are typically categorized into two types: continuous-time dynamic graph (CTDG) methods and discrete-time dynamic graph (DTDG) methods. Section [B.1](https://arxiv.org/html/2510.07586v1#A2.SS1) and Section [B.2](https://arxiv.org/html/2510.07586v1#A2.SS2) provide further information about common approaches from each category.

### B.1 DTDG methods

DTDG, or snapshot-based methods, take as input a sequence of graph snapshots, each representing the state of the temporal graph at discrete time intervals (e.g., hours or days). These approaches process each snapshot as a whole, typically using a graph learning model, and employ mechanisms to capture temporal dependencies across snapshots.

The majority of DTDG methods consist of two main components: a spatial encoder, commonly GNN-based, and a temporal encoder, usually an RNN or one of its variants. Given a snapshot $G_{i}$, a spatial representation is learned, $Z_{i}=f(V_{i},E_{i})$, where $f$ is a trainable or non-trainable function that takes the graph structure of the current snapshot and returns either node-level representations in $G_{i}$ or a representation of the entire snapshot. GCN (Kipf & Welling, 2017) is used as $f$ in TGCN (Zhao et al., 2019), EvolveGCN (Pareja et al., 2020), and GCLSTM (Chen et al., 2018). In contrast, GraphPulse (Shamsi et al., 2024) encodes a whole-graph representation by extracting topological features from both the original graph $G_{i}$ and a transformed version $G_{i}^{\prime}$, using Topological Data Analysis (TDA). The concatenation of the features from $G_{i}$ and $G_{i}^{\prime}$ serves as the graph-level representation for downstream property prediction tasks.

To capture temporal dependencies across snapshots, an RNN or one of its variants (e.g., GRU or LSTM) is typically employed. These are applied either to the sequence of snapshot representations $Z_{i}$ (Zhao et al., 2019; Chen et al., 2018; Shamsi et al., 2024) or directly to the evolving parameters of the GCN (Pareja et al., 2020).

### B.2 CTDG methods

In contrast, CTDG methods operate on a continuous stream of edges and can make predictions at arbitrary timestamps. They update internal representations incrementally as new interactions arrive, incorporating fresh information into predictions. For computational efficiency, the edge stream is usually partitioned into fixed-size batches, with predictions performed sequentially per batch; once predictions are made, the corresponding edges are revealed to the model. Unlike DTDG methods, CTDG approaches do not rely on snapshots; instead, they maintain evolving node representations and sample temporal neighborhoods around nodes of interest for prediction.

Temporal Message Passing.
The temporal message passing framework is a neighbourhood aggregation scheme which recursively computes a latent representation by forwarding messages to temporal neighbours. Formally, if $\mathcal{N}^{k}(s)$ denotes the k-hop neighbourhood of node $s$ in the dynamic graph $\mathcal{G}$, then the temporal neighbourhood $\mathcal{N}^{k}_{t}(s)$ is given by restricting neighbours to edge events chronologically before time $t$:

$$ $\displaystyle\mathcal{N}^{k}_{t}(s)=\{(s,d,t^{\prime})\in\mathcal{N}^{k}(s):t^{\prime}\leq t\}$ (4) $$

The combination of temporal and topological constraints makes efficient neighbourhood particularly challenging, requiring complex hierarchical data structures and cache-aware programming to sustain high-throughput on GPU stream multiprocessors Zhang et al. (2021); Sha et al. (2017). We bypass the insertion and deletion complexity by assuming the entire graph structure is read-only. Temporal message proceeds by creating and passing messages between such sub-neighorhoods. In particular, messages are created by concatenating embeddings, aggregating embeddings across temporal neighbourhoods, then updating the new hidden representation. Such information flow occurs concurrently for each event in a batch of data.

Time-Encoding and Memory-Based Learning. Time-encoding models use a shift-invariant model $\psi:T\to\mathbb{R}^{d_{t}}$ that maps a real-valued time stamp into a $d_{t}$-dimensional vector (e.g. TGAT da Xu et al. (2020) use time-encoders like Time2Vec Kazemi et al. (2019)). This encoding is then passed through modified self-attention blocks or feedforward layers. Memory-based models, such as TGN Rossi et al. (2020), utilize a fixed-bandwidth memory module that compresses relevant information for each node and updates it over time. EdgeBank Poursafaei et al. (2022a) is a non-parametric, memory-based method that memorizes and predicts new links at test time based on their occurrence in the training data.

## Appendix C Dataset Details

In this work, we conduct experiments on Wikipedia (obtained from the TGB Huang et al. (2023a), where the dataset can be downloaded along with the package from [TGB website](https://tgb.complexdatalab.com/)), Reddit, LastFM, datasets, obtained from Poursafaei et al. (2022b); these can be downloaded from [https://zenodo.org/records/7213796#.Y8QicOzMJB2](https://zenodo.org/records/7213796#.Y8QicOzMJB2).
These datasets span a variety of real-world domains, providing a broad testbed for evaluating temporal graph models.
Detailed information about these datasets are as follows.

- •
Wikipedia is a bipartite interaction network that captures editing activity on Wikipedia over one month. The nodes represent Wikipedia pages and their editors, and the edges indicate timestamped edits. Each edge is associated with a 172-dimensional LIWC feature vector derived from the text.
- •
Reddit models user-subreddit posting behavior over one month. Nodes are users and subreddits, and edges represent posting requests made by users to subreddits, each associated with a timestamp. Each edge is associated with a 172-dimensional LIWC feature vector based on post contents.
- •
LastFM is a bipartite user–item interaction graph where nodes represent users and songs. Edges indicate that a user listened to a particular song at a given time. The dataset includes 1000 users and the 1000 most-listened songs over a one-month period.
This dataset is not attributed.
- •
Trade represents the international agriculture trading network between UN nations from 1986 to 2016. Nodes are countries and edges capture the annual sum of agriculture trade values from one country to another. The task is to predict each nation’s trade proportions in the following year.
- •
Genre is a bipartite, weighted network connecting users to music genres based on listening history. Edges indicate the proportion of a song belonging to a genre that a user listens to, aggregated weekly. The task is to predict user-genre interactions in the next week, capturing evolving user preferences for music recommendation.

**Table 13: Dataset statistics.**
| Dataset | # Nodes | # Edges | # Unique Edges | # Unique Steps | Surprise | Duration |
| --- | --- | --- | --- | --- | --- | --- |
| Wikipedia | 9,227 | 157,474 | 18,257 | 152,757 | 0.108 | 1 month |
| Reddit | 10,984 | 672,447 | 78,516 | 669,065 | 0.069 | 1 month |
| LastFM | 1,980 | 1,293,103 | 154,993 | 1,283,614 | 0.35 | 1 month |
| Trade | 255 | 468,245 | 468,245 | 32 | 0.023 | 30 years |
| Genre | 1,505 | 17,858,395 | 17,858,395 | 133,758 | 0.005 | 1 month |

## Appendix D Temporal Graph Models Supported in TGM

TGM is a research-driven library providing implementations of state-of-the-art temporal graph learning models. At the time of writing, TGM includes the following models:

Persistent Forecast. A simple baseline that predicts the future state of each node or edge by assuming it remains unchanged from the most recent observation. Despite its simplicity, it often serves as a strong baseline for dynamic node property prediction.

EdgeBank. Poursafaei et al. (2022a) Maintains a memory bank of historical edges and uses them to make predictions. By storing and sampling past interactions, EdgeBank leverages temporal patterns without explicit node embedding updates, providing a lightweight but effective approach for dynamic link prediction.

TGAT. da Xu et al. (2020) proposed to model dynamics node representations with TGAT layer, which is a combination of the graph attention mechanism with a time encoding function based on Bochner’s theorem, which provides a continuous functional mapping from time to a vector space. This allows TGAT to efficiently learn from temporal neighbourhood features with the aid of a self-attention mechanism and temporal dependencies encoded by the time encoding function.

TGN. Rossi et al. (2020) proposed an event-based model that is a combination of a memory module, message aggregator, message updater and embedding module. In particular, the memory module maintains evolving memory for each node and updates this memory when the node is observed to be involved in an interaction, which is achieved by a message function, message aggregator, and message updater. Finally, the embedding model is used to compute the representation of nodes.

GCN.(Kipf & Welling, 2017) Standard Graph Convolutional Network applied on static snapshots to encode structural information. Node features are aggregated from neighbors and combined with self-features to produce updated embeddings at each snapshot. When used in temporal settings, GCNs process sequences of snapshots independently or in combination with temporal modules.

GCLSTM. To learn over a sequence of graph snapshots, Chen et al. (2018) proposed an end-to-end model named Graph Convolutional Long Short-Term Memory (GCLSTM) for dynamic link prediction. The LSTM serves as the backbone to capture temporal dependencies across graph snapshots, while a GCN is applied to each snapshot to encode structural dependencies between nodes. Specifically, two GCNs are used to update the hidden state and the cell state of the LSTM, and a multilayer perceptron (MLP) decoder maps the features at the current time step back to the graph space. This design enables GCLSTM to effectively handle both link additions and deletions.

T-GCN. Zhao et al. (2019) integrates GCNs with gated recurrent units to learn node embeddings over sequences of graph snapshots, capturing temporal and structural information jointly.

GraphMixer. (Sarıgün, 2023) A graph adaptation of MLP-Mixer architectures. It alternates between node-wise and feature-wise mixing layers to capture structural correlations across nodes and temporal correlations across features. By stacking multiple mixer layers, GraphMixer can model complex dependencies in dynamic graphs while remaining simple and parameter-efficient.

DyGFormer. Yu et al. (2023a) proposed a Transformer-based architecture for modeling dynamic graphs. DyGFormer consists of two key components: the Neighbour Co-occurrence Encoder and a Transformer. The Neighbour Co-occurrence Encoder leverages the recent first-hop neighbours of the source and destination nodes of an edge to capture correlations and compute relative embeddings. To enhance representation learning, Yu et al. (2023a) further introduced a patching technique that splits the source and destination node features, edge features, time embeddings (computed following TGAT (da Xu et al., 2020)), and relative embeddings into multiple patches. These patches are then fed into the Transformer to generate node representations with respect to an edge.

TPNet. TPNet is composed of two main modules: Node Representation Maintenance and Link Likelihood Computation. Lu et al. (2024b) unifies existing relative encoding methods by introducing temporal walk matrices with an integrated time-decay function. These matrices establish a principled connection between relative encodings and temporal walks, offering a clearer framework for analyzing and designing temporal encodings. The time-decay effect further allows joint modelling of temporal and structural information. Since computing temporal walk matrices directly is computationally and memory intensive, TPNet employs a theoretically grounded random feature propagation mechanism to implicitly approximate and maintain them efficiently.

The TGM team is actively expanding the library to incorporate additional cutting-edge models, including TNCN (Zhang et al.,), DyGMamba (Ding et al., 2024), NAT (Luo & Li, 2022), and TGNv2 (Tjandra et al.,).

## Appendix E Compute Resources and Experiment Details

Compute: Experiments were run on Ubuntu 20.04 with 64 GB RAM, 4 isolated AMD EPYC 7502 CPU cores, and a single 80 GB A100 GPU. Jobs were managed with SLURM to ensure isolated environments and no concurrent interference.

Experiment Details: We use the default TGB splits (Huang et al., 2023a; Gastinger et al., 2024), with hyperparameters listed in Table [14](https://arxiv.org/html/2510.07586v1#A5.T14). For efficiency benchmarks, TGAT and TGN adopt the TGLite configuration (Wang & Mendis, 2024) for fairness. Other libraries were modified only minimally to measure latency, and TGLite/TGL times are taken directly from Fig. 6 of (Wang & Mendis, 2024). All DTDG methods discretized the Trade dataset to yearly snapshots, and the Genre dataset to weekly snapshots.

**Table 14: Hyperparameters used for each model**
| Parameter | Edgebank | TGAT | TGN | GCN | GCLSTM | TGCN | GraphMixer | DyGFormer | TPNet |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Batch Size | 200 | 200 | 200 | 200 | 200 | – | 200 | 200 | 200 |
| Epochs | – | 10 | 30 | 30 | 30 | – | 10 | 5 | 10 |
| Learning Rate | – | 1e-4 | 1e-4 | 1e-3 | 1e-3 | 1e-3 | 2e-4 | 1e-4 | 1e-4 |
| Dropout | – | 0.1 | 0.1 | 0.1 | – | 0.1 | 0.1 | 0.1 | 0.1 |
| # Heads | – | 2 | 2 | – | – | – | – | 2 | – |
| # Neighbors | – | 20 | 10 | – | – | – | 20 | 32 | 32 |
| # Layers | – | 2 | 2 | 2 | 2 | 2 | 2 | 2 | 2 |
| Embedding Dim. | – | 100 | 100 | 128 | 256 | 128 | 128 | 172 | 172 |
| Time Dim. | – | 100 | 100 | – | – | – | 100 | 100 | 100 |
| Memory Dim. | – | – | 100 | – | – | – | – | – | – |
| Node Dim. | – | – | – | 256 | 256 | 256 | 100 | 128 | 128 |
| Sampling | – | Recency | Recency | – | – | – | Recency | Recency | Recency |
| Memory Mode | Unlimited | – | – | – | – | – | – | – | – |
| Time Gap | – | – | – | – | – | – | 2000 | – | – |
| Token Dim. Factor | – | – | – | – | – | – | 0.5 | – | – |
| Channel Dim. Factor | – | – | – | – | – | – | 4.0 | – | – |
| Channel Dim. | – | – | – | – | – | – | – | 50 | – |
| Patch Size | – | – | – | – | – | – | – | 1 | – |
| # Channels | – | – | – | – | – | – | – | 4 | – |
| # RP Layers | – | – | – | – | – | – | – | – | 2 |
| RP Time Decay | – | – | – | – | – | – | – | – | 1e-6 |
| RP Dim | – | – | – | – | – | – | – | – | $\log(|2*E|)$ |

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 6
presentation: 4
questions: Apart from the points discussed above, there are the following minor points:

- Could the authors clarify how hooks differ from standard PyTorch data transformations or DGL message-passing pipelines conceptually?

- The paper mentions “dynamic graph property prediction” as a novel task; could more examples or datasets be shown?

- How does discretization handle overlapping time intervals or missing timestamps in real-world data? Or edges appearing and disappearing within the same time interval.

- Are there guidelines for selecting optimal time granularities, given their strong impact on performance?

- Representing Continuous-Time and Discrete-Time Graphs: A similar idea has been used already in [1], Definition 2 and 3.

[1] A. Longa et al., Graph Neural Networks for Temporal Graphs: State of the Art, Open Challenges, and Opportunities, TMLR (2023)
soundness: 4
strengths: - Unification: Comprehensive integration of CTDG and DTDG models under a single abstraction.

- Technical design and efficiency: The hook-based modularity and vectorized implementation lead to significant computational gains.

- Empirical validation and usability: Extensive benchmarks on multiple datasets and models.
summary: The paper introduces TGM, a modular and efficient open-source library for temporal graph learning. 
It unifies continuous-time and discrete-time dynamic graph paradigms within a single framework, providing native support for time operations, event-driven iteration, and node/edge dynamics. 
TGM uses a _hook_ abstraction to implement flexible composition of temporal graph operations and efficient workflows. 
The experiments show convincing speedups on a broad set of models.
weaknesses: -Limited novelty beyond software engineering: While the framework is well-engineered, the conceptual contribution (e.g., the hook abstraction) is mostly organizational rather than methodological.

- Evaluation scope: The Experiments focus mainly on efficiency and reproducibility; some examples showing directions of possible novel research would strengthen the claim of scientific impact.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. Will the framework be adapted to text-attributed dynamic graphs[1]?

[1] DTGB: A Comprehensive Benchmark for Dynamic Text-Attributed Graphs
soundness: 2
strengths: S1. This paper is generally well-writen and easy to follow.

S2. This paper proposes a clean theoretical unification of CTDG and DTDG via the notion of a native time granularity and a principled discretization operator.

S3. This paper introduces a typed hook formalism with explicit dependency contracts, which makes complex temporal pipelines composable and easier to reason about and test. 

S4. This paper provides a well‑architected system that separates data storage, execution, and model layers. the proposed framework demonstrates broad coverage of tasks and models.
summary: This paper presents a research‑oriented software library that unifies continuous‑time and discrete‑time learning on temporal graphs under one formal and practical framework. The authors introduce a typed hook abstraction for composing common temporal operations, and they formalize time‑granularity conversion via a discretization operator, enabling iteration either by events or by time. The system follows a three‑layer architecture, supports node and edge events, and implements representative models spanning message‑passing, transformer‑based, and snapshot methods. Empirically, TGM reports stronger efficiency  than DyGLib and UTG. It also enables research case studies on dynamic graph properties, snapshot granularity, and batching effects.
weaknesses: W1. This paper’s primary contribution is a software framework. While the system is valuable, the methodological novelty is limited relative to prior unification attempts (e.g., UTG) and existing libraries (e.g., DyGLib), raising questions about the conceptual contributions beyond engineering improvements.

W2. This paper claims to unify CTDG and DTDG approaches, and it indeed provides a conceptual bridge through an event-sequence formulation and discretization operator. However, the empirical section does not yet demonstrate unification beyond efficiency. For example, there is no study comparing a CTDG model and a DTDG model on exactly the same data, tasks, and evaluation protocol.

W3. The coverage of DTDG methods in the library and experiments is limited. The implemented and evaluated snapshot-based models are mainly GCN, GCLSTM, and T-GCN, while stronger or more representative DTDG baselines such as EvolveGCN[1] and DySAT[2] are neither implemented nor evaluated.

W4. The experimental section focuses heavily on efficiency, but it does not verify correctness against the original authors’ official implementations or reported numbers across multiple metrics. As a result, the validity of the re-implemented models cannot be fully confirmed.

W5. This paper lacks empirical comparisons with PyG Temporal[3] and Torch Spatiotemporal[4], two DTDG-oriented libraries that are discussed in the related-work section but not benchmarked in Section 5.

Minor Typos. 

+ "up to 246× than DyGLib" -> "up to 246× faster than DyGLib". 

+ The spelling of behavior and behaviour should be made consistent.

+ Table 8 "first and second are highlighted" -> "First and second best are highlighted"



Reference

[1] EvolveGCN: Evolving Graph Convolutional Networks for Dynamic Graphs

[2] Dynamic Graph Representation Learning via Self-Attention Networks

[3] PyTorch Geometric Temporal: Spatiotemporal Signal Processing with Neural Machine Learning Models

[4] https://github.com/TorchSpatiotemporal/tsl

---

confidence: 4
contribution: 2
initial_rating: 4
presentation: 3
questions: Refer to the paper’s weaknesses.
soundness: 3
strengths: - The paper addresses a timely and relevant problem in dynamic graph learning, where current frameworks lag behind static counterparts (e.g., PyG, DGL) in terms of flexibility, modularity, and computational efficiency.
- The manuscript is well written and clearly structured, providing sufficient context and motivation for the proposed library.
- If properly released and maintained as open-source, TGM could serve as a standard reference library for temporal graph learning research.
- The framework demonstrates substantial efficiency gains across multiple models and tasks, indicating careful engineering and system design.
summary: This paper introduces TGM, a research-oriented library for Temporal Graph Learning (TGL) 
that supports both continuous-time (CTDG) and discrete-time (DTDG) dynamic graphs within a single modular system. 
The library proposes a formal unification of both paradigms via the notion of graph discretization and time granularity. 
TGM supports link-, node-, and graph-level tasks and demostrantes significant efficiency gains over prior libraries such as DyGLib and UTG.
weaknesses: - The empirical section primarily focuses on efficiency metrics and new results on CTDG tasks solved using DTDG-based models. However, these results offer limited analysis of performance in comparison with prior libraries and existing literature.
- Some aspects are insufficiently detailed:
    1) It is not clear whether experiments across libraries use identical data splits, hyperparameters, preprocessing, etc.
    2) The paper does not clearly explain how batches are processed, specifically, whether events or snapshots within a batch are handled in parallel or sequentially, and if parallel processing is used, if temporal causality is preserved.
    3) The treatment of deletion events (e.g., node removal) is not detailed in the paper.
    4) It is unclear if irregularly sampled snapshot-based tasks (e.g., as in [4,5]) can be processed within TGM.
- TGM currently implements tasks for CTDGs and enables DTDG models to operate on these tasks. However, the TGL community would greatly benefit if TGM also supported tasks specifically designed for DTDGs, such as Metr-LA and Pems-Bay [6], making it a truly unified library that facilitates research across both CTDG and DTDG paradigms.
- When evaluating DTDG-based models, the authors should include comparisons against dedicated DTDG frameworks, such as Torch Spatiotemporal or PyTorch Geometric Temporal, to reduce the large number of unsupported baselines reported in Tables 3, 4, and 9.
- The unified conceptual view connecting CTDGs and DTDGs is interesting; however, the theoretical relationship between these two temporal graph paradigms has already been discussed in prior works, including [1, 2, 3].
  Although not implemented in a general-purpose library, these contributions should be properly acknowledged in the manuscript.
- Given the growing interest on long-range information propagation and oversquashing in temporal GNNs [7], the authors should consider including CTAN [8], a model specifically designed to address this problem, within the TGM. This addition would further broaden the TGM's coverage and enhance its utility for research on novel temporal GNN architectures.

-----

[1] [Representation Learning for Dynamic Graphs: A Survey. JMLR 2020](https://jmlr.csail.mit.edu/papers/volume21/19-447/19-447.pdf)

[2] [Deep learning for dynamic graphs: models and benchmarks. IEEE TNNLS 2024](https://ieeexplore.ieee.org/document/10490120)

[3] [Graph neural networks for temporal graphs: State of the art, open challenges, and opportunities. TMLR 2023](https://openreview.net/pdf?id=pHCdMat0gI)

[4] [Graph Neural Controlled Differential Equations for Traffic Forecasting. AAAI 2022](https://cdn.aaai.org/ojs/20587/20587-13-24600-1-2-20220628.pdf)

[5] [Temporal Graph ODEs for Irregularly-Sampled Time Series. IJCAI 2024](https://www.ijcai.org/proceedings/2024/0445.pdf)

[6] [Diffusion Convolutional Recurrent Neural Network: Data-Driven Traffic Forecasting. ICLR 2018](https://arxiv.org/abs/1707.01926)

[7] [Over-squashing in Spatiotemporal Graph Neural Networks. 2025](https://arxiv.org/pdf/2506.15507)

[8] [Long Range Propagation on Continuous-Time Dynamic Graphs. ICML 2024](https://openreview.net/pdf?id=gVg8V9isul)

---

confidence: 4
contribution: 4
initial_rating: 6
presentation: 2
questions: See weaknesses.
soundness: 3
strengths: The proposed library is timely and represents a valuable contribution to the field of temporal graph learning. It offers a convenient experimental infrastructure and a fair evaluation platform that can accelerate research progress. Compared with existing libraries, it appears more general and efficient, and it provides a diverse collection of datasets and methods to facilitate easy and consistent comparison across studies.
summary: This paper introduces a new library for temporal graph learning that unifies CTDG and DTDG, supporting a wide range of tasks and methods efficiently. The work includes several novel components, notably the unification of CTDG and DTDG and the hook management mechanism for obtaining training features. Its modular design is well-conceived and will allow researchers to easily develop, extend, and evaluate new methods.
weaknesses: W1. My primary concern lies in the writing. First, while the authors emphasize the efficiency of TGM, the paper lacks a detailed explanation or analysis clarifying why TGM is more efficient than existing methods. Second, Section 3 spans nearly two pages but presents multiple items in a disconnected manner, making it difficult to follow the logical flow of ideas.

W2. I also noticed that a prior study, TGB-Seq, introduced several new datasets and integrated them into DyGLib. It would be better if the authors could incorporate the TGB-Seq datasets into TGM as well, since these datasets have been widely adopted in recent research.


Decision: Accept (Poster)