Hubbry Logo
RELAX NGRELAX NGMain
Open search
RELAX NG
Community hub
RELAX NG
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
RELAX NG
RELAX NG
RELAX NG
View on Wikipedia
from Wikipedia
RELAX NG
Filename extension
.rng
Internet media type
application/xml, text/xml
Type of formatXML schema language
Extended fromXML

In computing, RELAX NG (REgular LAnguage for XML Next Generation) is a schema language for XML. A RELAX NG schema specifies a pattern for the structure and content of an XML document. A RELAX NG schema is itself an XML document, but RELAX NG also offers a popular compact, non-XML syntax.[1] Compared to other XML schema languages, RELAX NG is considered relatively simple.

It was defined by a committee specification of the OASIS RELAX NG technical committee in 2001 and 2002, based on Murata Makoto's RELAX and James Clark's TREX,[2][3][4] and also by part two of the international standard ISO/IEC 19757: Document Schema Definition Languages (DSDL).[5][6] ISO/IEC 19757-2 was developed by ISO/IEC JTC 1/SC 34 and published in its first version in 2003.[7]

Comparison with W3C XML Schema

[edit]
Main article: XML schema languages

Although the RELAX NG specification was developed at roughly the same time as the W3C XML Schema specification, the latter was arguably better known and more widely implemented in both open-source and proprietary XML parsers and editors when it became a W3C Recommendation in 2001. Since then, however, RELAX NG support has increasingly found its way into XML software, and its acceptance has been aided by its adoption as a primary schema for popular document-centric markup languages such as DocBook, the TEI Guidelines, OpenDocument, and EPUB.

RELAX NG shares many features with W3C XML Schema that set both apart from traditional DTDs: data typing, regular expression support, namespace support, ability to reference complex definitions.

Filename extensions

[edit]

By informal convention, RELAX NG schemas in the regular syntax are typically named with the filename extension ".rng". For schemas in the compact syntax, the extension ".rnc" is used.

Determinism

[edit]

Relax NG schemas are not necessarily "deterministic" or "unambiguous".

Converting Relax NG to DTD

[edit]

Relax NG schemas can be converted to DTDs by applying Trang which can be found at: [1]. The manual for Trang is located at [2]. Note that Trang is unable to convert the OASIS DITA 1.3 schema to DTDs, failing with messages like: 

 sorry, combining definitions with combine="choice" is not supported

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

RELAX NG

View on Grokipedia
from Grokipedia
RELAX NG is a schema language for XML designed to specify patterns for the structure, content, and data types of XML documents, allowing validation of XML instances against defined grammars. It supports two equivalent syntaxes: a full XML syntax that integrates seamlessly with XML tools and a compact, non-XML syntax optimized for readability and conciseness. Developed as a unification of the TREX and RELAX Core proposals, RELAX NG emphasizes simplicity, modularity, and internationalizability while maintaining compatibility with W3C XML Schema datatypes. The language was created by the OASIS RELAX NG Technical Committee, with initial committee specifications published in 2001 and 2002. It achieved international standardization as ISO/IEC 19757-2:2003 (Information technology — Document Definition Languages (DSDL) — Part 2: RELAX NG), with a second edition in that incorporated minor revisions. RELAX NG's prioritizes ease of use for both authors and implementers, supporting features like named patterns for , context-dependent content models, and extensibility without requiring modifications. It is notably employed in standards such as 3.0 for schema-aware processing and the Citation Style Language for document formatting. As part of the broader Document Definition Languages (DSDL) framework, RELAX NG complements other technologies by focusing on declarative, pattern-based validation rather than complex type hierarchies.

Overview

Definition and Purpose

RELAX NG, an acronym for for XML Next Generation, is a schema specification language designed to define patterns for the , content, and valid sequences of elements and attributes in XML documents. Its primary purpose is to enable the validation of XML instances against these schemas, thereby ensuring conformance to predefined rules, maintaining , and promoting across XML-based applications and systems. Unlike traditional XML documents, RELAX NG schemas can be expressed either as XML documents themselves or in a non-XML compact syntax, while preserving the underlying XML information set without modification. RELAX NG emerged as an alternative to more complex schema languages for XML processing, prioritizing simplicity and ease of use over intricate features like those in W3C or DTDs.

Key Features

