This page is a suggested implementation for providing DublinCore metadata in WikiEngines.


The suggested format is RDF/XML, mostly for simplicity and performance reasons. Implementing the Dublin Core as a separate URL means that WikiEngines don't have to do expensive history lookups each time a page is served, but only when the metadata is explicitly requested.

RDF for the Dublin Core data can be generated dynamically from the WikiEngine, just like any other data. It's just a different format.

On the displaying a Wiki page, an HTML <link> element can be used to point to the URL that will generate the metadata, like so:

 <link rel="meta" href="http://wiki.example.com/ExamplePage?action=dc" />

Simple Dublin Core

This is the current recommendation for Dublin Core in RDF.


It has the advantage of being DTD-validatable, and being a full recommendation, but the disadvantage that some qualifications to the elements aren't present.

The following are some suggestions for what to assign to the elements of this encoding. Elements marked "ignore" should just be left out, unless there's special mechanisms in the Wiki engine to support them. (See DublinCore for a way to add special MetaData markup to a page.)

Authorship model

"Authorship", in wiki, is a difficult subject. Dublin Core differentiates between creators and contributors. There are several ways to map wiki editing methods onto Dublin Core:

  1. All editors are listed as creators, with no contributors.
  2. All editors are listed as contributors, with no creators.
  3. The first editor is listed as a creator, and all others as contributors.
  4. The top N editors, in terms of added text, are listed as creators, and all others are contributors.
  5. Editors who made minor edits are contributors, and all others are creators.
  6. The last editor is responsible for the current version and thus the creator. All other editors contributed to this last version.

The last model is the one recommended above. It has the benefit that it fits some standard AuthorshipModels for wiki, especially those that use a CopyLeft license.

Identifying people

You can identify contributors and creators a few ways. One is to use spaced-out versions of their user name: "EvanProdromou" -> "Evan Prodromou". Another is to use an URL to their user page, as follows:

 <dc:creator rdf:resource="http://wiki.example.com/EvanProdromou" />

It may be good to use the resource if a user page exists, and the spaced-out user name if not.

Anonymous editors should be identified as "Anonymous".


The following is a full example of the RDF output for an example wiki page:

 <?xml version="1.0"?>
 <!DOCTYPE rdf:RDF PUBLIC "-//DUBLIN CORE//DCMES DTD 2002/07/31//EN http://dublincore.org/documents/2002/07/31/dcmes-xml/dcmes-xml-dtd.dtd">
 <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
         xmlns:dc ="http://purl.org/dc/elements/1.1/">
   <rdf:Description rdf:about="http://wiki.example.com/ExamplePage">
     <dc:creator rdf:resource="http://wiki.example.com/MaryFakename" />
     <dc:subject>Example Page</dc:subject>
     <dc:publisher rdf:resource="http://wiki.example.com/ExampleWiki" />
     <dc:contributor rdf:resource="http://wiki.example.com/BobMadeup" />
     <dc:contributor rdf:resource="http://wiki.example.com/ZeldaErsatz" />
     <dc:contributor>Danny Hasnopage</dc:contributor>
     <dc:rights rdf:resource="http://www.dsl.org/copyleft/dsl.txt" />

Qualified Dublin Core

The newer encoding for Dublin Core is here:


It enhances the simple Dublin Core encoding with some more specific terms. It's not DTD-validatable (but it does use an XML Schema), and it's only a proposed recommendation, not a full one. However, it's what Dublin Core uses for its own site, so maybe that's a good enough endorsement for now.

Qualified Dublin Core for wikis should use all of the above Dublin Core terms,in the principle of GradualDegradation?. It should add the following, also:




Historical versions

If historical versions of a page are directly navigable (like "http://wiki.example.com/ExampleWiki?version=2"), that page can/should have metadata, too. The simple stuff should be equivalent, but only include contributions up to the version shown. The qualified DC elements should be as follows:


If the Wiki engine provides information on links to and from the page, each may be added as <dcq:isReferencedBy> and <dcq:references> elements, respectively. This could be useful for building site maps, for example.

Human-edited metadata

Some additional human-edited metadata can make the Dublin Core data here more complete. This is probably only useful for things that the Wiki engine can't figure out for itself; some metadata that may be useful:

Creative Commons metadata

Creative Commons has their own metadata standard almost but not quite identical to the Dublin Core one. It concentrates slightly more on licensing and digital rights.


There's not really much that needs to be changed for wiki that doesn't need to be changed for other Web resources. The above-defined DC elements should work well within the Creative Commons format.




I'd use dc:subject for the categories. You could also use the Wiki's RecentChanges page (or relevant cluster) for dc:publisher.


I can kinda get using categories in the subject, but I think the URL used for the publisher should be the description of the wiki, and not a utilities page.


