simongray / clojure-graph-resources

A curated list of Clojure resources for dealing with graph-like data.

Clojure graph resources

This is a curated list of mostly mature and/or actively developed Clojure resources relevant for dealing with graph-like data. It's currently being expanded as I explore this area more thoroughly. Suggestions are welcome in the form of pull requests or Github issues. I try to steer around abandonware, though.

If you're interested in DSLs and parsing, be sure to check out clojure-dsl-resources too.

Data structures / algorithms

• aysylu/loom: Graph library for Clojure.
• Engelberg/ubergraph: An all-purpose Clojure graph data structure that implements Loom protocols and more.
• ont-app/igraph: IGraph defines a protocol which aims to provide a general interface to a variety of graph-based representations.
• totakke/jungerer: Clojure network/graph library wrapping JUNG.
• pangloss/fermor: Fast, powerful, general-purpose graph traversal and modelling tools plus a performant immutable in-memory graph database.
• ekoontz/dag-unify: A Clojure library for combining directed acyclic graphs (DAGs) via unification.
• aroemers/rmap: Clojure library for defining recursive maps; literally, programmatically and with pure data.
• cjsauer/joinery: Enables traversal of in-memory graph-like data structures using Clojure(Script)'s map protocols.

Visualisation

• chrismurrph/show-graph: Translates a particular directed graph data structure (graph with vertices and edges) into a JavaFX view that can be seen from Reveal.
• jebberjeb/specviz: Generate Graphviz images from clojure.spec.
• benedekfazekas/morpheus: Generate dependency graph(s) for variables in Clojure(Script) namespaces.
• jpmonettas/clograms: Clojure[Script] source code diagrams.
• jafingerhut/cljol: Visualise the memory usage of a Java object and all the objects that it references as a graph.

Databases

Labeled-property graph

Labeled-property graph databases use complex graph models where edges and vertices can have both labels and associated properties.

• gorillalabs/neo4j-clj: Clojuresque client to Neo4j database, based upon the bolt protocol.
• full-spectrum/neo4clj: Neo4clj is a idomatic clojure client, exclusivly using Bolt for performance.

RDF + OWL

RDF triplestores are a specialised type of graph database for representing knowledge graphs; part of the W3C Semantic Web standards.

• arachne-framework/aristotle: An RDF/OWL library for Clojure, providing a data-oriented wrapper for Apache Jena.
  • ont-app/igraph-jena: This is a port of the Jena APIs to the IGraph protocol.
• Swirrl/grafter: Linked Data & RDF Manufacturing Tools in Clojure.
  • Swirrl/matcha In-memory, schemaless triplestore with a SPARQL-like DSL.
  • ont-app/igraph-grafter: A port of the IGraph protocols to the Grafter protocols.
• stardog-union/stardog-clj: Clojure language bindings for the proprietary Stardog Graph / RDF Database.
• fluree/db: Fluree is an immutable, temporal, ledger-backed semantic graph database that has a cloud-native architecture.
• fluree/json-ld: A Clojure(script) JSON-LD library.
• yetanalytics/flint: A Clojure(Script) DSL for creating SPARQL query and update strings.
• Swirrl/csv2rdf: Clojure library and application implementing the W3C CSV on the Web tabular metadata specifications for converting CSV to RDF.
• ont-app/vocabulary: Utilities to map between clojure namespaced keywords and RDF-style URIs.
• phillord/tawny-owl: Tawny-OWL allows construction of OWL ontologies, in a evaluative, functional and fully programmatic environment.
  • phillord/owl-primer: The Ontology from the owl-primer written using Tawny-OWL.
• sam_russell/porta-owl-sqwrl: (GITLAB) A Clojure domain-specific language for Web Ontology Language (OWL) and Semantic (Query) Web Rule Language (SQWRL).

Datalog

Clojure's Datomic-like databases also model data as triplets... or in some cases technically as quintuplets AKA datoms. See clojurelog.github.io for a comparison of some of the Datalog database options listed below.