RELAX NG supports two distinct syntaxes for authoring schemas: an XML-based syntax typically stored in files with the .rng extension, and a compact, non-XML syntax stored in files with the .rnc extension, allowing authors to choose between structured XML representation and a more concise, grammar-like notation that enhances while preserving full expressiveness. The schema language integrates seamlessly with W3C datatypes, enabling validation of content against built-in types such as and , as well as custom derivations, through the use of the element specifying the datatype library. This integration allows RELAX NG to leverage a robust datatype system without redefining it, focusing instead on structural patterns. RELAX NG features a namespace-friendly that supports referencing external via URI identifiers or prefixed names, avoiding prefix conflicts by relying on URIs for unambiguous resolution during interpretation and validation. Unlike some languages that enforce strict , RELAX NG permits ambiguous grammars where multiple patterns may match a given context, resolving them dynamically based on the instance document without requiring unambiguous definitions. RELAX NG documents in XML syntax are identified by the internet media types application/xml and text/xml, ensuring compatibility with standard XML processing tools and parsers. The language excels at expressing complex constraints, such as co-occurrence rules between attributes and elements—for instance, requiring a specific attribute only when certain child elements are present—through constructs like , , and that model interdependencies flexibly. This capability stems from RELAX NG's design goal of , which prioritizes intuitive composition over rigid ordering requirements.

History

Development Origins

RELAX NG originated from the convergence of two independent efforts to create more expressive and flexible schema languages for XML documents. In early 2000, Makoto Murata developed RELAX (Regular Language description for XML), a schema language that leveraged theory to describe XML structures, initially published as a specification on , 2000, and later approved as an ISO/IEC (TR 22250-1) in May 2001. Independently, in January 2001, James introduced TREX (Tree Regular Expressions for XML), a compact schema language based on tree automata that emphasized simplicity and the use of W3C datatypes. These prototypes addressed key shortcomings in existing XML validation mechanisms, particularly the Document Type Definitions (DTDs) introduced with XML 1.0, which lacked support for XML namespaces and offered limited expressiveness for complex content models. The unification of RELAX and TREX began in March 2001 when OASIS formed the TREX Technical Committee, chaired by , to standardize TREX as an XML validation language. By June 2001, recognizing the synergies between the two approaches, OASIS merged the TREX committee with efforts around Murata's RELAX, renaming it the RELAX NG Technical Committee to develop a single, lightweight language. Clark continued as chair, with Murata as a key contributor, aiming to create a "next generation" that combined RELAX's modularity with TREX's streamlined syntax while avoiding the anticipated verbosity and complexity of the emerging W3C recommendation. This motivation stemmed from the need for a language that was easier to author and maintain than DTDs—without their namespace insensitivity and rigid attribute handling—and simpler than 's type hierarchy and particle constraints. Early development involved iterative prototypes and discussions within the committee, building on the theoretical foundations of hedge automata from RELAX and the practical validation algorithms from TREX. The first working draft of the RELAX NG specification was released on September 17, 2001, marking the initial formal outline of the unified language. This draft incorporated core patterns from both predecessors, focusing on composable grammars to enable reusable schema modules, and set the stage for further refinement toward an OASIS committee specification.

Standardization Process

The standardization of RELAX NG began with its approval as an OASIS Committee Specification. On December 3, 2001, the OASIS RELAX NG Technical Committee approved the RELAX NG specification, which defined the XML syntax for the schema language. This marked the formal consolidation of earlier efforts into a unified standard for XML schema definition. Subsequently, the compact syntax was developed to provide a more concise, non-XML alternative for authoring schemas. On November 21, 2002, the OASIS RELAX NG Technical Committee approved the RELAX NG Compact Syntax as a Committee Specification, enabling easier human readability and editing while maintaining equivalence to the XML syntax. RELAX NG was incorporated into the broader Document Schema Definition Languages (DSDL) framework, which coordinates multiple schema languages for comprehensive XML validation. As Part 2 of DSDL, RELAX NG focuses on regular-grammar-based validation, integrating with other parts like Schematron for rule-based assertions. The international standardization process advanced through ISO/IEC JTC 1/SC 34. In December 2003, RELAX NG was published as ISO/IEC 19757-2:2003, titled Information technology — Document Schema Definition Languages (DSDL) — Part 2: RELAX NG, establishing it as a formal for XML schema patterns based on regular tree grammars. An amendment in 2006 (ISO/IEC 19757-2:2003/Amd 1:2006) added explicit support for the compact syntax. The standard underwent a minor revision in December 2008 with the second edition (ISO/IEC 19757-2:2008), which incorporated the 2006 amendment and provided clarifications on schema requirements and validation rules without altering core functionality. The 2008 edition remains the current version of RELAX NG , with the standard last reviewed and confirmed in 2024. A Version 2 is under development by ISO/IEC JTC1/SC34/WG1 to address evolving needs in XML processing.

