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
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill rvt-to-ifc -a claude-codeWhat 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.rvtto IFC using the extended preset - Batch convert all RVT files in
C:\ProjectsintoD:\Export - Export
model.rvtto IFC4 withExportBaseQuantities=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-code2Manually: put the files in place
~/.claude/skills/rvt-to-ifc/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/rvt-to-ifc/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill rvt-to-ifc -a codex2Manually: put the files in place
.agents/skills/rvt-to-ifc/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill rvt-to-ifc -a cursor2Manually: put the files in place
.cursor/skills/rvt-to-ifc/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction 1_DDC_Toolkit/CAD-Converters/rvt-to-ifc2Manually: put the files in place
.github/skills/rvt-to-ifc/SKILL.md1Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill rvt-to-ifc -a gemini-cli2Platform CLI
gemini skills install https://github.com/datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --path 1_DDC_Toolkit/CAD-Converters/rvt-to-ifcManually: put the files in place
.devin/skills/rvt-to-ifc/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill rvt-to-ifc -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
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