ReqIF requirements format

ReqEdit Online Documentation

ReqIF requirements format

5 min read
last updated: 09/06/2021

RIF/ReqIF (Requirements Interchange Format) is an XML file format suitable for lossless exchange of requirements in any industry.

The old way of transmitting requirements were lossy like Office Documents, PDF or Spreadsheets, ReqIF offers solutions to keep the data integrity through the supply-chain.

Can be used to exchange requirements, along with its associated metadata, between software tools from different vendors. The requirements exchange format also defines a workflow for transmitting the status of requirements between partners.

The format is excellent for exchanging requirements, attributes, additional files (e.g. images) across the supply-chain. Each object is uniquely identified by GUID, ensures unique content across the data exchange processes.

GUID: globally unique identifier inside a RIF / ReqIF file

The interchange standard

Main players of the automotive industry in Germany agreed to conform to the RIF/ReqIF joint standard, initially developed by HIS Group, ProSTEP iViP, now maintained by OMG.

The HIS group is the panel of the vehicle manufacturers Audi AG, BMW Group, Daimler AG, Porsche AG, and Volkswagen AG

The group that is working on the initial release of ReqIF consists of the ProSTEP iViP Association, Atego Systems GmbH, Audi AG, BMW AG, Continental AG, Daimler AG, HOOD GmbH, International Business Machines, MKS GmbH, PROSTEP AG, Robert Bosch GmbH, and Volkswagen AG.

Currently all major ALM/PLM tools (PTC Integrity, IBM Doors, Dassault Rectify, Intland Codebeamer, IBM DNG …) support ReqIF format with minor differences.


  • 2004 – HIS (Herstellerinitiative Software) defined a generic requirements interchange format called RIF
  • 2008 – The RIF format was handed over to ProSTEP, than after further development to OMG
  • 2010 – OMG renamed the format to ReqIF to deal with a naming collision with W3C RIF
  • 2011 – ReqIF 1.0.1 was adopted as a formal specification
  • 2013 – ReqIF 1.1 updated the documentation of the standard, 1.1 and 1.0.1 are equivalent
  • 2016 – ReqIF 1.2 updated the documentation of the standard, remaining equivalent to 1.1 and 1.0.1

Links to OMG website: ReqIF 1.2 specification and the ReqIF 1.2 file format

Features of requirement files

FeatureReqIF format
Structure specifications hierarchicallyReqIF provides the concept of a specification that contains a hierarchical structure of requirement objects
Use formatted text in specificationsAs representing formatted text is a potentially complex topic, ReqIF re-uses a subset of W3C’s XHTML modules to ease implementation of the format. XHTML content MAY be used in specific attribute values
Reference binary filesTo allow referencing binary files from within an attribute value that contains formatted text, XHTML is used as a mechanism as well
Uniquely identify requirementsReqIF provides an identification mechanism for requirements through GUID
Associate attributes with requirementsReqIF allows to attach attributes to requirements. The definition of the attributes (the attribute name, the attribute data type etc.) is separated from the attribute value
Establish relations between requirementsReqIF represents relations with a freely definable semantic
Group relationsReqIF allows grouping of relationships
Restrict user access to certain informationReqIF allows to specify that certain information elements are not editable

ReqIF handling in different tools

There is no “unified language” for requirements that all requirement authoring tools support, and therefore, there is also no meta-model shared between requirement authoring tools.

Requirement authoring tools use different naming for the same conceptReqIF includes only a limited collection of concepts, but provides an (informal) mapping to various requirement authoring tools on the market
When users of two different brands of requirement authoring tools exchange specifications, information may get lost due to the different capabilities of the toolsFor concepts that are individual features of a certain requirement authoring tool, ReqIF offers the concept of tool extensions

Naming conventions and ReqEdit

In ReqEdit the naming of specific entities can differ from the standard to be more user friendly, here is an overview of such names:

ReqIF, RIF, ReqIF Archive – represents a requirement exchange file that can contain one or more specification documents

Specification Document, Document, Documents – a collection of requirements inside a ReqIF file

Requirement Objects, Objects – the atomic part of a requirement exchange file, this is the building block of a specification

Attributes – objects can have one or more attributes which are properties of a requirement

Attribute type – can be a specific configuration of the basic types of boolean, date, enumeration, integer, real, string, xhtml

Structure of ReqIF files

Overview of a ReqIF file, element names are a conceptual representation of the standard

An OMG ReqIF file consists of XML with the root element REQ-IF, containing information regarding the file itself as well as the contained datatypes and requirements.

Documents (Specifications)

The format permits the usage of one or more specifications in one single ReqIF file. These documents can have their own attributes.

Hierarchical trees create a structured view on SpecObjects, called Specifications. Multiple references on the same SpecObject are permitted. Relations are stored inside SpecHierarchy elements

Objects (SpecObject)

The containers for requirements in ReqIF are called specification objects (SpecObject), which have user-defined attributes.


Each attribute has a data type, which is one of Boolean, Integer, Real, String, Enumeration (with user-defined values) and XHTML, which is also for formatted text and embedded objects, including images. Some datatypes can be constrained further, e.g. the range of numerical values.

Relations between objects

Relationships between objects are represented as SpecRelations, which can also have attributes.


Is built up from a collection of requirement objects organized in a hierarchical structure. Specifications can have its own attributes.

ReqIF files can be single spec or multi spec files depending of how many specifications will there be inside.

Each specification has its own Spec Type that describe the available specification attributes.

ReqEdit currently is not displaying the Spec Types. Each specification document is a separate spec type and it cannot be reused.

Requirement objects

Are the equivalent of paragraphs in a document, these are the individual building blocks. Each requirement uses its own SpecObjectType with a defined set of attributes. The object types are defined inside Specification and cannot be reused in other specifications.

Object types are a good way to organize information inside the specification.

ReqEdit currently is not displaying the objects types, these are used only internally. Each specification will have its own object type that is used for its requirement objects.


Additional structured information can be attached to each requirement object. This is the most powerful feature of ReqIF format. The attributes can have its own attribute types defining value ranges, content lengths or other options. The restrictions and the clear data type definitions represents the basis of lossless data exchange.

ReqIF Required Attributes

To be able to display common content across workflow, ReqIF standard specifies attributes that has to be included in the file.

ReqIF.IDglobally unique identifier
ReqIF.Texttype: Text
the main content of the spec object
ReqIF.ChapterNametype: Text
displayed as a heading, usually it will be numbered
ReqIF.Nametype: Text
type: Boolean
deleted flag


Objects can be linked from one to another, providing an alternate way for navigating the process flow. Links can be grouped in Spec Relation Groups, that can define specific workflow directions, offering a way for traceability.


The values itself are the content of the whole ReqIF specification. The requirements and the attributes can be highly refined to leave the least chance for errors.