• Datomic.com: (PROPRIETARY) A transactional database with a flexible data model, elastic scaling, and rich queries.
  • vvvvalvalval/datofu: This library provides common utilities for working with Datomic, mostly in the form of database functions.
  • vvvvalvalval/datomock: Mocking and forking Datomic Peer connections in-memory.
  • vvvvalvalval/datalog-rules: Utilities for managing Datalog rulesets from Clojure.
  • avescodes/conformity: A Clojure/Datomic library for idempotently transacting norms into your database.
  • JarrodCTaylor/schema-cartographer: Schema Cartographer provides a means to visualize, navigate, create, edit and share the relationships that exist in your Datomic schema.
  • Provisdom/spectomic: Generate Datomic or Datascript schema from your Clojure(script) specs.
  • ivarref/gen-fn: Generate Datomic function literals from regular Clojure namespaces (on-prem).
  • ivarref/rewriting-history: A library to rewrite Datomic history (on-prem).
  • ivarref/yoltq: An opinionated Datomic queue for building more reliable systems (on-prem).
  • ivarref/double-trouble: Handle duplicate Datomic transactions with ease.
  • ivarref/datomic-schema: Simplified writing of Datomic schemas.
  • ont-app/datomic-client: Ports the Datomic Client to the IGraph protocols.
• tonsky/datascript: An immutable in-memory database and Datalog query engine in Clojure and ClojureScript.
  • mpdairy/posh: Posh is a ClojureScript / React library that lets you use a single DataScript database to store your app state.
  • denistakeda/re-posh: Re-posh allows Posh and re-frame to work together by adding support for re-frame specific subscriptions, events, effects, and co-effects to Posh.
  • metasoarous/datsync: This library offers tools for building DataScript databases as materialized views (very much in the re-frame/samsa sense) of some master/central Datomic database.
  • frankiesardo/minikusari: minikusari is a minimal rule engine built on top of Datascript (and can work with Datomic or Datahike).
  • ont-app/datascript-graph: An implementation of the IGraph protocol extended to datascript.
• mhuebert/re-db: Attempts to be a fast, reactive, client-side triple-store for handling global state in ClojureScript apps, inspired by Datomic/DataScript, working in conjunction with Reagent.
• replikativ/datahike: Datahike is a durable Datalog database powered by an efficient Datalog query engine.
  • replikativ/datahike-frontend: A front-end to Datahike written in Fulcro.
  • lambdaforge/datalog-parser: This parser is used by Datahike and follows the Datalog dialect of Datomic.
• juji-io/datalevin: Datalevin is a simple durable Datalog database.
• quoll/asami: A graph database, for Clojure and ClojureScript.
  • quoll/asami-loom: This library extends Asami in-memory graphs to Loom.
• xtdb/xtdb: XTDB is a general purpose database with graph-oriented bitemporal indexes.
• Workiva/eva: Eva is a distributed database-system implementing an entity-attribute-value data-model that is time-aware, accumulative, and atomically consistent.
• ribelo/doxa: An in-memory datalog database implemented with Meander.
• threatgrid/naga: Datalog based rules engine.
• den1k/nldl: Natural Language for Clojure's Datalog flavor as present in Datomic, Datascript, Datahike etc.

Other

• clojurewerkz/ogre: Ogre is a Clojure Gremlin Language Variant of the Gremlin graph traversal language from Apache Tinkerpop, which is an open source, vendor-agnostic, graph computing framework.
• fern-flower-lab/sqlg-clj: Tinkerpop3 graphs in a relalional database (Sqlg wrapper).
• stuartsierra/mapgraph: Basic in-memory graph database of maps with links.
• den1k/subgraph: Reactive graph database for re-frame; a fork of stuartsierra/mapgraph.
• keechma/keechma-entitydb: EntityDB is a client side database and normalization engine.

Queries

• juxt/pull: Like Datomic pull, but can be used on any map.
• edn-query-language/eql: EQL is a declarative way to make hierarchical (and possibly nested) selections of information about data requirements.
  • souenzzo/eql-style-guide: This guide covers both EQL as an abstract API and common library usage, like fulcro and pathom.
  • wilkerlucio/pathom: Pathom is a Clojure(script) engine for processing EQL requests.
    • wilkerlucio/pathom3: Pathom3 is a redesign of Pathom.
    • jlesquembre/pathom-pedestal: A library to integrate pathom and pedestal.
  • graphqlize/honeyeql: HoneyEQL transforms EQL into efficient SQL.
  • lilactown/pyramid: A library for storing and querying graph data in a Clojure map.
• sixthnormal/pullql: A GraphQL-like query language for DataScript, optimized for execution across many entities at once.
• walkable-server/walkable: A Clojure(script) SQL library for building APIs: Datomic® (GraphQL-ish) pull syntax, data driven configuration, dynamic filtering with relations in mind.
• walmartlabs/lacinia: This library is a full implementation of Facebook's GraphQL specification.
  • vlaaad/plusinia: Solution to N+1 problem in Lacinia.