Design Principles

Simplicity and Ease of Use

RELAX NG was designed with a primary goal of minimizing to enhance for schema authors and implementers. Its pattern-based approach draws inspiration from context-free grammars, allowing to define XML structures in a way that feels intuitive, particularly for those accustomed to regular expressions or theory. By focusing on declarative patterns rather than intricate type hierarchies or mechanisms, RELAX NG avoids unnecessary abstractions that could complicate schema authoring. This choice ensures that can directly mirror the hierarchical structure of the target XML documents without requiring additional flattening or restructuring steps. A key aspect of RELAX NG's simplicity lies in its validation process, which operates directly on the input XML without altering the document's infoset. Unlike certain schema languages that mandate preprocessing, such as inserting default attributes or handling nilled elements, RELAX NG performs validation as a pure matching exercise against defined patterns. This approach eliminates the need for schema processors to modify the original document, reducing potential errors and simplifying integration into XML pipelines. As a result, validation remains deterministic and non-intrusive, preserving the integrity of the input while confirming conformance. The for RELAX NG is notably gentle, as it supports straightforward without the verbose declarations often required in alternatives like . Developers can express constraints using concise constructs that prioritize clarity over boilerplate, such as defining sequences and choices in a linear, grammar-like fashion. This reduces the overhead of schema creation and maintenance, making it accessible even to users without deep expertise in schema technologies. The language's uniform treatment of elements and attributes further streamlines comprehension, as patterns apply consistently across content models. Readability is further enhanced in RELAX NG's compact syntax, which employs familiar delimiters like parentheses for grouping subpatterns and vertical bars for specifying alternatives, evoking the notation of regular expressions. This syntax option allows authors to write schemas in a textual format that closely resembles the informal sketches often used in or prototyping. By leveraging such intuitive symbols, RELAX NG facilitates quick and , contributing to its overall ease of use in practical development workflows.

Modularity and Namespace Handling

RELAX NG supports through the include and div elements, which enable to reference and incorporate external definitions for reuse across multiple documents. The include element uses an href attribute to merge an external into the current one, effectively inlining its patterns while allowing optional redefinition of specific definitions via nested define elements. For instance, a schema might include a module for common inline elements like this: <include href="inline.rng" rel="nofollow"/>, which adds reusable patterns without duplicating code. The div element further enhances by grouping related definitions within a grammar, such as <div><define name="header">...</define></div>, facilitating modular structure and annotation without affecting semantics. Linking mechanisms in RELAX NG, particularly the externalRef element, allow schemas to import patterns from external files while preserving the original context during composition. By specifying an href attribute, externalRef references a named pattern in another schema, ensuring that namespace and scoping information from the imported module is maintained to avoid resolution conflicts. An example is <externalRef href="common.rng" rel="nofollow"/> within an element pattern, which integrates reusable components like data types or structures seamlessly into the host schema. This approach promotes reuse by treating external patterns as black boxes, with validation occurring as if they were inline. RELAX NG integrates namespaces directly through xmlns declarations in schema documents, enabling the use of qualified names for elements and attributes without complications from default namespace inheritance. Schemas declare namespaces via attributes like xmlns:prefix="URI", and the ns attribute on grammar elements specifies the default namespace URI for contained names, such as ns="http://example.com/doc". This allows precise qualification, for example, <element name="ex:doc" xmlns:ex="http://example.com/doc">, ensuring that local names are bound correctly regardless of surrounding contexts and avoiding issues where unqualified names might inadvertently fall into unintended namespaces. Attributes, by convention, belong to the empty namespace unless explicitly qualified. Co-occurrence constraints in RELAX NG permit the definition of interdependencies across modules, such as requiring specific attribute-element pairings, through compositors like interleave and choice applied to imported patterns. For example, a module might define a card element that interleaves a name attribute with an email child element, ensuring they co-occur appropriately when referenced via externalRef or include: <interleave><attribute name="name"/><element name="email">...</element></interleave>. This mechanism enforces relational rules between components from different modules during validation, maintaining consistency in composed schemas without needing monolithic definitions.

Syntax

XML Syntax

