GraphBLAS Pointers

Notation:

• :star: if you're new to GraphBLAS, check out these pointers first
• :hammer: theory-focused
• :wrench: implementation-focused
• :hammer_and_wrench: mix of theory and implementation
• :book: detailed specification

Community sites

• :bird: GraphBLAS Twitter page
• GraphBLAS.org
• HPC Graph Analysis

Selected readings and presentations

• :star: GraphBLAS Wikipedia page
• :star: :movie_camera: Graph Analytics: A Foundational Building Block for the Data Analytics World, Tim Mattson, Henry Gabb (2020)
• :star: Introduction to GraphBLAS: A linear algebraic approach for concise, portable, and high-performance graph algorithms by Gábor Szárnyas

GraphBLAS design papers

• :hammer: Standards for graph algorithm primitives (HPEC 2013) by Tim Mattson et al.
• :hammer: Graphs, Matrices, and the GraphBLAS: Seven Good Reasons (ICCS 2015) by Jeremy Kepner et al.
• :hammer: :star: Mathematical Foundations of the GraphBLAS (HPEC 2016) by Jeremy Kepner et al.
  • Extended version: GraphBLAS Mathematics - Provisional Release 1.0 (2017)
• :hammer_and_wrench: Design of the GraphBLAS API for C (GABB @ IPDPS 2017) by Aydın Buluç et al.
• :hammer_and_wrench: GraphBLAS C API: Ideas for future versions of the specification (HPEC 2017) by Tim Mattson et al.
• :wrench: Implementing the GraphBLAS C API (GABB @ IPDPS 2018) by José E. Moreira, Manoj Kumar, William P. Horn
• :hammer: Mathematics of Digital Hyperspace (GrAPL @ IPDPS 2020) by Jeremy Kepner et al., introducing the definition of semilinks

Tutorials

• :hammer: GraphBLAS tutorials (GitHub organization)
• :hammer: :star: Introduction to GraphBLAS: A linear algebraic approach for concise, portable, and high-performance graph algorithms by Gábor Szárnyas: a tutorial with 180+ slides
  • :movie_camera: Talk at FOSDEM 2020's HPC room (abridged version)
  • Case studies, algorithms, and other slide decks
• :hammer_and_wrench: :star: Hands-on tutorial for GraphBLAS (HPEC 2018-) by Scott McMillan and Tim Mattson
  • latest version presented at SIAM CSE 2021
• :wrench: :star: Introduction to GraphBLAS with Python (2019) by Michel Pelletier
• :hammer: The Algebraic Path Problem: Semirings by Fred Hamprecht at the HCI of Heidelberg University (2020)

Specifications

• :hammer_and_wrench: :book: The GraphBLAS C API Specification, v2.0.0 by Benjamin Brock, Aydın Buluç, Timothy Mattson, Scott McMillan, and José Moreira
• :hammer_and_wrench: :book: The GraphBLAS C API Specification, v1.3.0 by Aydın Buluç, Tim Mattson, Scott McMillan, José Moreira, Carl Yang
  • Summary paper: Design of the GraphBLAS API for C (GABB @ IPDPS 2017)
  • Proposals to the GraphBLAS specification
• Introduction to GraphBLAS 2.0 (GrAPL @ IPDPS 2021) by Benjamin Brock et al.
• :hammer_and_wrench: :book: SuiteSparse:GraphBLAS User Guide by Tim Davis

Algorithms

• :wrench: :star: LAGraph – A library of algorithms for GraphBLAS, similar to LAPACK for BLAS
  • Repository on GitHub
  • LAGraph Working Group: Public document and planning repository for the LAGraph Working Group
  • LAGraph: A Community Effort to Collect Graph Algorithms Built on Top of the GraphBLAS (GrAPL @ IPDPS 2019) by Tim Mattson et al.
  • LAGraph: Linear Algebra, Network Analysis Libraries, and the Study of Graph Algorithms (GrAPL @ IPDPS 2021) by Gábor Szárnyas et al.
  • Intel Generic Implementation of LAGraph for Go, a port implemented in Go
• :wrench: graphblas-algorithms - A library of algorithms written using python-graphblas
  • Repository on GitHub

Generic