• graphqlize/graphqlize: A library for creating a GraphQL API for a Postgres or MySQL database.
• timrichardt/hicgql: GraphQL in Clojure data structures.
• ivarref/clj-paginate: Pagination of vectors and maps with Clojure for GraphQL

Miscellaneous

• fulcrologic/fulcro: Fulcro is a full-stack web framework where a single underlying graph acts as the shared data model of both backend and frontend.
• plumatic/plumbing: Plumbing and Graph: the Clojure utility belt. Graph is a simple and declarative way to specify a structured computation, which is easy to analyze, change, compose, and monitor.
• simongray/datalinguist: Stanford CoreNLP in idiomatic Clojure. Support for dependency grammar graphs, pattern matching, and visualisation.
• nwjsmith/generators.graph: test.check generators for graph data.
• jackrusher/mundaneum: A clojure wrapper around WikiData.
• Swirrl/cubiql: A proof of concept GraphQL service for querying Linked Data Cubes.
• esuomi/muotti: A graph-based value transformer library.

Personal knowledge graphs

It is perhaps worth mentioning that several tools have been written in Clojure for making personal knowledge graphs through note-taking. The first one to appear was Roam Research (proprietary). It has since inspired Athens Research (open source, commercial) and Logseq (open source, community-driven). These tools are all based on libraries listed in the Datalog section.

Articles/video

• Open Source Clojure-Datalog Databases
• Domain modeling with Datalog
• Introduction to Asami

Community

RDF has a small, but steady Clojure following. People are using Neo4j with Clojure, but not talking much about it. Datomic-like Datalog databases have the most momentum.

• Clojurians Slack: Where Clojure's most active users seem to hang out.
  • #rdf
  • #datalog
  • #datomic
  • #datascript
  • #datahike
  • #datalevin
  • #xtdb
  • #neo4j - currently dead, but maybe you can make it come alive?

clojure-graph-resources's Issues

Clojure client for Stardog

Great idea! May I suggest

https://github.com/stardog-union/stardog-clj - Clojure language bindings to use to develop apps with the Stardog Graph / RDF Database

New graph implementation to the list

Hi there!

We released recently our Clojure driver for Sqlg. Maybe you would be interested to add it into your list :)
Wanna make it more known and form a community.

https://github.com/fern-flower-lab/sqlg-clj

Thanks.

Denormalized data structures

These are more in the realm of storing data in a denormalized fashion, rather than doing operations on graphs, but still relevant IMO.

https://github.com/stuartsierra/mapgraph (archived but still used / relevant)

https://github.com/keechma/keechma-entitydb

https://github.com/den1k/subgraph a fork of mapgraph that interops with re-frame

There are probably others in this same fashion, those are just the 3 I know off the top of my head.

Consider plumatic/graph

First of all, great idea! Second, I’d like to suggest one of my favorite clj libs, Plumatic Graph.

From Plumbing’s readme :

Graph is a simple and declarative way to specify a structured computation, which is easy to analyze, change, compose, and monitor.

Although it is mostly focused on DAGs to create stream graph computation models, IME it’s a very practical and useful lib.

Graph query benchmarking

The Crux repository maintains a comparative query benchmarking project, most notably including WatDiv ("Waterloo SPARQL Diversity Test Suite") which is an RDF-based suite of "subgraph matching" stress tests that have been adapted to run using Datalog and Cypher also:
https://github.com/juxt/crux/tree/master/crux-bench

The benchmark results are not currently published but the project can be run independently and could be extended to cover the other databases listed.

Add factui to the list

https://github.com/arachne-framework/factui

FactUI is a library for efficiently rendering user interfaces declaratively, based on a tuple-oriented data store.

It uses a datomic-like syntax for rules declaration. and clara-rules underneath. So it feels like datascript + re-posh + rules.

I used it in a project a while back and it worked great with reagent.
Seems abandoned but some great code and ideas to explore in there.

of possible interest

https://github.com/phillord/tawny-owl

https://github.com/phillord/owl-api

https://github.com/phillord/owl-primer

Graph query resources

EDN query language (EQL) is a GraphQL-like language specification: https://github.com/edn-query-language/eql

Pathom is a library which helps with implementing services that provide EQL APIs: https://github.com/wilkerlucio/pathom

Speaking of GraphQL, lacinia is a popular library for implementing GraphQL services: https://github.com/walmartlabs/lacinia