RELAX NG schemas in XML syntax are themselves valid XML documents that adhere to the RELAX NG namespace http://relaxng.org/ns/structure/1.0. This syntax enables the use of standard XML tools for parsing, editing, and processing schemas. The root of the schema can be a single pattern, such as an <element>, or a <grammar> element for more modular definitions containing named patterns via <define> elements. Key elements in the XML syntax include <element> for defining element patterns, <attribute> for attribute patterns, and <text/> for matching text content. The <grammar> element, when used, serves as a container that includes a <start> element to designate the initial matching pattern and <define> elements to create reusable named patterns referenced by <ref>. This structure allows for hierarchical and modular schema composition while maintaining XML conformance. A simple example of an XML syntax schema defines a book element with required title and author child elements, each containing text:

xml

<element name="book"> <element name="title"> <text/> </element> <element name="author"> <text/> </element> </element>

<element name="book"> <element name="title"> <text/> </element> <element name="author"> <text/> </element> </element>

This schema validates XML instances like <book><title>Foundation</title><author>Isaac Asimov</author></book>, ensuring the specified structure and content types. Namespaces are declared using standard XML xmlns attributes on the schema document or elements, with the RELAX NG namespace typically bound to a default or prefix like rng. For patterns matching namespaced elements or attributes, the ns attribute specifies the target namespace URI on <element> or <attribute>, such as <element name="book" ns="http://example.com/book">. This approach integrates seamlessly with XML's namespace mechanisms without requiring additional scoping elements within the <grammar>. The XML is notably verbose compared to alternatives but excels in machine , making it ideal for automated generation by tools and integration into XML processing pipelines.

Compact Syntax

The RELAX NG compact provides a non-XML, grammar-like notation for defining , designed to enhance while preserving full equivalence to the XML . It employs keywords such as element for defining elements and attribute for attributes, along with delimiters including {} for grouping content within named constructs, , for sequences, | for choices, & for interleaving, and repetition operators like * for zero or more occurrences, + for one or more, and ? for optional . These elements map directly to corresponding XML constructs, such as element nameClass { pattern } translating to <element name="nameClass"><pattern/></element>, ensuring lossless bidirectional conversion between the two forms. For instance, a simple for a book element with required title and subelements can be expressed as:

element book { element title { text }, element author { text } }

element book { element title { text }, element author { text } }

This notation specifies that a valid must have a book root element containing exactly one title and one author, each holding text content, demonstrating the compact syntax's concise, declarative style akin to a . The advantages of the compact syntax include maximized human readability, which facilitates manual editing and comprehension without the verbosity of XML tags, while supporting all RELAX NG features such as namespaces, datatypes, and through mechanisms like named patterns and includes. It is particularly beneficial for schema authors preferring a programming-language-like format over XML's markup-heavy structure, and schemas in this form can be independently translated to XML syntax without introducing dependencies or loss of information. Annotations and comments further enhance usability in the compact syntax. Annotations are enclosed in square brackets [ ] and placed before patterns, allowing embedding of foreign elements or attributes for metadata, which map to XML annotations like <db:annotation> in DocBook-integrated . Comments begin with # and extend to the line end, while ## specifically denotes comments that integrate with mechanisms for schema .

Core Concepts

Patterns and Elements

In RELAX NG, patterns serve as the fundamental building blocks for specifying the structure of XML documents, defining what constitutes a valid of elements, attributes, and text content. These patterns are composable, allowing schema authors to construct complex structures from simpler ones through operators that model sequences, alternatives, and repetitions. By treating elements and attributes uniformly within content models, RELAX NG patterns enable a declarative approach that mirrors the hierarchical nature of XML without imposing rigid ordering constraints where unnecessary. The core atomic patterns include text, empty, and notAllowed, which handle textual content and constraints at the leaf level. The text pattern matches any sequence of text characters, including whitespace or empty strings, and is used to specify locations where arbitrary character data is permitted. In contrast, the empty pattern matches only an absence of content, ensuring no text or child elements are present in that position. The notAllowed pattern, conversely, forbids any content entirely, serving to explicitly prohibit elements or text in a given context and preventing unintended expansions in schema composition. Element and attribute declarations are primary patterns for defining named nodes in the XML tree. The element pattern specifies an XML element with a given name (or name class) and an inner pattern that constrains its content; for instance, in compact syntax, element foo { text } requires an <foo> element containing only text. Similarly, the attribute pattern declares an XML attribute with a name and inner pattern, such as attribute name { text }, which mandates a name attribute holding text on its parent element. These declarations can nest patterns recursively to capture document hierarchies. Patterns combine via operators to express relationships between components. The sequence , denoted by a comma (,) in compact syntax or a group element in XML syntax, enforces ordered concatenation of subpatterns, as in element header { element title { text }, element author { text } }, which requires a <header> containing a <title> followed immediately by an <author>. The choice operator, represented by a vertical bar (|) or a choice element, allows one of several alternatives, enabling flexible structures like element greeting { "hello" | "hi" } for selectable fixed content. Repetition modifiers extend patterns to handle multiplicity without verbose recursion. The optional modifier (?) permits zero or one occurrence of a pattern, such as element optionalNote { text }? to allow but not require a note. The one-or-more modifier (+) requires at least one repetition, while zero-or-more (*) allows any number including none; for example, element items { element item { text }+ } defines an <items> element containing one or more <item> subelements, each with text, modeling a non-empty list structure. These operators apply uniformly to elements, attributes, and other patterns, promoting modularity in schema design.

