Existing RDF serialization formats such as Turtle, N-Quads, and JSON-LD are widely used for communication and storage in knowledge graph and Semantic Web applications. However, they sufer from limitations in performance, compression ratio, and lack of native support for RDF streams. To address these shortcomings, we introduce Jelly, a fast and convenient binary serialization format for RDF data that supports both batch and streaming use cases. Jelly is designed to maximize serialization throughput, reduce file size with lightweight streaming compression, and minimize compute resource usage. Built on Protocol Bufers, Jelly is easy to integrate with modern programming languages and RDF libraries. To maximize reusability, Jelly has an open protocol specification, open-source implementations in Java and Python integrated with popular RDF libraries, and a versatile command-line tool. To illustrate its usefulness, we outline concrete use cases where Jelly can provide tangible benefits. We consider that by combining practical usability with state-of-the-art eficiency, Jelly is an important contribution to the Semantic Web tool stack.
Jelly is a binary serialization format for streams of RDF triples, quads, graphs, or datasets [
Compression. The design goals of Jelly are to: (1) maximize serialization/deserialization throughput,
(2) provide a relatively good compression ratio, and (3) operate in a fully streaming manner. We
understand the third goal as meeting the common criteria for stream processing systems: process only
one triple at a time, use a limited amount of time per triple, use a limited amount of memory (overall),
output the results on demand, and adapt to temporal changes [
To meet these criteria, Jelly employs a streaming compression algorithm, defined in the
aforementioned specification. The full description of the algorithm is beyond the scope of this contribution –
here we provide only a brief summary. Three fixed-sized string lookup tables indexed by integers are
used, for IRI prefixes, sufixes, and datatypes. The serializer populates these tables until they are full,
after which old lookup entries can be replaced by new ones using any policy (e.g., least recently used).
This allows for processing datasets of indefinite size, as old lookup IDs can be reused. In triples and
quads, IRIs are constructed as a pair of integer identifiers of the relevant prefix and sufix, referencing
the lookup tables. These identifiers are represented as variable-length integers, to minimize their size.
Additionally, simple delta compression is applied, with the value of zero having a special meaning
(repeat last ID or increment it by one, depending on context). Because in Protobuf an integer with a
value of zero is represented with zero bytes, this provides a very eficient compression mechanism.
For consecutive RDF statements with repeating terms (e.g., same triple subject), the repeated term is
not serialized, further reducing file size – this is analogous to semicolons and colons in Turtle. These
compression methods are relatively easy to implement and can work in a fully streaming manner,
processing one triple at a time. They work to both reduce file size and to speed up processing, as less
data written/read corresponds to less memory bandwidth, which is usually the constraining factor.
Performance. We regularly publish performance benchmarks for the Jelly-JVM implementation
on the Jelly website2, using a diverse mix of datasets from RiverBench [
Jelly currently has implementations for Python and the Java Virtual Machine. Both implementations are designed around a generic core that can be used in conjunction with multiple diferent RDF libraries – at the moment supported are: Apache Jena, Eclipse RDF4J, Titanium RDF API, and RDFLib.
Jelly-JVM3 is the more mature and heavily optimized implementation. It is organized into a set of modular components. The jelly-core module encapsulates the base functionality for encoding, decoding and transcoding Jelly data, independent of any particular RDF library, along with necessary utilities and abstractions to facilitate the development of integrations with various RDF libraries. The jelly-jena module provides full interoperability with Apache Jena by converting between Jelly Protobuf messages and Jena’s data structures. It includes an integration with Jena’s RIOT subsystem, making it possible to use Jelly in Jena just like any other RDF format (e.g., Turtle), including proper support for content negotiation. Module jelly-rdf4j ofers analogous adapters for Eclipse RDF4J, in addition to an integration with the Rio serialization subsystem. Module jelly-titanium-rdf-api supplies an adapter layer for the minimalistic Titanium RDF API. Finally, the jelly-pekko-stream module written in Scala integrates with the powerful Apache Pekko Streams framework, allowing for eficient and scalable processing of RDF streams in more advanced use cases (e.g., IoT data aggregation).
Jelly-JVM can be used as a plugin with Jena or RDF4J4. For example, for Apache Jena Fuseki, full Jelly support can be installed by placing the plugin JAR in the extra/ directory of the Fuseki installation. This will enable full support in SPARQL UPDATE queries, the graph store protocol, and in the graphical user interface. Alternatively, for programmatic use, one can include either the jelly-jena (for Jena) or jelly-rdf4j (for RDF4J) Maven artifact by adding the following to pom.xml: <dependency> <groupId>eu.neverblink.jelly</groupId> <artifactId>jelly-jena</artifactId> <version>3.4.0</version> </dependency>
This pulls in jelly-core and all necessary converters. With this dependency in place, Jelly support is registered with Jena or RDF4J automatically, enabling the use of Jelly as an RDF format in code. For example, one can load a Jelly-serialized graph via Jena RIOT using: Model m = RDFDataMgr.loadModel("https://w3id.org/riverbench/v/2.1.0.jelly");
RDFDataMgr.write(new FileOutputStream("m.jelly"), m, JellyLanguage.JELLY);
Streaming serialization/deserialization with Jena, RDF4J, and Titanium is also possible, hooking into the iterator-like interfaces of these libraries, which allows for processing RDF data one statement at a time5. Using the Pekko Streams integration, it is also possible to manipulate RDF data in more complex ways, e.g., batching a stream of quads into a stream of datasets6 and sending it to a Kafka topic. 3.2. Python: pyjelly pyjelly7 is a Python implementation of Jelly, designed to make the benefits of the format accessible to the broad Python audience. Distributed through PyPI8, it can be easily installed on all major operating systems (Linux, Windows, macOS) using standard Python package managers such as pip. To support users in getting started with pyjelly, a documentation suite is available9 including usage examples, up-to-date functionality information, and an API reference. 3https://w3id.org/jelly/jelly-jvm 4https://w3id.org/jelly/jelly-jvm/dev/getting-started-plugins/ 5https://w3id.org/jelly/jelly-jvm/dev/user/rdf4j 6https://w3id.org/jelly/jelly-jvm/dev/user/reactive 7https://github.com/Jelly-RDF/pyjelly 8https://pypi.org/project/pyjelly/ 9https://w3id.org/jelly/pyjelly
Like Jelly-JVM, pyjelly also has a generic serialization core, on top of which integrations with other libraries are built. Currently, the popular RDFLib library is supported in this manner along with integrations for Neo4j and NetworkX, however, more integrations are planned. Serializing an RDFLib graph to the Jelly format is as simple as installing pyjelly with RDFLib support, e.g., pip install pyjelly[rdflib], and specifying the Jelly format during serialization. As shown below, this is as easy as using built-in RDFLib formats: from rdflib import Graph g = Graph() g.parse("https://www.w3.org/2013/N-TriplesTests/nt-syntax-subm-01.nt") g.serialize(destination="triples.jelly", format="jelly")
g = Graph() g.parse("triples.jelly", format="jelly")
To make it easier to use Jelly in production, development, and CI pipelines, we have developed a user-friendly command-line tool, jelly-cli10. This utility supports manipulating Jelly files without the need to write any code beyond a single terminal command. jelly-cli supports the adoption and growth of the Jelly ecosystem by lowering the barrier to entry and helps with common development tasks. Below we briefly showcase several commands supported by jelly-cli (version 0.5.1): • Convert RDF to Jelly: jelly-cli rdf to-jelly input.nq --to=out.jelly This command converts RDF data written in any W3C-standard format into Jelly. Additional options allow for configuring the compression settings. • Convert Jelly to RDF: jelly-cli rdf from-jelly input.jelly --to=out.ttl This command converts a Jelly file to a chosen RDF syntax. Supported formats include W3Cstandard formats and a human-readable version of Jelly, useful for debugging (jelly-text). • Inspect a specific Jelly frame in human-readable binary form: jelly-cli rdf from-jelly input.jelly --out-format=jelly-text --take-frames=3..5 Combined with jelly-text, the --take-frames flag allows extracting individual frames for direct inspection and debugging of parts of the Jelly file. • Merge and transcode Jelly files: cat in1.jelly in2.jelly in3.jelly | jelly-cli rdf transcode --to=merged.jelly --opt.max-name-table-size=8192 The transcode command allows for merging multiple Jelly files into one, as well as recompressing the contents with new settings, using a very eficient transcoding algorithm. • Collect Jelly file statistics: jelly-cli rdf inspect ./in.jelly --per-frame=true Summarizes information about the Jelly file’s contents and used compression options. When run with --per-frame=true, returns detailed statistics for each frame. • Validate a Jelly file: jelly-cli rdf validate file.jelly
Validates the Jelly file and optionally compares its contents against a reference RDF file. This command can also verify whether specific compression options were used during serialization.
Jelly was designed to flexibly fit the requirements of many practical use cases, improving processing speed and reducing compute resource usage. Below we list the intended technical use cases, along with two examples of how Jelly is used in other projects. • Client-server communication – for example, a frontend component can be eficiently linked to the backend. Jelly can reduce the latency between user input and the result, improving the user experience. • Inter-service communication – complex backend applications often consist of a network of microservices that must exchange RDF data (e.g., databases, cron job workers, analytics pipelines).
Jelly can be integrated into existing APIs or with a complete gRPC stack, improving eficiency.
• Database dumps and bulk loads – large RDF datasets can be quickly written and read with
Jelly, while taking up less storage space. This can reduce the time needed for routine database
maintenance tasks and help minimize infrastructure costs.
• Streaming ingest – Jelly can eliminate ingestion bottlenecks in systems processing large amounts
of streaming data, improving responsiveness, and allowing the system to scale to larger problems.
• Database replication and change capture – changes to append-only databases can be recorded
with the Jelly-RDF protocol described in Section 2. Additionally, add/delete operations with
transaction support can be recorded using the Jelly-Patch format11, based on RDF Patch.
Example use case 1: Nanopublication Network. The Nanopublication Network is a decentralized
infrastructure for publishing and querying scientific knowledge using Semantic Web technologies [
Several eficient binary formats for streaming RDF data were proposed in the past, such as ERI [
Both Apache Jena and Eclipse RDF4J have their own binary formats. In Jena, there are two nearly
identical formats (one based on Apache Thrift, the other on Protobuf) that have no built-in compression
and are largely analogous to N-Triples [
There are also binary RDF formats with diferent design goals than Jelly, resulting in a very diferent
set of trade-ofs. CBOR-LD is a tightly compressed binary version of JSON-LD [
In this contribution, we present Jelly, a high-performance RDF serialization format designed specifically to be fast, easy to use, and meet the practical requirements of many real-life use cases. It is currently integrated with several popular RDF libraries and has a CLI tool available to aid with production workloads, as well as testing and development.
We are constantly improving Jelly and its tooling. In the near future, we plan to: finalize protocol test cases for conformance testing of implementations, expand the feature set of the Python implementation, and integrate Jelly with commonly-used Semantic Web tools. Further plans include more implementations (e.g., JavaScript, Rust, Kotlin), new integrations (e.g., Pandas, KGTK), adding support for serializing SPARQL result sets, introducing new compression schemes, and temporal indexing.
We invite the community to contribute to the Jelly protocol and its tooling, with feature requests, bug reports, new integrations, documentation and more. More information on contributing can be found here: https://w3id.org/jelly/dev/contributing
This work was financially supported from the European Funds under the Sector Agnostic path of the Huge Thing Startup Booster program (project no. 0021/2025, program FENG.02.28-IP.02-0006/23).
Declaration on Generative AI. During the preparation of this work, the authors used ChatGPT in order to draft content. After using this tool, the authors reviewed and edited the content as needed and take full responsibility for the publication’s content.