Technical reference for IDS file structure, checking tool integration, and programmatic workflows.

IDS File Format

IDS (Information Delivery Specification) files are XML documents with the .ids extension. They follow a schema defined by buildingSMART International.

Basic Structure

<?xml version="1.0" encoding="UTF-8"?>
<ids xmlns="http://standards.buildingsmart.org/IDS"
     xmlns:xs="http://www.w3.org/2001/XMLSchema"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://standards.buildingsmart.org/IDS http://standards.buildingsmart.org/IDS/1.0/ids.xsd">
  <info>
    <!-- File metadata -->
  </info>
  <specifications>
    <!-- Individual specifications -->
  </specifications>
</ids>

Info Section (Metadata)

<info>
  <title>Fire Safety Requirements</title>
  <copyright>ACME Corp 2024</copyright>
  <version>1.0.0</version>
  <description>Information requirements for fire safety compliance</description>
  <author>bim@acme.com</author>
  <date>2024-01-15</date>
  <purpose>regulatory</purpose>
  <milestone>design development</milestone>
</info>

Specification Structure

Each specification defines a validation rule:

<specification name="Wall Fire Rating" ifcVersion="IFC4">
  <applicability minOccurs="0" maxOccurs="unbounded">
    <entity>
      <name>
        <simpleValue>IFCWALL</simpleValue>
      </name>
    </entity>
  </applicability>
  <requirements>
    <property dataType="IFCLABEL">
      <propertySet>
        <simpleValue>Pset_WallCommon</simpleValue>
      </propertySet>
      <baseName>
        <simpleValue>FireRating</simpleValue>
      </baseName>
    </property>
  </requirements>
</specification>

Cardinality (minOccurs/maxOccurs)

Value Restrictions in XML

Simple Value

<simpleValue>IFCWALL</simpleValue>

Enumeration

<restriction base="xs:string">
  <enumeration value="1HR"/>
  <enumeration value="2HR"/>
  <enumeration value="3HR"/>
</restriction>

Pattern (Regex)

<restriction base="xs:string">
  <pattern value="[A-Z]{2}-[0-9]{4}"/>
</restriction>

Numeric Bounds

<restriction base="xs:double">
  <minInclusive value="10"/>
  <maxInclusive value="100"/>
</restriction>

Length Constraint

<restriction base="xs:string">
  <minLength value="3"/>
  <maxLength value="50"/>
</restriction>

Supported IFC Versions

IDSedit supports these IFC schemas:

You can specify multiple versions per specification:

<specification ifcVersion="IFC2X3 IFC4 IFC4X3_ADD2">

Validating IDS Files

Schema Validation

IDS files must validate against the official XSD schema:

# Using xmllint (Linux/Mac)
xmllint --schema ids.xsd your-file.ids --noout

# Using Python
from lxml import etree
schema = etree.XMLSchema(etree.parse('ids.xsd'))
doc = etree.parse('your-file.ids')
schema.validate(doc)

Semantic Validation

Beyond schema compliance, IDS files should be semantically correct:

• Entity names must be valid IFC classes
• Property sets should exist for the targeted IFC version
• Data types must be valid IFC types

Use these tools for comprehensive validation:

• buildingSMART IDS Audit Tool
• Xbim IDS Validator (browser-based, runs locally)

IDSedit Export

IDSedit exports fully compliant IDS files:

Export Features

• Valid XML with proper namespace declarations
• Schema-compliant structure
• Properly escaped special characters
• UTF-8 encoding

Export Options

• Single file - All specifications in one .ids file
• Individual files - One specification per file (for modular requirements)

Integration Workflows

Model Checking Pipeline

IDS-Compatible Checking Tools

modelcheck.opensource.construction

An open-source web-based modelchecker that validates IFC models against basic rules and IDS specifications. Upload your IFC and IDS files to check compliance directly in the browser.

For a complete list of software that supports IDS, see the official buildingSMART IDS Software Implementations page.

BCF Integration

IDS checking results are typically exported as BCF (BIM Collaboration Format):

<Topic>
  <Title>Wall missing FireRating property</Title>
  <Description>Element #123 does not have required Pset_WallCommon.FireRating</Description>
  <ReferenceLink>specification:FIRE-001</ReferenceLink>
</Topic>

Programming with IDS

Python Example (IfcOpenShell)

import ifcopenshell
import ifcopenshell.ids

# Load IDS and IFC
ids_file = ifcopenshell.ids.open('requirements.ids')
ifc_file = ifcopenshell.open('model.ifc')

# Check compliance
results = ids_file.validate(ifc_file)

# Process results
for spec_result in results:
    print(f"Specification: {spec_result.specification.name}")
    for element_result in spec_result.elements:
        if not element_result.is_pass:
            print(f"  FAIL: {element_result.element}")
            for req_result in element_result.requirements:
                if not req_result.is_pass:
                    print(f"    - {req_result.message}")

JavaScript/TypeScript

// Using web-ifc or similar library
import { IdsParser, IdsChecker } from 'ids-lib';

const ids = await IdsParser.parse(idsXml);
const ifc = await loadIfc(ifcFile);

const results = IdsChecker.check(ids, ifc);
results.specifications.forEach(spec => {
  console.log(`${spec.name}: ${spec.pass ? 'PASS' : 'FAIL'}`);
});

.NET Example (Xbim)

using Xbim.IDS;
using Xbim.Ifc;

var ids = IdsDocument.Load("requirements.ids");
var model = IfcStore.Open("model.ifc");

var results = ids.Validate(model);
foreach (var result in results)
{
    Console.WriteLine($"{result.Specification.Name}: {result.Status}");
}

Best Practices

IDS Authoring

1. Use meaningful names - Specifications should have clear, descriptive names
2. Include instructions - Help model authors understand how to comply
3. Test thoroughly - Validate against sample IFC files before deployment
4. Version control - Track changes to requirements over time
5. Modular design - Create reusable specification sets by discipline

IDS Checking

1. Check early, check often - Integrate into CI/CD pipelines
2. Report clearly - Provide actionable feedback to model authors
3. Track trends - Monitor compliance improvement over time

Interoperability

1. Stick to the standard - Avoid proprietary extensions
2. Test with multiple tools - Ensure IDS works across different checkers
3. Document assumptions - Note which IFC versions are targeted

Troubleshooting

Common Issues

Debugging Tips

1. Start with a simple specification and add complexity gradually
2. Test with known IFC files that should pass/fail
3. Use verbose output in checking tools to see matching details
4. Validate IDS file independently before checking against IFC

Resources

Official buildingSMART Resources

• IDS Specification Repository
• IDS XSD Schema
• IDS Test Cases
• IDS Implementer Documentation
• IDS Software Implementations

IFC Documentation

• IFC4x3 Documentation
• IFC4 Documentation
• IFC2x3 Documentation

Community & Support

• buildingSMART Forums
• IDS GitHub Issues
• IfcOpenShell Community

Contributing to IDSedit

IDSedit is open source under the AGPL-3 license.

• Report issues: GitHub Issues
• Contribute code: GitHub Repository
• Documentation: Help improve these docs via pull requests