Skip to main content
skill CX Codex

rvt-to-ifc — Claude Code skill: what it does, how to install

rvt-to-ifc converts Revit RVT models into open IFC format without an Autodesk license. Supports IFC2x3, IFC4, and IFC4.3 schemas with batch processing.

MIT 143 installs ★ 434 updated 2026-10-19

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill rvt-to-ifc -a claude-code
Open on GitHub

What rvt-to-ifc does

The skill manages RVT to IFC conversions using the RVT2IFCconverter.exe command-line utility. It runs offline without requiring Autodesk licenses or Revit installations. Users can select IFC2x3 for compatibility with older software, IFC4 for standard workflows, or IFC4.3 for infrastructure models.

A Python integration wrapper handles batch processing across directories and runs basic output checks, verifying headers for ISO-10303-21. The export behavior can be tuned with standard and extended presets, or configured directly with options like ExportBaseQuantities and SitePlacement.

Execution requires Windows (win32) with python3 and RVT2IFCconverter.exe available on the system.

What it helps with

  • Convert Revit RVT models to IFC without Autodesk licenses
  • Generate IFC files under IFC2x3, IFC4, or IFC4.3 schemas
  • Batch process entire directories containing RVT projects
  • Pass custom export settings such as base quantities and shared coordinates

Example prompts for the agent

  • Convert Building.rvt to IFC using the extended preset
  • Batch convert all RVT files in C:\Projects into D:\Export
  • Export model.rvt to IFC4 with ExportBaseQuantities=true

How to install rvt-to-ifc

1Skills CLI (Vercel)

npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill rvt-to-ifc -a claude-code

2Manually: put the files in place

~/.claude/skills/rvt-to-ifc/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/rvt-to-ifc/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about rvt-to-ifc

How to install rvt-to-ifc in Claude Code?

Run npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill rvt-to-ifc -a claude-code. The skill file will be created at ~/.claude/skills/rvt-to-ifc/SKILL.md.

What does rvt-to-ifc do?

It converts Autodesk Revit (.rvt) files into standard IFC format. The skill runs the offline CLI converter with configurable schemas and presets.

Does rvt-to-ifc require Revit or an Autodesk license?

No Autodesk software or license is required. However, the tool runs exclusively on Windows (win32) and needs python3 alongside RVT2IFCconverter.exe.

Source text

SKILL.md · MIT
---
name: "rvt-to-ifc"
description: "Convert RVT files to IFC format. Support IFC2x3, IFC4, IFC4.3 with customizable export settings."
homepage: "https://datadrivenconstruction.io"
metadata: {"openclaw":{"emoji":"🔄","os":["win32"],"homepage":"https://datadrivenconstruction.io","requires":{"bins":["python3","RvtExporter"]}}}
---

# RVT to IFC Conversion

> **Note:** RVT is the file format. IFC is an open standard by buildingSMART International.

## Business Case

### Problem Statement
IFC is the open BIM standard for interoperability, but:
- Native Revit IFC export requires Autodesk license
- Export settings significantly affect data quality
- Batch processing is manual and time-consuming

### Solution
RVT2IFCconverter.exe converts Revit files to IFC offline, without licenses, with full control over export settings.

### Business Value
- **No license required** - Works without Autodesk software
- **Multiple IFC versions** - IFC2x3, IFC4, IFC4.3 support
- **Batch processing** - Convert thousands of files
- **Consistent quality** - Standardized export settings

## Technical Implementation

### CLI Syntax
```bash
RVT2IFCconverter.exe <input.rvt> [<output.ifc>] [preset=<name>] [config="..."]
```

### IFC Versions
| Version | Use Case |
|---------|----------|
| IFC2x3 | Legacy compatibility, most software |
| IFC4 | Enhanced properties, modern BIM |
| IFC4.3 | Infrastructure, latest standard |

### Export Presets
| Preset | Description |
|--------|-------------|
| `standard` | Default balanced export |
| `extended` | Maximum detail and properties |
| `custom` | User-defined configuration |

### Examples

```bash
# Standard IFC export
RVT2IFCconverter.exe "C:\Projects\Building.rvt"

# IFC4 with extended settings
RVT2IFCconverter.exe "C:\Projects\Building.rvt" preset=extended

# Custom output path
RVT2IFCconverter.exe "C:\Projects\Building.rvt" "D:\Export\model.ifc"

# Custom configuration
RVT2IFCconverter.exe "C:\Projects\Building.rvt" config="ExportBaseQuantities=true; SitePlacement=Shared"
```

### Python Integration