Data Types and Attributes

RELAX NG integrates data types primarily through external libraries, with the W3C Datatypes serving as the recommended standard for defining and constraining textual content within patterns. This integration is facilitated by the <data> element in XML or the data keyword in compact , which specifies a datatype via the type attribute and references the library using the datatypeLibrary attribute, defaulting to the XML Schema namespace http://www.w3.org/2001/XMLSchema-datatypes. Custom facets, such as length restrictions or value ranges, are applied using parameters like <param> in XML or inline declarations in compact , enabling precise control over content validity without embedding full schema complexity. Attributes in RELAX NG are defined using the <attribute> pattern, which specifies the attribute's name and optional content constraints, including data types from the integrated libraries. By default, attributes are optional within an element pattern unless explicitly required through grouping or referencing mechanisms; their order is insignificant, unlike elements. For typed attributes, the pattern can incorporate a <data> , as in the compact syntax example:

attribute name { text }

attribute name { text }

or with typing:

attribute age { xsd:integer }

attribute age { xsd:integer }

This ensures the attribute value conforms to the specified datatype, such as an for age. Data types extend to element content as well, allowing constraints like numeric ranges within simple elements, as shown in this compact syntax example for a element:

element person { attribute name { text }, element age { xsd:[integer](/page/Integer) { minInclusive = "0" maxInclusive = "150" } } }

element person { attribute name { text }, element age { xsd:[integer](/page/Integer) { minInclusive = "0" maxInclusive = "150" } } }

Here, the age element's text content must be an integer between 0 and 150, leveraging facets for validation. This approach maintains RELAX NG's focus on pattern-based typing while borrowing robust primitive and derived types from . For linking and uniqueness constraints akin to ID/IDREF in XML DTDs, RELAX NG relies on the companion RELAX NG DTD Compatibility specification, which introduces specialized datatypes from the library http://relaxng.org/ns/compatibility/datatypes/1.0. These include ID for unique identifiers, IDREF for single references, and IDREFS for lists of references, applied within attribute patterns to enforce cross-document linking and uniqueness. Validation processors supporting this check that all IDREF values match existing IDs and normalize whitespace in lists, updating the infoset accordingly without altering RELAX NG's core schema language. This modular extension preserves RELAX NG's simplicity while providing key constraints via datatype libraries.

Validation

Validation Mechanism

The validation of an XML document against a RELAX NG schema involves a two-input process: the schema itself, which defines the expected structure and content patterns, and the instance document to be checked. The schema is first loaded and compiled into an internal representation, typically as a set of patterns forming a grammar based on regular tree languages. This compilation resolves references and expands patterns like choices or repetitions into a form suitable for matching, enabling efficient processing without requiring the entire document to be built in memory upfront. Validation commences at the document's , where the schema's start —often a top-level element —is applied. The process recursively traverses the document's , computing "derivatives" of the current with respect to each encountered node, such as start tags, attributes, text content, or child elements. For instance, the derivative of a p with respect to a node x yields a new that matches the remaining after x has been consumed, allowing step-by-step expansion and matching. This derivative-based approach, grounded in finite , ensures that the validation proceeds in a deterministic manner for unambiguous schemas, recursively descending into child while verifying attributes, data types, and . If a mismatch occurs—such as an unexpected element, incorrect attribute value, or violation of required —the process identifies the by reaching a notAllowed state, pinpointing issues like deviations or type failures. Error reporting focuses on actionable diagnostics, such as "expected element 'foo' but found 'bar'" or "attribute 'id' must match datatype 'ID'", derived from the context of the failed pattern derivative. This granular feedback aids developers in correcting structural or content violations without needing to reparse the entire document. Due to RELAX NG's foundation in regular languages, the mechanism supports streaming validation, processing the document linearly in a single pass over its serialized form, which is particularly useful for large or incrementally generated XML streams. A practical workflow for validation uses tools like Jing, an open-source RELAX NG validator. For example, to check an XML instance file document.xml against a compact schema.rnc, the command jing schema.rnc document.xml is executed; if valid, it exits silently with status 0, otherwise outputting detailed error messages to standard output with exit status 1. This command-line approach integrates easily into build pipelines or scripts, handling both XML and compact syntax schemas.