• :hammer_and_wrench: Delayed Asynchronous Iterative Graph Algorithms (HPEC 2021) by Mark P. Blanco, , Scott McMillan, and Tze Meng Low
• :hammer_and_wrench: Large-scale graph representation learning and computational biology through sparse matrices (NJIT Data Science Seminar Series, 2021 by Aydın Buluç
• :wrench: Parallel GraphBLAS with OpenMP (SIAM Workshop on Combinatorial Scientific Computing, CSC 2020) by Mohsen Aznaveh et al.
• :hammer: GraphBLAS: Handling performance concerns in large graph analytics (Computing Frontiers 2018) by Manoj Kumar, José Moreira, Pratap Pattnaik
• Many algorithms are described as an example in the specification and in papers about frameworks:
  • The specification has BFS (levels/parents), betwenness centrality, maximal independent set (Luby's algorithm) and triangle count
  • The GraphBLAS CF paper has deep neural network (feed-forward pass), betweenness centrality and PageRank.
  • The SuiteSparse TOMS paper has BFS and maximal independent set (Luby's algorithm).
  • The GraphBLAS Template Library has many textbook algorithms including maxflow and minimum spanning tree (Prim's).
  • LAGraph has many algorithms including community detection using label propagation and an SCC algorithm.
  • BFS algorithm computing the DAG of the traversal

Traversals, max-flow, and shortest paths

• Multicore Max-Flow using GraphBLAS: A Usability Study (Norsk informatikkonferanse 2021) by Zawadi Svela and Anne C. Elster
  • Usability Study of GraphBLAS Through MulticoreMax-Flow (Master's thesis, Norwegian University of Science and Technology, 2021) by Zawadi Berg Svela
• :hammer_and_wrench: [BFS] Optimal algebraic Breadth-First Search for sparse graphs (preprint, 2019) by Paul Burkhardt
• :hammer_and_wrench: [BFS] Implementing Push-Pull Efficiently in GraphBLAS (ICPP 2018) by Carl Yang, Aydın Buluç, John D. Owens
  • This paper forms the basis of Chapter 5 in Carl Yang's PhD thesis, High-Performance Linear Algebra-based Graph Framework on the GPU (2019). The figures in the conference paper have some coloring issues that have been amended in the thesis.
• :hammer_and_wrench: [BFS] A GraphBLAS solution to the SIGMOD 2014 Programming Contest using multi-source BFS (HPEC 2020) by Márton Elekes et al.
  • Presentation
• :hammer: [DFS] Linear Algebraic Depth-First Search (ARRAY workshop @ PLDI 2019) by Daniele G. Spampinato et al.
  • :movie_camera: Video
• :hammer_and_wrench: [SSSP] Delta-Stepping SSSP: From Vertices and Edges to GraphBLAS Implementations (GrAPL @ IPDPS 2019) by Upasana Sridhar et al.
  • In its Preliminaries section, this paper contains the translation of a few vertex-centric and edge-centric design patterns to linear algebra.

Connected components

• :hammer_and_wrench: [CC] Parallel algorithms for finding connected components using linear algebra (Journal of Parallel and Distributed Computing 2020) by Yongzhe Zhang, Ariful Azad, Aydın Buluç
• :hammer_and_wrench: [CC] FastSV: A Distributed-Memory Connected Component Algorithm with Fast Convergence (PP 2020) by Yongzhe Zhang, Ariful Azad, Zhenjiang Hu
• :hammer_and_wrench: [CC] LACC: A Linear-Algebraic Algorithm for Finding Connected Components in Distributed Memory (IPDPS 2019) by Ariful Azad and Aydın Buluç

Triangle counting, k-truss, clustering coefficient, etc.

• :wrench: Graph algorithms via SuiteSparse:GraphBLAS: Triangle counting and K-truss (HPEC 2018) by Tim Davis
• :hammer_and_wrench: Tze Meng Low et al.'s work on triangle counting:
  • First look: Linear algebra-based triangle counting without matrix multiplication (HPEC 2017) by Tze Meng Low et al.
  • A Family of Provably Correct Algorithms for Exact Triangle Counting (Correctness @ SC 2017) by Matthew Lee and Tze Meng Low
    • Presentation
  • Linear Algebraic Formulation of Edge-centric K-truss Algorithms with Adjacency Matrices (HPEC 2018) by Tze Meng Low et al.
• :hammer: Parallel Triangle Counting and Enumeration Using Matrix Algebra (GABB @ IPDPS 2015) by Ariful Azad, Aydın Buluç, John R. Gilbert
  • This paper introduced masked matrix multiplication which became an important primitive in GraphBLAS.
• :hammer: A task-based linear algebra building blocks approach for scalable graph analytics (HPEC 2015) by Michael M. Wolf, Jonathan W. Berry, Dylan T. Stark
  • Related presentation: Task Parallel Approach to the Linear Algebra-Based Implementation of miniTri (SIAM Annual Meeting 2016) by Michael M. Wolf
  • Related presentation: Fast Linear Algebra-Based Triangle Counting with KokkosKernels (IEEE HPEC/DARPA/Amazon Graph Challenge at HPEC 2017) by Michael Wolf et al.
• :hammer_and_wrench: A GraphBLAS Implementation of Triangle Centrality by Fuhuan Li, David A. Bader
• :hammer_and_wrench: The GraphBLAS in Julia and Python: the PageRank and Triangle Centralities (HPEC 2021) by Michel Pelletier et al.
• The K-Core Decomposition Algorithm Under the Framework of GraphBLAS (HPEC 2021) by Longlong Li et al.
• A GraphBLAS Implementation of Triangle Centrality (HPEC 2021) by Fuhuan Li and David A. Bader

Formal language constarined path querying

Regular path querying (RPQ)

• :hammer_and_wrench: Single-Source Regular Path Querying in Terms of Linear Algebra (LSGDA-2025) by Georgiy Belyanin et al.

Context-free path querying (CFPQ)

• :hammer_and_wrench: Universal High-Performance CFL-Reachability via Matrix Multiplication (SOAP-2025) by Ilia Muravev and Semyon Grigorev
• :hammer_and_wrench: Context-Free Path Querying with Single-Path Semantics by Matrix Multiplication (GRADES-NDA 2020) by Arseniy Terekhov et al.
• :hammer_and_wrench: Context-Free Path Querying by Kronecker Product (ADBIS 2020) by Egor Orachev et al.
• :hammer: Path Querying with Conjunctive Grammars by Matrix Multiplication (Programming and Computer Software 2019) by Rustam Azimov and Semyon Grigorev
• :wrench: CFPQ algorithm implementations using pygraphblas

Community detection

• :hammer_and_wrench: Linear Algebraic Louvain Method in Python (GrAPL 2020) by Tze Meng Low et al.
  • :movie_camera: Video
  • pygraphblas implementation

Other

• :wrench: GraphLily: Accelerating Graph Linear Algebra on HBM-Equipped FPGAs (ICCAD 2021) by Yuwei Hu et al.
  • Presentation
  • :movie_camera: Video
• :hammer_and_wrench: A GraphBLAS Approach for Subgraph Counting (preprint) by Langshi Chen et al.
• :hammer_and_wrench: Write Quick, Run Fast: Sparse Deep Neural Network in 20 Minutes of Development Time via SuiteSparse:GraphBLAS (HPEC 2019) by Tim Davis, Mohsen Aznaveh, Scott P. Kolodziej
• :hammer_and_wrench: Graph Coloring on the GPU (GrAPL 2019) by Muhammad Osama et al.

Presentations

Overviews on GraphBLAS and linear algebra-based graph processing

• :hammer: :star: Gábor Szárnyas: GraphBLAS: A linear algebraic approach for high-performance graph algorithms (introduction to GraphBLAS, 100+ slides), :movie_camera: Talk at FOSDEM 2020's HPC room (abridged version)
• :hammer: :star: Jeremy Kepner: Mathematical Foundations of the GraphBLAS and Big Data (SIAM Minisymposium 2020 on Linear Algebraic Tools for Graph Computation) :movie_camera: Video
• John R. Gilbert's talks:
  • :hammer_and_wrench: :star: GraphBLAS: Graph Algorithms in the Language of Linear Algebra (2019)
  • :hammer: Graph Algorithms in the Language of Linear Algebra: How did we get here, where do we go next? (GABB @ IPDPS 2018)
  • :hammer_and_wrench: Building Blocks for Graph Algorithms in the Language of Linear Algebra (CIMI Workshop on Innovative Clustering Methods 2015)
  • :hammer_and_wrench: Graph Algorithms in the Language of Linear Algebra (originally at Intel Non-Numeric Computing Workshop 2014)
• Scott McMillan's talks:
  • :hammer_and_wrench: :star: Graph Algorithms on Future Architectures (CMU SEI Research Review 2015), :scroll: Poster, :movie_camera: Video
  • :hammer_and_wrench: GraphBLAS: A Programming Specification for Graph Analysis (SEI Research Review 2016), :scroll:Poster
  • :hammer_and_wrench: Design and Implementation of the GraphBLAS Template Library (GBTL) (SIAM Annual Meeting 2016)
  • :hammer_and_wrench: Automated Code Generation for High-Performance, Future-Compatible Graph Libraries (SEI Research Review 2017), :scroll: Poster, :movie_camera: Video
  • :hammer_and_wrench: GraphBLAS Updates, SC BoF: HPC Graph Toolkits and GraphBLAS Forum, 2019
• Aydın Buluç's talks:
  • :hammer_and_wrench: Sparse Matrices Beyond Solvers: Graphs, Biology, and Machine Learning (MIT CSAIL Fast Code Seminar, June 22 2020), :movie_camera: Video
  • :hammer_and_wrench: GraphBLAST: A high-performance C++ GPU library implementing GraphBLAS (ECP Annual Meeting 2020)
  • :hammer_and_wrench: Graph algorithms, computational motifs, and GraphBLAS (ECP Annual Meeting 2018)
  • :wrench: Concepts in the GraphBLAS C API (2017)
  • :hammer: Parallel Algorithms across the GraphBLAS Stack (ACS HPC and Data Analytics Workshop 2017) co-authored by Ariful Azad
  • :hammer: Faster parallel GraphBLAS kernels (EECS, UC Berkeley, 2016)
  • The Graph BLAS effort and its implications for Exascale (SIAM Workshop on Exascale Applied Mathematics Challenges and Opportunities, 2014)
• :hammer_and_wrench: Task Parallel Approach to the Linear Algebra-Based Implementation of miniTri Michael Wolf (SIAM Annual Meeting, 2016) by Michael Wolf
• Albert-Jan Yzelman's talks:
  • :hammer_and_wrench: A foundational communication layer and a linear algebraic programming methodology (2019)
  • :hammer_and_wrench: Efficient sparse matrix computations and their generalization to graph computing applications (Linked Data Benchmark Council, Technical User Community meeting, 2017)
• Tim Davis' talks:
  • :hammer_and_wrench: SuiteSparse:GraphBLAS: Graph algorithms via sparse matrix operations on semirings (Sparse Days @ CERFACS 2017)
  • :hammer_and_wrench: SuiteSparse:GraphBLAS, a Parallel Implementation of the GraphBLAS Specification (SIAM Minisymposium 2020 on Linear Algebraic Tools for Graph Computation) :movie_camera: Video
• :hammer_and_wrench: Multiplex graph analysis with GraphBLAS (Graph Developer room @ FOSDEM 2019) by Gábor Szárnyas

Minisymposium at SIAM CSE'21: GraphBLAS: Tools, Algorithms, and Applications

• :hammer_and_wrench: Sparse Matrices for Scaling Data-Intensive Problems on Distributed-Memory Systems by Aydın Buluç
• :wrench: SuiteSparse:GraphBLAS, a Parallel Implementation of the GraphBLAS API by Tim Davis
• :wrench: LAGraph: Graph Algorithms as Linear Algebra by Scott McMillan
• :hammer_and_wrench: Vertex Centric and/or GraphBLAS – Why Choose One? by Roger Pearce
• :wrench: Introduction to pygraphblas by Michel Pelletier
• :hammer_and_wrench: Bandwidth-Optimized Algorithms for Sparse Matrix-Matrix Multiplication by Ariful Azad
• :wrench: High-Performance Sparse Linear Algebra on NVIDIA GPUs with cuSPARSE by Federico Busato
• :hammer_and_wrench: F-Dbscan: Fusing Dbscan with Accelerated Tree Traversal on GPUs by Andrey Prokopenko
• :hammer_and_wrench: Implementing GraphBLAS Primitives on Distributed-Memory Systems by Ben Brock
• :hammer_and_wrench: Dense Semiring Linear Algebra on Modern CUDA Hardware by Vijay Thakkar

Books

• Graph Algorithms in the Language of Linear Algebra (SIAM, 2011) by Jeremy Kepner and John R. Gilbert
  • This is the best reference on the topic of linear algebra-based graph processing. However, note that GraphBLAS effort was not yet started when this book was written. Therefore, there are some differences between the notation of GraphBLAS documents and the one used in this book.
• Mathematics of Big Data: Spreadsheets, Databases, Matrices, and Graphs (MIT Press, 2018) by Jeremy Kepner and Hayden Jananthan
  • An updated version of paper Mathematical Foundations of the GraphBLAS is reprinted in this book (Chapter 6, p81-113)
  • This book is currently the latest detailed reference on semiring-based computations, including graph algorithms. It also covers many other topics such as associative arrays. The book is not intended to be a GraphBLAS reference, but it can be used for providing a background in linear algebra (see e.g. Chapter 8, "Visualizing the Algebra of Associative Arrays").
• Path Problems in Networks (Morgan & Claypool Publishers, 2010) by John S. Baras and George Theodorakopoulos.
  • This book is about the algebraic path problem – a semiring-based generalization of shortest path problem. The mathematical foundations of semiring-based graph analysis are described. Basic ideas to create new semirings to solve new problems are described.
  • The section 3.1 "Alternative viewpoints: paths and matrices" (p17-19) provides a matrix-based framework for the algebraic path problem which is highly relevant to GraphBLAS.
  • The table on pages 58-59 contains 29 different semirings and respective applied problems.

Implementations

Core implementations

• SuiteSparse:GraphBLAS
  • GitHub repository
  • :hammer_and_wrench: Algorithm 1000: SuiteSparse:GraphBLAS: Graph algorithms in the language of sparse linear algebra, preprint, (ACM Transactions on Mathematical Software, 2019) by Tim Davis
  • The SuiteSparse:GraphBLAS library is released both as an individual package and (less frequently) as part of SuiteSparse.
  • This library can be installed on Debian-based distributions with the libsuitesparse-dev package. For example, Ubuntu 20.04's default repository contains SuiteSparse:GraphBLAS 3.2.0.
• GraphBLAS Template Library (GBTL): C++ implementation (version 3.0 has been released in June 2020)
  • GraphBLAS: Building a C++ Matrix API for Graph Algorithms (CppCon 2021) by Benjamin Brock and Scott McMillan
• GraphBLAST
  • GraphBLAST: A High-Performance Linear Algebra-based Graph Framework on the GPU, preprint by Carl Yang, Aydın Buluç, John D. Owens
  • High-Performance Linear Algebra-based Graph Framework on the GPU (PhD dissertation, 2019) by Carl Yang

Other implementations

• Huawei's GraphBLAS implementation: C++ implementation
  • gitee mirror
• IBM GraphBLAS: C++ implementation in approx. 6000 lines of code.
• GraphBLAS C99: "C99 prototype implementation of enough of GraphBLAS standard to run first two examples in Appendix A of the standard." Consists of <800 lines of code. Only supports vxm.
• GraphMat: linear algebra-based graph analytics framework prototype by Intel
  • GraphMat: High performance graph analytics made productive (VLDB 2015) by Narayanan Sundaram
  • GraphPad: Optimized Graph Primitives for Parallel and Distributed Platforms (IPDPS 2016) by Michael J. Anderson et al.
• EJML (Efficient Java Matrix Library): partial Java implementation
  • :wrench: A GraphBLAS implementation in pure Java (GRADES-NDA 2021) by Florentin Dörre et al.
• Introducing Lucata's GraphBLAS by Jason Riedy and Shannon Kuntz (SlideShare)
• Bit-GraphBLAS: Bit-Level Optimizations of Matrix-Centric Graph Processing on GPU (IPDPS 2022) by Jou-An Chen et al.
• spla is a generalized sparse linear algebra library with GPU-accelerated computations. C++ and OpenCL implementation. The library is vendor-agnostic: it can utilize GPUs by nvidia, Intel, AMD.
  • Source code
  • Generalized sparse linear algebra library with vendor-agnostic GPUs acceleration (master thesis, 2023) by Egor Orachev

Wrappers

• Python wrappers:
  • :star: pygraphblas: a Python wrapper for SuiteSparse:GraphBLAS aiming to provide a Pythonic API
    • GraphBLAS Programmability: Python and MATLAB Interfaces by Tim Mattson, Michel Pelletier, Tim Davis (preprint)
  • :star: python-graphblas: a Python wrapper for SuiteSparse:GraphBLAS with high-level syntax that adheres closely to the mathematical abstractions of GraphBLAS with natural syntax for masks, transpose descriptors, etc.
    • User Guide with API Reference
    • This library and all dependencies can be installed from conda-forge for Linux, macOS, and Windows
    • conda-forge also has standalone SuiteSparse:GraphBLAS packages for Linux, macOS and Windows
  • dask-grblas: mirrors the python-graphblas API and uses dask for out-of-core or distributed computation
  • PyGB: a Python wrapper for GBTL
• Intel Generic Implementation of GraphBLAS for Go - a Go binding for SuiteSparse:GraphBLAS
• SuiteSparseGraphBLAS.jl: a Julia wrapper for SuiteSparse:GraphBLAS
• rustgraphblas: a Rust wrapper
• graphblas-java-native: a Java wrapper
  • artifact at the Maven Central
• MATLAB wrapper: built-in for SuiteSparse:GraphBLAS
• Docker containers on Docker Hub

See also the ongoing design of the GraphBLAS C++ API and its rgri reference implementation.

Related libraries

• Graphony: a Python library for doing high-performance graph analysis using the GraphBLAS over sparse and hypersparse data sets. It uses pygraphblas to store graph data in sparse GraphBLAS matrices and node and edge properties in PostgreSQL.
• FalkorDB: a graph database that uses GraphBLAS under the hood for its sparse adjacency matrix graph.
  • Note: Several developers of FalkorDB originally worked on RedisGraph which was also powered by GraphBLAS.
• Graphulo (built for Apache Accumulo)
  • More pointers below
• D4M
  • Repository
  • D4M.jl: Julia implementation
  • D4M.py: Python implementation
• pggraphblas: Postgres extension for using GraphBLAS
• Combinatorial BLAS (CombBLAS): "An extensible distributed-memory library offering a small but powerful set of linear algebraic operations specifically targeting graph analytics." Influences the development of GraphBLAS.
  • Aydın Buluç, John R. Gilbert: The Combinatorial BLAS: design, implementation, and applications, Int. J. High Perform. Comput. Appl. 2011 (paper entry at the publisher's site). This paper is referred to as a "strawman proposal" on GraphBLAS.org
  • Documentation
  • Presentation
• Viral B. Shah, Alan Edelman, Stefan Karpinski, Jeff Bezanson, Jeremy Kepner: Novel algebras for advanced analytics in Julia, HPEC 2013
  • Repository
• A Hybrid GraphBLAS in C++11: specification, design, implementation, and performance (a work-in-progress distributed C++11 GraphBLAS implementation)
  • A C++ GraphBLAS: specification, implementation, parallelisation, and evaluation (preprint 2020) by Albert-Jan Yzelman et al.
  • Nonblocking execution in GraphBLAS (GrAPL 2022)
  • Design and implementation for nonblocking execution in GraphBLAS: tradeoffs and performance by Aristeidis Mastoras et al., ACM Transactions on Architecture and Code Optimization, 2022
  • Poster by Albert-Jan Yzelman and W. J. Suijlen

FalkorDB

• FalkorDB

RedisGraph

• Deep Dive into RedisGraph (RedisConf 2019) by Roi Lipman
  • Presentation
• Lower Latency Graph Queries in Cypher with Redis Graph (RedisConf 2018) by Roi Lipman and Tim Davis
  • GraphBLAS section
  • Presentation
• Evaluating Cypher queries and procedures as algebraic operations within RedisGraph (12th LDBC TUC, 2019) by Roi Lipman

Graphulo

• Graphulo: Graph Analytics in Apache Accumulo (Accumulo Summit 2016) by Vijay Gadepally, Timothy Weale, Dylan Hutchison, Jeremy Kepner
• Interacting with Accumulo and Graphulo using Julia/Python D4M (Accumulo Summit 2018) by Lauren Milechin, Hayden Jananthan, Vijay Gadepally, Jeremy Kepner
• Accumulo and the Convergence of Machine Learning, Big Data, and Supercomputing (Accumulo Summit 2017) by Jeremy Kepner
• Server-side Sparse Matrix Multiply in the Accumulo Database (HPEC 2015) by Dylan Hutchison, Jeremy Kepner, Vijay Gadepally, Adam Fuchs
• Using D4M for rapid prototyping of analytics for Apache Accumulo (Accumulo Summit 2015) by Vijay Gadepally, Lauren Edwards, Jeremy Kepner
• Graph Analytics expressed in GraphBLAS (2014) by Jeremy Kepner, Vijay Gadepally, Ben Miller

You can also find many papers, posters, and presentations in the Accumulo repository.

Events

News, interviews, popular science

• GraphBLAS: Building Blocks For High Performance Graph Analytics – Berkeley Lab Researchers Contribute to GraphBLAS and Will Leverage it for Exascale Applications
• ACM's interview with Tim Davis
• First Person: Tim Davis, American Scientist
• The Applications of Matrices | What I wish my teachers told me way earlier (Networks segment) by Zach Star (2019), the section on networks and graph theory start at 15:55
• GraphBLAS and GraphChallenge Advance Network Frontiers by Jeremy Kepner, David A. Bader, Tim Davis, Roger Pearce, and Michael M. Wolf

Typesetting

The nicematrix LaTeX package can be used to typeset block matrices.

• Example TeX code

Related work

• graphblas-verif: Formal verification of the GraphBLAS C API implementation by Tim Davis using Frama-C/WP.
• LA3: A scalable link-and locality-aware linear algebra-based graph analytics system (VLDB 2018) by Yousuf Ahmad et al.
• Efficient Distributed Graph Analytics using Triply Compressed Sparse Format (CLUSTER 2019) by Mohammad Hasanzadeh Mofrad et al.
• Magas: matrix-based asynchronous graph analytics on shared memory systems (Journal of Supercomputing, 2021) by Le Luo et al.
• MAGiQ – a GraphBLAS-based RDF query engine:
  • A Demonstration of MAGiQ: Matrix Algebra Approach for Solving RDF Graph Queries (demo at VLDB 2018) by Fuad Jamour, Ibrahim Abdelaziz, Panos Kalnis
  • Matrix Algebra Framework for Portable, Scalable and Efficient Query Engines for RDF Graphs (EuroSys 2019) by Fuad Jamour, Ibrahim Abdelaziz, Yuanzhao Chen, Panos Kalnis
  • Algorithms and Frameworks for Graph Analytics at Scale (PhD thesis, 2019) by Fuad Jamour
• Parallel and Scalable Sparse Basic Linear Algebra Subprograms (PhD thesis, 2015) by Weifeng Liu
• Density-Aware Linear Algebra in a Column-Oriented In-Memory Database System (PhD thesis, 2016) by David Kernert
• Connection of relational joins (join-project, projected join) and sparse matrix multiplication:
  • A relational approach to the compilation of sparse matrix programs (Euro-Par 1997) by Vladimir Kotlyar et al.
  • Faster join-projects and sparse matrix multiplications (ICDT 2009) by Rasmus Resen Amossen and Rasmus Pagh
  • Fast Join Project Query Evaluation using Matrix Multiplication (SIGMOD 2020) by Shaleen Deep et al.
  • SPORES: Sum-Product Optimization via Relational Equality Saturation for Large Scale Linear Algebra (VLDB 2020) by Yisu Remy Wang et al.
• Semiring Provenance over Graph Databases (USENIX Workshop on the Theory and Practice of Provenance 2018) by Yann Ramusat et al.
• Provenance-Based Algorithms for Rich Queries over Graph Databases (EDBT 2021) by Yann Ramusat et al.
• Querying Sparse Matrices for Information Retrieval (PhD thesis, 2012) by Roberto Cornacchia

Source code

The source of this page is available at https://github.com/GraphBLAS/GraphBLAS-Pointers.