RDF Serialization

RDF/XML is the original, canonical XML-based serialization for RDF, mandated by the first W3C RDF specifications. It represents RDF graphs as well-formed XML documents.

• Key Feature: Guaranteed interoperability with any XML parser.
• Characteristic: Verbose and complex due to XML's tree structure representing a graph.
• Use Case: Legacy system integration and contexts where XML toolchains are mandatory.
• Standard: W3C Recommendation (2004). While largely superseded by simpler formats, it remains the only format all conformant RDF tools must support.

N-Triples is a strict, line-based subset of Turtle where each line contains exactly one full triple, with no abbreviations or prefixes. It is the simplest format for machine processing.

• Key Feature: Extremely simple to parse and generate, ideal for streaming large datasets.
• Limitation: Very verbose, as every URI must be written in full within angle brackets.
• Use Case: Output format for batch data dumps, ETL pipelines, and interoperability testing between triplestores.
• Standard: W3C Recommendation (2014).

N-Quads and TriG are extensions of N-Triples and Turtle, respectively, designed to serialize RDF Datasets that contain multiple Named Graphs.

• N-Quads: Adds a fourth element (the graph name/context) to each N-Triples line.
• TriG: Allows Turtle-style syntax to define multiple graphs within curly braces, identified by a graph label.
• Key Feature: Native support for representing provenance, versioning, and access control contexts via distinct sub-graphs.
• Use Case: Storing and exchanging datasets with metadata, trust assertions, or data from different sources.

Turtle is a compact, human-readable text syntax for RDF. It uses prefixes to abbreviate URIs and supports shorthand notations like lists and nested blank nodes, making it the preferred format for authoring and exchanging RDF data. Its clarity facilitates manual inspection and debugging of RDF graphs.

• Key Features: Prefix declarations (@prefix), predicate lists, object lists.
• Example: @prefix ex: <http://example.org/> . ex:Alice ex:knows ex:Bob .
• Primary Use Case: Human-readable RDF authoring, data dumps, and configuration files.

JSON-LD serializes RDF graphs as standard JSON, designed for seamless integration into web applications and REST APIs. It uses a @context to map JSON keys to URIs, enabling developers to work with semantic data without deep RDF expertise. It can be processed as plain JSON or expanded into full RDF triples.

• Key Features: @context for mapping, @id for subjects, @type for rdf:type.
• Example: {"@context":{"knows":"http://xmlns.com/foaf/0.1/knows"}, "@id":"http://me.example.com", "knows":{"@id":"http://you.example.com"}}
• Primary Use Case: Web APIs, microservices, and embedding linked data in JavaScript applications.

RDF/XML is the original, canonical XML-based serialization for RDF, standardized by the W3C. It represents RDF triples as XML elements and attributes, ensuring interoperability with XML toolchains. However, its verbosity and complex nesting can make it less human-friendly than Turtle or JSON-LD.

• Key Features: XML syntax, namespace-based URIs, defined in the RDF 1.1 XML Syntax specification.
• Example: <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:ex="http://example.org/"><rdf:Description rdf:about="http://example.org/Alice"><ex:knows rdf:resource="http://example.org/Bob"/></rdf:Description></rdf:RDF>
• Primary Use Case: Legacy system integration and environments with mandated XML data formats.

N-Triples is a line-based, plain-text format where each line contains exactly one triple in fully expanded form (no prefixes). N-Quads extends N-Triples by adding an optional fourth component—the graph name—for representing datasets with named graphs. Their simplicity makes them ideal for machine processing, large-scale data streams, and incremental parsing.

• Key Features: One triple per line, fully resolved URIs, no abbreviations.
• Example (N-Triples): <http://example.org/Alice> <http://example.org/knows> <http://example.org/Bob> .
• Example (N-Quads): <http://example.org/Alice> <http://example.org/knows> <http://example.org/Bob> <http://example.org/Graph1> .
• Primary Use Case: Large-scale data dumps, stream processing, and interchange between triplestores.

RDFa is a W3C standard for embedding RDF data within HTML and XHTML documents using attributes. It allows publishers to add semantic markup directly to web pages, making the same content human-readable and machine-processable. Search engines and crawlers use RDFa to extract structured data for rich snippets and knowledge panels.

• Key Features: Uses HTML attributes like vocab, typeof, property, and resource.
• Example: <div vocab="http://schema.org/" typeof="Person"><span property="name">Alice</span> knows <span property="knows" typeof="Person"><span property="name">Bob</span></span></div>
• Primary Use Case: Semantic SEO, embedding metadata in web pages, and enabling data extraction by crawlers.

TriG is a serialization format that extends Turtle to encode an RDF Dataset—a collection of multiple RDF graphs, including a default graph and one or more named graphs. It uses curly braces {} to group triples into distinct, named graphs, which is essential for representing data provenance, access controls, and contextual partitions.

• Key Features: Graph labels (GRAPH <uri> { ... }), supports both default and named graphs.
• Example: @prefix ex: <http://example.org/> . ex:Graph1 { ex:Alice ex:knows ex:Bob . } ex:Graph2 { ex:Bob ex:age "30" . }
• Primary Use Case: Serializing complex RDF datasets with multiple named graphs for context and provenance.