Determinism and Ambiguity

RELAX NG schemas are inherently capable of expressing non-deterministic content models, where a single XML document may match a pattern in multiple distinct ways. This arises primarily from the use of choice patterns, which allow overlapping alternatives, and interleave patterns, which permit elements in arbitrary orders without enforcing a unique sequence. Unlike strictly deterministic systems, RELAX NG does not require schemas to guarantee a unique derivation for every valid document, prioritizing expressive power for modeling complex structures. In choice patterns, ambiguity occurs when multiple branches can consume the same input sequence; validation proceeds by attempting alternatives in the order they appear in the schema, succeeding on the first viable match (first-success rule). For example, a schema defining an element as either containing a single text node or a sequence of two text nodes with identical content would accept the input in either interpretation, without preferring one over the other beyond the evaluation order. This approach simplifies implementation while allowing schemas that capture real-world variability, such as optional refinements in data formats. Interleave patterns introduce further non-determinism by allowing permutations of child elements, where the validator must explore all possible orderings to confirm a match. Consider a pattern interleaving an "" element and zero or more "keyword" elements; a document with "author" followed by "keyword" would match, as would "keyword" preceding "author," with the engine trying combinations until success or failure. While this enables flexible modeling of unordered collections, it can result in exponential for deeply nested interleaves, though practical implementations mitigate this via optimizations like computation. The allowance for such provides significant flexibility in design, facilitating the representation of intricate grammars that reflect natural ambiguities, such as mixed-order metadata. However, it carries the risk of inconsistent application behaviors across validators, particularly if assumes a unique match; authors must therefore exercise care to avoid unintended multiple interpretations that could lead to validation discrepancies. Detection algorithms exist to identify ambiguous grammars proactively, ensuring robust maintenance.

Comparisons

With W3C XML Schema

RELAX NG and W3C were developed concurrently, both achieving specification status in , with the RELAX NG OASIS Committee Specification finalized on December 3 and XML Schema Part 1 on May 2. Despite this timeline, RELAX NG emphasizes simplicity by avoiding XML Schema's intricate type hierarchies and derivation mechanisms, which can complicate schema authorship and maintenance. This design choice makes RELAX NG more concise and semantically straightforward for defining XML structures, prioritizing pattern-based expressions over XML Schema's component-oriented approach. Adoption patterns diverge significantly between the two. W3C XML Schema remains dominant in enterprise environments due to its extensive tool support and integration with industry standards, backed by major vendors. In contrast, RELAX NG finds preference in document-centric publishing workflows, powering schemas for formats like , the (TEI) Guidelines, , and . These applications leverage RELAX NG's readability and flexibility for content markup. In terms of features, RELAX NG lacks XML Schema's substitution groups, which enable polymorphic element replacement based on a head element. However, it excels in unambiguous namespace handling, treating namespaces as integral to patterns without the wildcard complexities that can lead to validation ambiguities in XML Schema. RELAX NG also offers superior modularity through mechanisms like the include and div elements, allowing schemas to reference and extend external modules seamlessly for reusable vocabularies. As of 2025, RELAX NG maintains stability in legacy XML workflows, particularly within publishing tools like and XMLmind, where it supports validation and authoring for established document standards. Its use has diminished in emerging JSON/XML hybrid environments, where XML Schema's broader ecosystem and adaptations for modern data interchange prevail.

With DTDs