The RecentChanges page is where changes are published, so it makes sense. (It also means separate communities using a DividedCommons will be distinguishable, but that's kind of theoretical right now.) I chose dc:subject for categories because it seemed to fit the description:

 Subject And Keywords
 The topic of the content of the resource.

Equally, for dc:publisher:

 An entity responsible for making the resource available
 Examples of a Publisher include a person, an organisation, or a service.

I'd call RC a service :) It seems to be the best - and only - place to put a page's cluster.


Well, if I had never heard of a wiki and it showed up in the metadata as a publisher, I'd like that URL to point to a page describing the wiki itself, not a page full of changes. A WikiNode page, or something like CommunityWiki or MeatballWiki. I guess I think RecentChanges is more of an insider's view of the wiki, not the FrontLawn.

[new] I don't understand this:

<dc:creator> -- the last editor of a page

The creator should be the First not the Last editor...


Read the page again; this is discussed under "Authorship model"


Sounds like a discussion. I'd make it "AuthorshipInDublinCoreForWiki?."


Well, the same issue comes up for e.g. CopyLeft licenses. Maybe AuthorshipModel?


In the example, why are the values for dc:identifier and source not rdf:resources, as are dc:creator, publisher, creator, and rights?

Regarding Creative Commons metadata: it is not different than DC RDF. The former extends the latter. Take

 <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
          xmlns:dc ="http://purl.org/dc/elements/1.1/">
    <rdf:Description rdf:about="http://wiki.example.com/ExamplePage">

which obtains the triple

 http://wiki.example.com/ExamplePage http://purl.org/dc/elements/1.1/title "ExamplePage" .


 <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
          xmlns:dc ="http://purl.org/dc/elements/1.1/"
          xmlns:cc ="http://web.resource.org/cc/">
    <cc:Work rdf:about="http://wiki.example.com/ExamplePage">

which obtains the triples

 http://wiki.example.com/ExamplePage http://www.w3.org/1999/02/22-rdf-syntax-ns#type http://web.resource.org/cc/Work .
 http://wiki.example.com/ExamplePage http://purl.org/dc/elements/1.1/title "ExamplePage" .

In other words, all that cc:Work does is add type information (that the subject is possibly a copyrightable work). This is a case where the RDF/XML encoding makes CC metadata appear annoyingly incompatible with DC though it is not.

To either of the above productions we can add

 <dc:rights rdf:resource="http://example.com/licenses/foo" />


 <cc:license rdf:resource="http://example.com/licenses/foo" />

Again, they look annoyingly different. However, the latter is just more precise. cc:license refines dc:rights (see the schema embedded in and linked to from http://web.resource.org/cc/). Admittedly this is a bit harder to deal with than the triple added by cc:Work -- an otherwise ignorant application would need to be rdf schema-aware to discover this.

I think cc:Work and cc:license ought to be used, though it isn't a tragedy if one just uses rdf:Description and dc:rights with a reference to a CC license URL where appropriate. It would be unfortunate to hand out separate DC and CC metadata as is contemplated at http://meta.wikipedia.org/wiki/RDF_metadata.


Wow, that's a lot to reply to. Let's see if I can take it bit by bit.

For identifier: I think the point of rdf:resource is to refer to some resource that contains the answer to the question. "Who is the creator of this page?" "The answer is here: http://wiki.example.com/Evan". But the identifier for a Web page isn't at the URL; it is the URL. So I think that the URL should stay content, not an rdf:resource.

However, for source, I think you're correct: the source is the content at the URL, not the URL itself. So I'll update that above, and try to do the same in the MediaWiki and PmWiki metadata.

As to the relationship between CC metadata and DC metadata: I think you may be mistaken as to the extensibility of Simple DC RDF/XML metadata. It's defined in a DTD, and doesn't leave much room to change the elements available. The Qualified DC RDF can be extended, but it's different.

I think it makes some sense to support both.

(Heh! That didn't turn out so bad after all.) B-)


A couple of issues, on review:

  • Embedded images. I think the idea would be to add another rdf:Description (or cc:Work) to the rdf:RDF element, with rdf:about being the URL of the image. But I'm not sure that's the right thing.
  • As stated above, the dc:creator didn't actually edit the page when it was dc:created. I'm not sure if the semantics of either term requires that, though.


You're right about simple vs. qualified DC RDF/XML. I completely missed that the target is the former, though it's plain as day above. Oops. I guess I have two followup points then:

  • Why target Simple DC RDF/XML at all? Are there people clamoring for DTD-valid metadata? You say it makes sense to support both...
  • If support for both is required, maybe call them "simple" and "qualified" instead of "dublincore" and "creativecommons".

I have two motives:

  • Aversion to format proliferation.
  • I want to make it clear that "Creative Commons metadata" is not something peculiar to CC. Setting metadata standards really isn't CC's game, we want to play nicely in the DC/RDF/SemWeb? ecosystem.


Regarding identifier: I could swear there was a long discussion of this on http://www.jiscmail.ac.uk/lists/DC-USAGE.html though I can't find it now. Some DC list anyway. This is a confusing topic, but I'm pretty sure that the only difference between



 <dc:identifier rdf:resource="http://example.com" />

is that the former value is a literal, while the latter is a URI. Again, looking at the triple produced in each case makes things clearer:

 <> http://purl.org/dc/elements/1.1/identifier 	"http://example.com" .


 <> http://purl.org/dc/elements/1.1/identifier http://example.com .

or to belabor the point even further, the former says that the current document has an idenfier which is some string, the latter that the current document has an identifier which is a URI, not that the identifier may be found at that URI.

Please disabuse me of any (quite likely) false notions.


I most willingly admit that my RDF/XML-fu is weak. But according to the RDF primer:


It says, in part:

If the URIref of this resource were written as a plain literal within start- and end-tags in the same way as the literal values of the other elements, this would say that the value of the dc:creator element was the character string http://www.example.org/staffid/85740, rather than the resource identified by that literal interpreted as a URIref. [...] The rdf:resource attribute indicates that the property element's value is another resource, identified by its URIref."

However, later in the document, they use an URN (heh, gotta love URNs!) in an rdf:resource in dc:identifier. So, y'know, I could be reading this completely wrong.


OK, the Qualified Dublin Core definition does use <dc:identifier rdf:resource="URI" />. I'm really losing ground, here, I think.


Define external redirect: AuthorshipInDublinCoreForWiki GradualDegradation SemWeb SomeWikiPage

EditNearLinks: MeatballWiki MediaWiki FrontLawn WikiEngine PmWiki