Jelly

Jelly is a high-performance binary serialization format and streaming protocol for RDF knowledge graphs. Jelly has implementations for the JVM (works with Apache Jena, RDF4J, Titanium, and Neo4j) and Python (works with RDFLib).

Stream any RDF data, fast

Jelly is blazing-fast by design, and can work with streams of triples, graphs, datasets, and more.

Getting started
JVM and Python implementations

Fully-integrated support for Apache Jena, RDF4J, Titanium, Neo4j, and RDFLib.

Jelly-JVM

pyjelly
End-to-end streaming

Jelly comes with a gRPC protocol and can work with Kafka, MQTT, and others.

User guide

Streaming with Jelly-JVM
Open specification

Everything is open-source and well-documented to help you get started.

Protocol specification

⚡ Quick start

CLI toolPythonJavaApache Jena pluginRDF4J pluginNeo4j

jelly-cli is a simple tool that lets you convert RDF files to and from Jelly, validate Jelly files, and more.

Install scriptmiseManual download

For Linux, macOS, and WSL on Windows, run:

. <(curl -sSfL https://w3id.org/jelly/setup-cli.sh)
jelly-cli

You can install jelly-cli on any platform (including Windows) using mise. Simply run:

mise use -g 'ubi:Jelly-RDF/cli[exe=jelly-cli]'
jelly-cli

You can also install jelly-cli manually by downloading the latest release, including a version for Windows without WSL and a platform-independent JAR file.

See all available commands and documentation.

Install the pyjelly package with support for RDFLib:

pip install pyjelly[rdflib]

Write an RDF graph to a Jelly file:

from rdflib import Graph

g = Graph()
g.parse("http://xmlns.com/foaf/spec/index.rdf")
g.serialize(destination="foaf.jelly", format="jelly")

Read a Jelly file:

g = Graph()
g.parse("foaf.jelly", format="jelly")

See the full user guide and API reference.

Other integrations (with or without RDFLib) are available, including Neo4j and NetworkX – see the Python user guide.

Jelly-JVM is a super-fast implemention of Jelly, fully integrated with Apache Jena, RDF4J, and Titanium.

To get started, add the following dependency to your pom.xml:

Apache JenaRDF4JTitanium

pom.xml

<dependency>
    <groupId>eu.neverblink.jelly</groupId>
    <artifactId>jelly-jena</artifactId>
    <version>3.5.0</version>
</dependency>

See the full Jena user guide.

pom.xml

<dependency>
    <groupId>eu.neverblink.jelly</groupId>
    <artifactId>jelly-rdf4j</artifactId>
    <version>3.5.0</version>
</dependency>

See the full RDF4J user guide.

pom.xml

<dependency>
    <groupId>eu.neverblink.jelly</groupId>
    <artifactId>jelly-titanium-rdf-api</artifactId>
    <version>3.5.0</version>
</dependency>

See the full Titanium RDF API user guide.

Quickly add Jelly support to your Apache Jena Fuseki server (5.2.0+) or other Jena-based applications:

Download the Jelly plugin JAR (version 3.5.0).
For Apache Jena Fuseki, place the JAR in the $FUSEKI_BASE/extra/ directory. You may need to create this directory.
Start Fuseki and enjoy full support in RDF loading, APIs, SPARQL, and content negotiation.

See the full Jena plugin user guide for more details.

Quickly add Jelly support to your RDF4J applications:

Download the Jelly plugin JAR (version 3.5.0).
For RDF4J SDK, place the JAR in the lib/ directory. For other applications, add the JAR to your classpath.
Start the application and enjoy full Jelly support.

See the full RDF4J plugin user guide for more details.

You can add Jelly support directly to your Neo4j Desktop or self-hosted server (Community / Enterprise Edition) using our plugin. Alternatively, you can use the rdflib-neo4j integration, which is more limited, but also works with AuraDB.

Plugin (Neo4j Desktop and self-hosted server)rdflib-neo4j (AuraDB)

Installation:

Open the Neo4j installation folder.
Download the neosemantics plugin .jar file from the neosemantics releases page and place it in the plugins folder. The plugin's version must be the same as Neo4j's.
Download the Jelly-Neo4j plugin .jar file and place it in the plugins folder.
Restart the Neo4j server.

You may also need to configure your instance for RDF support. See the documentation of neosemantics for details.

Usage:

All features of the neosemantics plugin are supported. For example, to import a Jelly file into your Neo4j instance:

CALL n10s.rdf.import.fetch(
    'https://w3id.org/riverbench/dumps-with-results/dev.jelly.gz', 
    'Jelly'
)

See the full installation and usage guide.

Install the pyjelly package with integration for Neo4j:

pip install pyjelly[rdflib] rdflib-neo4j

You can now import Jelly files into your Neo4j AuraDB or Neo4j server instance:

from rdflib import Graph
from rdflib_neo4j import Neo4jStoreConfig, Neo4jStore

neo4j_store = Graph(store=Neo4jStore(
    config=Neo4jStoreConfig(
        # add your connection details here
    )
))

neo4j_store.parse("foaf.jelly", format="jelly")

See the full installation and user guide.

How fast is it?

Fast. Jelly was specifically designed to serialize and deserialize streams of RDF data faster than N-Triples or other binary formats, while being more compact than Turtle.

The benchmarks below were performed on streams of RDF graphs or datasets, but Jelly is also good at handling streams of triples or quads ("classic" serialization). The benchmark was performed with Jelly-JVM 2.7.0 with Apache Jena 5.3.0. See: more benchmark results and details about the benchmark setup.

Serialization speed bar plot — Serialization speed of a stream of RDF graphs or RDF datasets, averaged over 13 datasets (RiverBench 2.1.0 profile `stream-mixed-rdfstar`, task `stream-serialization-throughput`).
* Partial results for RDF/XML and JSON-LD (some datasets not supported).
More details about the benchmark.

Deserialization speed bar plot — Deserialization (parsing) speed of a stream of RDF graphs or RDF datasets, averaged over 13 datasets (RiverBench 2.1.0 profile `stream-mixed-rdfstar`, task `stream-deserialization-throughput`).
* Partial results for RDF/XML and JSON-LD (some datasets not supported).
More details about the benchmark.

What can I use it for?

Common use cases for Jelly include:

Client-server communication – connect frontend and backend with less latency, improving user experience.
Inter-service communication – efficiently exchange RDF data between microservices in complex backend applications.
Database dumps and bulk loads – quickly write and read large RDF datasets, reducing storage space and time needed for database maintenance tasks.
Streaming ingest – eliminate ingestion bottlenecks in systems processing large amounts of incoming streaming data.
Database replication and change capture (new!) – record add/delete operations in RDF datasets with transaction support using Jelly-Patch.

See also concrete examples of Jelly being used, along with example datasets.

Commercial and community support

NeverBlink provides commercial support services for Jelly, including implementing custom features, system integrations, implementations for new frameworks, benchmarking, and more.

Community support is available on the Jelly Discord chat.