RELAX NG offers significant improvements over Document Type Definitions (DTDs) in XML validation by providing native support for XML , which DTDs handle through awkward prefix-based mechanisms that do not recognize namespace URIs as the primary identifiers. In DTDs, namespace declarations must be mimicked using parameter entities or conditional sections, leading to brittle and non-portable schemas, whereas RELAX NG directly uses qualified names tied to namespace URIs for precise matching. This namespace awareness enables RELAX NG to support extensible and modular schemas without the hacks required in DTDs, such as those needed for documents involving multiple vocabularies like or RDF. Another key advantage is RELAX NG's richer datatyping capabilities, which extend far beyond the limited options in DTDs, such as #PCDATA, , or enumerated tokens. RELAX NG integrates external datatype libraries, including those from W3C , allowing uniform specification of types like integers, strings with length constraints, or unions for both element content and attribute values. This decoupling from fixed built-in types addresses DTDs' inability to express complex constraints, such as or derivations, enabling more precise validation of structured data. RELAX NG also overcomes DTD limitations in modularity and pattern expressiveness by supporting clean includes and composable patterns that resemble regular expressions. Unlike DTDs, which rely on entities for but impose ordering constraints and flattening requirements, RELAX NG allows definitions to be included and overridden in any order within grammars, facilitating maintainable, context-dependent content models. Its patterns support interleaving for unordered content and choice operators that close under union, providing regex-like flexibility for sequences, repetitions, and alternatives that DTDs' rigid & and | operators cannot fully capture without ambiguity or loss of precision. Converting between RELAX NG and DTDs is feasible in one direction—DTDs can be automatically translated to RELAX NG schemas—but the reverse is often lossy due to RELAX NG's advanced features, such as full interleave semantics or namespace-independent name classes, which have no direct equivalents in DTD syntax. The RELAX NG DTD Compatibility specification addresses some gaps by allowing annotations for DTD-specific behaviors like attribute defaults or ID/IDREF validation, but core RELAX NG validation remains focused on schema constraints without modifying the document infoset. In practice, DTDs persist primarily for legacy XML systems where simplicity and broad tool support are prioritized, while RELAX NG is preferred for developing precise, maintainable schemas in modern structured documents, such as those in or data exchange standards. This shift underscores RELAX NG's role in evolving beyond DTDs' foundational but restrictive paradigm, much like how it complements W3C in namespace-aware validation.

Implementations

Tools and Validators

Jing, developed by in 2002, serves as the primary RELAX NG validator, implemented in and supporting both XML and compact syntaxes through its command-line interface and API for programmatic integration. It enables efficient validation of XML documents against RELAX NG schemas, with features including pluggable datatype libraries and compatibility with SAX2 parsers for streaming validation. For schema authoring and editing, oXygen XML Editor provides comprehensive RELAX NG support, including a visual schema editor, content completion assistant, and specialized views for elements, attributes, and constraints, alongside validation for both syntaxes. Similarly, Altova XMLSpy offers RELAX NG validation capabilities through its associated command-line tool AltovaXML, facilitating schema checking in development workflows, though primary editing focuses on graphical views for related schema languages. RELAX NG validation is integrated into libraries such as Apache Xerces, where configurations like enable parser-based schema enforcement during XML processing. In the .NET ecosystem, libraries like dotnet-dsdl provide RELAX NG validation readers, allowing programmatic checks against schemas in C# applications via XmlReader extensions. As of 2025, RELAX NG tools like Jing are incorporated into IDEs such as through plugins that offer on-the-fly validation, error checking, and content completion for XML projects using RELAX NG schemas. Extensions for pipelines, including Actions and Jenkins, leverage Jing's to automate schema validation in build processes, ensuring document compliance during . Converters like Trang complement these tools by enabling format translations for broader . Other notable validators include the Multi-Schema Validator (MSV), a library for validating against RELAX NG and other schema languages, and librelaxng, a implementation for integrating RELAX NG validation into C-based applications.

Converters and Integrations

One prominent converter for RELAX NG schemas is Trang, developed by , which facilitates interconversion between RELAX NG (in both XML and compact syntaxes) and other schema languages such as DTDs and . Trang processes schemas by first converting them to an intermediate RELAX NG object model, applying necessary transformations, and then generating the target format, enabling seamless integration into environments that rely on alternative schema standards. For specific use cases, custom tools have been developed to generate parsers from RELAX NG schemas, such as grammars for XKB configuration files. Integrations with Schematron enhance RELAX NG by embedding rule-based constraints for co-occurrence and semantic validations that go beyond structural patterns, often achieved through annotations in the RELAX NG XML syntax or direct embedding of Schematron rules within elements. This combination is particularly useful for enforcing rules in complex documents, where RELAX NG handles content models and Schematron addresses interdependencies. In broader XML ecosystems, RELAX NG integrates into pipelines via standards like XProc, which includes a dedicated p:validate-with-relax-ng step to apply schema validation within processing workflows, ensuring document conformance during transformations or data flows. Similarly, in publishing tools, leverages RELAX NG schemas for vocabulary definition, with XSL stylesheets incorporating validation extensions to enforce schema rules during document processing and output generation. These integrations promote RELAX NG's use in modular XML authoring and automated workflows. RELAX NG schemas conventionally use the .rng for the XML syntax and .rnc for the compact syntax, though these are not strictly enforced and serve primarily as identification aids in tools like converters and editors.