```python
import subprocess
from pathlib import Path
from typing import List, Optional, Dict, Any
from dataclasses import dataclass
from enum import Enum


class IFCVersion(Enum):
    """IFC schema versions."""
    IFC2X3 = "IFC2x3"
    IFC4 = "IFC4"
    IFC4X3 = "IFC4x3"


class ExportPreset(Enum):
    """Export presets."""
    STANDARD = "standard"
    EXTENDED = "extended"
    CUSTOM = "custom"


@dataclass
class IFCExportConfig:
    """IFC export configuration."""
    ifc_version: IFCVersion = IFCVersion.IFC4
    export_base_quantities: bool = True
    site_placement: str = "Shared"
    split_walls_and_columns: bool = False
    include_steel_elements: bool = True
    export_2d_elements: bool = False
    export_linked_files: bool = False
    export_rooms: bool = True
    export_schedules: bool = True

    def to_config_string(self) -> str:
        """Convert to CLI config string."""
        parts = [
            f"ExportBaseQuantities={str(self.export_base_quantities).lower()}",
            f"SitePlacement={self.site_placement}",
            f"SplitWallsAndColumns={str(self.split_walls_and_columns).lower()}",
            f"IncludeSteelElements={str(self.include_steel_elements).lower()}",
            f"Export2DElements={str(self.export_2d_elements).lower()}",
            f"ExportLinkedFiles={str(self.export_linked_files).lower()}",
            f"ExportRooms={str(self.export_rooms).lower()}"
        ]
        return "; ".join(parts)


class RevitToIFCConverter:
    """Convert Revit files to IFC format."""

    def __init__(self, converter_path: str = "RVT2IFCconverter.exe"):
        self.converter = Path(converter_path)
        if not self.converter.exists():
            raise FileNotFoundError(f"Converter not found: {converter_path}")

    def convert(self, rvt_file: str,
                output_path: Optional[str] = None,
                preset: ExportPreset = ExportPreset.STANDARD,
                config: Optional[IFCExportConfig] = None) -> Path:
        """Convert Revit file to IFC."""

        rvt_path = Path(rvt_file)
        if not rvt_path.exists():
            raise FileNotFoundError(f"Revit file not found: {rvt_file}")

        # Build command
        cmd = [str(self.converter), str(rvt_path)]

        # Add output path if specified
        if output_path:
            cmd.append(output_path)

        # Add preset
        cmd.append(f"preset={preset.value}")

        # Add custom config if provided
        if config:
            cmd.append(f'config="{config.to_config_string()}"')

        # Execute
        result = subprocess.run(cmd, capture_output=True, text=True)

        if result.returncode != 0:
            raise RuntimeError(f"Conversion failed: {result.stderr}")

        # Return output path
        if output_path:
            return Path(output_path)
        return rvt_path.with_suffix('.ifc')

    def batch_convert(self, folder: str,
                      output_folder: Optional[str] = None,
                      preset: ExportPreset = ExportPreset.STANDARD,
                      config: Optional[IFCExportConfig] = None) -> List[Dict[str, Any]]:
        """Convert all Revit files in folder."""

        folder_path = Path(folder)
        results = []

        for rvt_file in folder_path.glob("**/*.rvt"):
            try:
                # Determine output path
                if output_folder:
                    out_dir = Path(output_folder)
                    out_dir.mkdir(parents=True, exist_ok=True)
                    output_path = str(out_dir / rvt_file.with_suffix('.ifc').name)
                else:
                    output_path = None

                ifc_path = self.convert(str(rvt_file), output_path, preset, config)
                results.append({
                    'input': str(rvt_file),
                    'output': str(ifc_path),
                    'status': 'success'
                })
                print(f"✓ Converted: {rvt_file.name}")

            except Exception as e:
                results.append({
                    'input': str(rvt_file),
                    'output': None,
                    'status': 'failed',
                    'error': str(e)
                })
                print(f"✗ Failed: {rvt_file.name} - {e}")

        return results

    def validate_output(self, ifc_file: str) -> Dict[str, Any]:
        """Basic validation of generated IFC."""

        ifc_path = Path(ifc_file)
        if not ifc_path.exists():
            return {'valid': False, 'error': 'File not found'}

        # Basic file checks
        file_size = ifc_path.stat().st_size

        if file_size < 1000:
            return {'valid': False, 'error': 'File too small'}

        # Read header
        with open(ifc_file, 'r', errors='ignore') as f:
            header = f.read(1000)

        # Check IFC format
        if 'ISO-10303-21' not in header:
            return {'valid': False, 'error': 'Not a valid IFC file'}

        # Detect version
        version = 'Unknown'
        if 'IFC4X3' in header:
            version = 'IFC4.3'
        elif 'IFC4' in header:
            version = 'IFC4'
        elif 'IFC2X3' in header:
            version = 'IFC2x3'

        return {
            'valid': True,
            'file_size': file_size,
            'ifc_version': version
        }


class IFCQualityChecker:
    """Check quality of IFC exports."""

    def __init__(self, converter: RevitToIFCConverter):
        self.converter = converter

    def compare_presets(self, rvt_file: str) -> Dict[str, Any]:
        """Compare different export presets."""

        results = {}

        for preset in [ExportPreset.STANDARD, ExportPreset.EXTENDED]:
            try:
                output = Path(rvt_file).with_suffix(f'.{preset.value}.ifc')
                self.converter.convert(rvt_file, str(output), preset)

                validation = self.converter.validate_output(str(output))
                results[preset.value] = {
                    'file_size': validation.get('file_size', 0),
                    'valid': validation.get('valid', False)
                }
            except Exception as e:
                results[preset.value] = {'error': str(e)}

        return results


# Convenience functions
def convert_revit_to_ifc(rvt_file: str,
                         converter_path: str = "RVT2IFCconverter.exe") -> str:
    """Quick conversion of Revit to IFC."""
    converter = RevitToIFCConverter(converter_path)
    output = converter.convert(rvt_file)
    return str(output)


def batch_convert_to_ifc(folder: str,
                         converter_path: str = "RVT2IFCconverter.exe") -> List[str]:
    """Batch convert all Revit files to IFC."""
    converter = RevitToIFCConverter(converter_path)
    results = converter.batch_convert(folder)
    return [r['output'] for r in results if r['status'] == 'success']
```

