Clojurians Log v2

Jena or RDF4j are both safe bets, in that they’re active and will be around for a long time to come. All graph databases in my experience are pretty memory hungry, and some queries will inevitably risk that. I can’t say much about visualisation features for graph data, other than that I’ve rarely found them useful in practice. graphviz layout algorithms become too big to big to be useful, and force directed graph visualisations rarely seem useful to me.

I think genuinely useful visualisations tend to be heavily curated.

But I guess it depends on what you’re doing.

It’s really all about delivering features in very little development time and keeping the system relatively open for potential future development efforts. The datasets are a couple of wordnets (that will eventually be linked) and the users of the system are academics with soft technical skills. Since this needs to be done purely within the limited budget of a single academic project, any kind of generic user interface will be appreciated — in addition to whatever specialised interface I actually have time to develop. Unfortunately, I have bunch of different requirements to live up to - including periodic synchronisation with an ancient SQL database - and only a few months to do it.

for visualization there's a Gephi SPARQL plugin: https://github.com/gephi/gephi/wiki/SemanticWebImport

if you already have RDF as source, you would just have to write some SPARQL queries

I've been playing with RDF4J quite a bit, it has a pretty nice API. Here's a breadth first search I implemented recently:

fun bfs(start: Resource, maxDepth: Int = 5, statementLimit: Int = 1024) =
        LinkedHashModel().also {
            sparqlDb!!.connection.use { conn ->
                val queue = mutableListOf<Pair<Resource, Int>>(Pair(start, 0))
                val seen = mutableMapOf<Resource, Boolean>()

                while (queue.isNotEmpty() && it.size < statementLimit) {
                    val (next, depth) = queue.removeFirst()

                    if (!seen.containsKey(next)) {
                        for (st in conn.getStatements(next, null, null)) {
                            st.`object`.let { r ->
                                if (r is Resource && depth < maxDepth) queue.add(Pair(r, depth + 1))
                            }
                            it.add(st)
                        }
                    }
                    seen[next] = true
                }
            }
        } 

Kotlin, but you get the idea

I also been eyeing https://github.com/jgrapht/jgrapht. It has a collection of graph algorithms, visualizations, serialization to graphviz and other formats that you could load into gephi, etc.