References

  1. https://relaxng.org/spec-20011203.html
  2. https://relaxng.org/compact-20021121.html
  3. https://relaxng.org/
  4. https://www.oasis-open.org/committees/relax-ng/
  5. https://relaxng.org/jclark/design.html
  6. https://upg-dh.newtfire.org/explainRNG.html
  7. https://relaxng.org/tutorial-20011203.html
  8. https://www.oasis-open.org/committees/relax-ng/compact-20021121.html
  9. https://www.oasis-open.org/committees/relax-ng/tutorial.html
  10. https://www.oasis-open.org/committees/relax-ng/charter.php
  11. http://www.xml.gr.jp/relax/cs.html
  12. http://www.xml.gr.jp/relax/
  13. http://www.thaiopensource.com/trex/tutorial.html
  14. https://dl.acm.org/doi/10.1145/604131.604132
  15. https://www.oasis-open.org/2001/03/12/oasis-forms-trex-technical-committee-to-create-xml-document-validation-language-specificatio/
  16. https://www.oasis-open.org/2001/06/04/oasis-unites-trex-and-relax-to-create-lightweight-xml-language-validation-specification/
  17. https://www.oasis-open.org/standard/relaxng-spec/
  18. https://www.oasis-open.org/committees/relax-ng/spec-20010917.html
  19. https://www.iso.org/standard/37605.html
  20. https://www.iso.org/standard/40774.html
  21. https://www.iso.org/standard/52348.html
  22. https://www.xml.com/pub/a/2002/06/19/rng-compact.html
  23. https://relaxng.org/compact-tutorial-20030326.html
  24. https://relaxng.org/tutorial-20030326.html
  25. https://relaxng.org/xsd-20010907.html
  26. https://relaxng.org/compatibility-20011203.html
  27. https://relaxng.org/jclark/derivative.html
  28. https://github.com/relaxng/jing-trang
  29. https://www.oreilly.com/library/view/relax-ng/0596004214/ch16s01.html
  30. https://www.kohsuke.org/relaxng/ambiguity/AmbiguousGrammarDetection.pdf
  31. https://www.xml.com/pub/a/2001/12/12/schemacompare.html
  32. https://stackoverflow.com/questions/4994875/relaxng-vs-xml-schema
  33. https://docbook.org/docs/howto/2007-10-28/howto
  34. https://www.tei-c.org/release/doc/tei-p5-doc/en/html/SG.html
  35. https://documentation.censhare.com/classic-2/latest/Public/relaxng-xml-schema-language
  36. https://www.oxygenxml.com/
  37. https://www.xmlmind.com/xmleditor/_distrib/doc/rngsupport/index.html
  38. https://moldstud.com/articles/p-interoperability-in-xml-avoiding-common-pitfalls-in-2025
  39. https://relaxng.org/jclark/jing.html
  40. https://www.oxygenxml.com/relaxng_schema_editor.html
  41. https://github.com/atsushieno/dotnet-dsdl
  42. https://plugins.jetbrains.com/plugin/1783-relax-ng-support
  43. https://msv.dev.java.net/
  44. https://relaxng.org/jclark/trang.html
  45. https://relaxng.org/jclark/convert-to-xsd-talk.html
  46. https://blog.simos.info/antlr-grammar-for-xkb-and-relax-ng-schema-draft/
  47. https://www.xml.com/pub/a/2004/02/11/relaxtron.html
  48. https://www.oxygenxml.com/doc/ug-editor/topics/combined_RNG_and_SCH.html
  49. https://xprocref.org/3.0/p.validate-with-relax-ng.html
  50. https://xsltng.docbook.org/guide/2.1.6/ext_validate-with-relax-ng
  51. https://relaxng.org/jclark/trang-manual.html
Add your contribution
Related Hubs
User Avatar
No comments yet.