View on GitHub


RDF.rb is a pure-Ruby library for working with Resource Description Framework (RDF) data.

Download this project as a .zip file Download this project as a tar.gz file

RDF.rb: Linked Data for Ruby

This is a pure-Ruby library for working with Resource Description Framework (RDF) data.

Gem Version Build Status


Differences between RDF 1.0 and RDF 1.1

This version of RDF.rb is fully compatible with RDF 1.1, but it creates some marginal incompatibilities with RDF 1.0, as implemented in versions prior to the 1.1 release of RDF.rb:

Notably, {RDF::Queryable#query} and {RDF::Query#execute} are now completely symmetric; this allows an implementation of {RDF::Queryable} to optimize queries using implementation-specific logic, allowing for substantial performance improvements when executing BGP queries.


Command Line

When installed, RDF.rb includes a rdf shell script which acts as a wrapper to perform a number of different operations on RDF files using available readers and writers.


require 'rdf'
include RDF

Writing RDF data using the N-Triples format

require 'rdf/ntriples'
graph = << [:hello, RDF::DC.title, "Hello, world!"]

or"hello.nt") { |writer| writer << graph }

Reading RDF data in the N-Triples format

require 'rdf/ntriples'
graph = RDF::Graph.load("")

or"") do |reader|
  reader.each_statement do |statement|
    puts statement.inspect

Reading RDF data in other formats

{} and {RDF::Repository.load} use a number of mechanisms to determine the appropriate reader to use when loading a file. The specific format to use can be forced using, e.g. :format => :ntriples option where the specific format symbol is determined by the available readers. Both also use MimeType or file extension, where available.

require 'rdf/nquads'

graph = RDF::Graph.load("", :format => :nquads)

A specific sub-type of Reader can also be invoked directly:

require 'rdf/nquads'"") do |reader|
  reader.each_statement do |statement|
    puts statement.inspect

Reader/Writer implementations may override {RDF::Format.detect}, which takes a small sample if input and return a boolean indicating if it matches that specific format. In the case that a format cannot be detected from filename or other options, or that more than one format is identified, {RDF::Format.for} will query each loaded format by invoking it's detect method, and the first successful match will be used to read the input.

Writing RDF data using other formats

{}, {RDF::Enumerable#dump}, {RDF::Writer.dump} take similar options to {} to determine the appropriate writer to use.

require 'linkeddata'"hello.nq", :format => :nquads) do |writer|
  writer << do |repo|
    repo <<, RDF::DC.title, "Hello, world!", :context => RDF::URI("context"))

A specific sub-type of Writer can also be invoked directly:

require 'rdf/nquads'

repo = <<, RDF::DC.title, "Hello, world!", :context => RDF::URI("context"))"hello.nq", "w") {|f| f << repo.dump(:nquads)}

Reader/Writer convenience methods

{RDF::Enumerable} implements to_{format} for each available instance of {RDF::Reader}. For example, if rdf/turtle is loaded, this allows the following:

graph = << [:hello, RDF::DC.title, "Hello, world!"]

Similarly, {RDF::Mutable} implements from_{format} for each available instance of {RDF::Writer}. For example:

graph =
graph.from_ttl("[ a <>]")

Note that no prefixes are loaded automatically, however they can be provided as arguments:

graph.from_ttl("[ a rdf:Resource]", :prefixes => {:rdf => RDF.to_uri})

Querying RDF data using basic graph patterns (BGPs)

require 'rdf/ntriples'

graph = RDF::Graph.load("")
query ={
  :person => {
    RDF.type  => FOAF.Person, => :name,
    FOAF.mbox => :email,

query.execute(graph) do |solution|
  puts "name=#{} email=#{}"

The same query may also be run from the graph:

graph.query(query) do |solution|
  puts "name=#{} email=#{}"

In general, querying from using the queryable instance allows a specific implementation of queryable to perform query optimizations specific to the datastore on which it is based.

A separate SPARQL gem builds on basic BGP support to provide full support for SPARQL 1.0 queries.

Using pre-defined RDF vocabularies

DC.title      #=> RDF::URI("")
FOAF.knows    #=> RDF::URI("")
RDF.type      #=> RDF::URI("")
RDFS.seeAlso  #=> RDF::URI("")
RSS.title     #=> RDF::URI("")
OWL.sameAs    #=> RDF::URI("")
XSD.dateTime  #=> RDF::URI("")

Using ad-hoc RDF vocabularies

foaf ="")
foaf.knows    #=> RDF::URI("")
foaf[:name]   #=> RDF::URI("")
foaf['mbox']  #=> RDF::URI("")


RDF Object Model

RDF Serialization

RDF Serialization Formats

The following is a partial list of RDF formats implemented either natively, or through the inclusion of other gems:

The meta-gem LinkedData includes many of these gems.

RDF Datatypes

RDF.rb only implements core datatypes from the RDF Datatype Map. Most other XSD and RDF datatype implementations can be find in the following:

Graph Isomorphism

Two graphs may be compared with each other to determine if they are isomorphic. As BNodes within two different graphs are no equal, graphs may not be directly compared. The RDF::Isomorphic gem may be used to determine if they make the same statements, aside from BNode identity (i.e., they each entail the other)

RDF Storage

RDF Querying

RDF Vocabularies



The recommended installation method is via RubyGems. To install the latest official release of RDF.rb, do:

% [sudo] gem install rdf             # Ruby 1.9.2+


To get a local working copy of the development repository, do:

% git clone git://

Alternatively, download the latest development version as a tarball as follows:

% wget


Mailing List




This repository uses Git Flow to mange development and release activity. All submissions must be on a feature branch based on the develop branch to ease staging and integration.


This is free and unencumbered public domain software. For more information, see or the accompanying {file:UNLICENSE} file.