## Quick Start

```python
# Initialize converter
converter = RevitToIFCConverter("C:/DDC/RVT2IFCconverter.exe")

# Basic conversion
ifc = converter.convert("building.rvt")
print(f"Created: {ifc}")

# With custom config
config = IFCExportConfig(
    ifc_version=IFCVersion.IFC4,
    export_base_quantities=True,
    export_rooms=True
)
ifc = converter.convert("building.rvt", preset=ExportPreset.CUSTOM, config=config)
```

## Common Use Cases

### 1. Batch Processing
```python
converter = RevitToIFCConverter()
results = converter.batch_convert(
    folder="C:/Projects",
    output_folder="C:/IFC_Export",
    preset=ExportPreset.EXTENDED
)
print(f"Converted {len([r for r in results if r['status'] == 'success'])} files")
```

### 2. Quality Check
```python
validation = converter.validate_output("model.ifc")
print(f"Valid: {validation['valid']}, Version: {validation['ifc_version']}")
```

### 3. Compare Presets
```python
checker = IFCQualityChecker(converter)
comparison = checker.compare_presets("building.rvt")
print(comparison)
```

## Resources

- **GitHub**: [cad2data Pipeline](https://github.com/datadrivenconstruction/cad2data-Revit-IFC-DWG-DGN-pipeline-with-conversion-validation-qto)
- **buildingSMART IFC**: https://www.buildingsmart.org/standards/bsi-standards/industry-foundation-classes/

© datadrivenconstruction · MIT · datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction

Similar skills

All skills for Automation and no-code: n8n, Zapier, Make →

From the same set156

The whole set →
bim-cost-estimation-cwicr bim-cost-estimation-cwicr is a Claude Code skill that estimates construction costs from BIM models using the DDC CWICR database. The agent uses it to price work from Revit or IFC data. CX Codex +1 146installs qto-report qto-report extracts volumes, areas, and element counts from BIM and CAD exports, groups quantities, and calculates cost estimates. Useful for building quantity take-offs. CX Codex +1 143installs bim-validation-pipeline The bim-validation-pipeline skill helps validate IFC models for geometry, property, relationship, and naming issues. Use it to check model data against project requirements. CX Codex +1 143installs bid-analysis-comparator bid-analysis-comparator scores contractor bids against weighted criteria, ranks them by total and writes the comparison to an Excel file. CX Codex +1 143installs critical-path-analyzer critical-path-analyzer analyzes project schedule networks to calculate the critical path, determine float values, and identify near-critical tasks that risk delaying deadlines. CX Codex +1 141installs drone-site-survey drone-site-survey processes drone survey data for construction sites: generates orthomosaics, calculates stockpile volumes, and links survey data with BIM models. CX Codex +1 141installs budget-variance-analyzer budget-variance-analyzer is a skill for Claude Code that compares budget figures with actual costs, flags overruns, and forecasts a project's final cost. It tracks spending variances by project line item. CX Codex +1 139installs cwicr-cost-calculator The cwicr-cost-calculator skill calculates construction costs using CWICR resource-based methodology, separating labor, materials, and equipment expenses into auditable components. CX Codex +1 138installs

Project sponsors

Companies that keep this analytics open