acadrust

A pure Rust library for reading and writing CAD drawing exchange files (DXF).

acadrust provides comprehensive support for the DXF file format with a focus on correctness, type safety, and completeness. Inspired by ACadSharp, this library brings full-featured DXF file manipulation to the Rust ecosystem.

✨ Features

Core Capabilities

• 📖 Read & Write — Full support for both ASCII and Binary DXF formats
• 🔒 Type Safe — Leverages Rust's type system with strongly-typed entities, tables, and objects
• 🌐 Encoding Support — Automatic code page detection and character encoding for pre-2007 files (~40 code pages via encoding_rs)
• 🛡️ Failsafe Mode — Optional error-tolerant parsing that collects diagnostics instead of aborting
• 📋 Notifications — Structured diagnostic system reporting unsupported elements, warnings, and errors
• 🔗 Handle Resolution — Automatic owner handle assignment and handle tracking after read
• ❓ Unknown Entity Preservation — Unrecognized entity types are preserved as UnknownEntity with common fields intact

File Version Support

Supported Entity Types (38)

Table System

Complete support for all standard tables:

Objects (Non-Graphical Elements)

• Dictionary / DictionaryWithDefault — Key-value storage for objects
• DictionaryVariable — Named variable in a dictionary
• Group — Named entity collections
• Layout — Model/paper space layout definitions
• MLineStyle — Multi-line style definitions
• MultiLeaderStyle — Multi-leader style definitions
• TableStyle — Table formatting styles
• PlotSettings — Print/plot configurations
• Scale — Annotation scale definitions
• ImageDefinition / ImageDefinitionReactor — Raster image definitions and reactors
• XRecord — Extended data records
• SortEntitiesTable — Entity draw order
• VisualStyle — 3D visual style definitions
• Material — Material definitions
• GeoData — Geolocation data
• SpatialFilter — Spatial clipping filter
• RasterVariables — Raster display settings
• BookColor — Color book (DBCOLOR) entries
• PlaceHolder — Placeholder objects
• WipeoutVariables — Wipeout display settings

CLASSES Section

Full support for the CLASSES section — reading, storing, and writing DXF class definitions with all standard fields (class name, DXF name, application name, proxy flags, instance count).

Extended Data (XData)

Full support for application-specific extended data:

• String, binary, and numeric values
• 3D points, directions, and displacements
• Layer references and database handles
• Nested data structures with control strings

Reactors & Extension Dictionaries

Full support for entity/object reactor chains (group code 102 {ACAD_REACTORS}) and extension dictionaries ({ACAD_XDICTIONARY}), read and written for all entity and object types.

📦 Installation

Add acadrust to your Cargo.toml:

[dependencies]
acadrust = "0.1.8"

Or install via cargo:

cargo add acadrust

🚀 Quick Start

Reading a DXF File

use acadrust::{CadDocument, DxfReader};

fn main() -> acadrust::Result<()> {
    // Open and read a DXF file
    let doc = DxfReader::from_file("drawing.dxf")?.read()?;
    
    // Access document properties
    println!("Version: {:?}", doc.header().version);
    
    // Iterate over entities in model space
    for entity in doc.entities() {
        println!("Entity: {:?}", entity);
    }
    
    // Check parse notifications
    for note in doc.notifications.iter() {
        println!("[{:?}] {}", note.level, note.message);
    }
    
    Ok(())
}

Reading with Failsafe Mode

use acadrust::{DxfReader};
use acadrust::io::dxf::DxfReaderConfiguration;

fn main() -> acadrust::Result<()> {
    let config = DxfReaderConfiguration { failsafe: true };
    let doc = DxfReader::from_file("drawing.dxf")?
        .with_configuration(config)
        .read()?;
    
    // Even if some sections had errors, the document is partially populated
    println!("Entities read: {}", doc.entities().len());
    println!("Notifications: {}", doc.notifications.len());
    
    Ok(())
}

Writing a DXF File

use acadrust::{CadDocument, DxfWriter, Line, Layer, Vector3};

fn main() -> acadrust::Result<()> {
    // Create a new document
    let mut doc = CadDocument::new();
    
    // Add a layer
    let layer = Layer::new("MyLayer");
    doc.layers_mut().add(layer)?;
    
    // Create and add a line
    let line = Line {
        start: Vector3::new(0.0, 0.0, 0.0),
        end: Vector3::new(100.0, 100.0, 0.0),
        ..Default::default()
    };
    doc.add_entity(line);
    
    // Write to file
    DxfWriter::new(&doc).write_to_file("output.dxf")?;
    
    Ok(())
}

Working with Layers

use acadrust::{CadDocument, Layer, Color};

fn main() -> acadrust::Result<()> {
    let mut doc = CadDocument::new();
    
    // Create a custom layer
    let mut layer = Layer::new("Annotations");
    layer.color = Color::from_index(1); // Red
    layer.is_frozen = false;
    layer.is_locked = false;
    
    doc.layers_mut().add(layer)?;
    
    // Access existing layers
    if let Some(layer) = doc.layers().get("0") {
        println!("Default layer color: {:?}", layer.color);
    }
    
    Ok(())
}

Creating Complex Entities

use acadrust::{CadDocument, LwPolyline, LwVertex, Vector2, Circle, Arc};

fn main() -> acadrust::Result<()> {
    let mut doc = CadDocument::new();
    
    // Create a rectangle using LwPolyline
    let mut polyline = LwPolyline::new();
    polyline.vertices = vec![
        LwVertex { position: Vector2::new(0.0, 0.0), ..Default::default() },
        LwVertex { position: Vector2::new(100.0, 0.0), ..Default::default() },
        LwVertex { position: Vector2::new(100.0, 50.0), ..Default::default() },
        LwVertex { position: Vector2::new(0.0, 50.0), ..Default::default() },
    ];
    polyline.is_closed = true;
    doc.add_entity(polyline);
    
    // Create a circle
    let circle = Circle {
        center: Vector3::new(50.0, 25.0, 0.0),
        radius: 10.0,
        ..Default::default()
    };
    doc.add_entity(circle);
    
    Ok(())
}

🏗️ Architecture

acadrust uses a trait-based design for maximum flexibility and extensibility:

┌──────────────────────────────────────────────────────────────┐
│                       CadDocument                            │
├──────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌──────────────┐  ┌─────────────────────┐ │
│  │   Header    │  │    Tables    │  │      Entities       │ │
│  │  Variables  │  │              │  │                     │ │
│  └─────────────┘  │ - Layers     │  │ - Lines, Circles    │ │
│                   │ - LineTypes  │  │ - Polylines, Arcs   │ │
│  ┌─────────────┐  │ - Styles     │  │ - Text, Dimensions  │ │
│  │   Blocks    │  │ - DimStyles  │  │ - Hatches, Splines  │ │
│  │             │  │ - VPorts     │  │ - 3D, Mesh, Images  │ │
│  └─────────────┘  └──────────────┘  └─────────────────────┘ │
│                                                              │
│  ┌──────────────────────────────────┐  ┌──────────────────┐ │
│  │            Objects               │  │  Notifications   │ │
│  │  Dictionaries, Groups, Styles,   │  │  Warnings, Errors│ │
│  │  Layouts, XRecords, Materials    │  │  Diagnostics     │ │
│  └──────────────────────────────────┘  └──────────────────┘ │
│                                                              │
│  ┌──────────────────────────────────────────────────────────┐│
│  │                      Classes                             ││
│  │  DXF class definitions (name, app, proxy flags, count)   ││
│  └──────────────────────────────────────────────────────────┘│
└──────────────────────────────────────────────────────────────┘

Core Traits

Key Types

⚙️ Dependencies

acadrust is built on a foundation of high-quality Rust crates:

🧪 Testing

Run the test suite:

# Run all tests
cargo test

# Run with output
cargo test -- --nocapture

# Run specific test
cargo test test_read_minimal_dxf

Run benchmarks:

cargo bench

️ Roadmap

• ASCII DXF read/write
• Binary DXF read/write
• Full entity, table, and object coverage
• CLASSES section support
• Character encoding / code page support
• Failsafe (error-tolerant) reading mode
• Unknown entity preservation
• Full DWG binary format support
• Geometric operations (offset, trim, extend)
• SVG/PDF export
• Spatial indexing for large drawings

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Development Setup

# Clone the repository
git clone https://github.com/hakanaktt/acadrust.git
cd acadrust

# Build the project
cargo build

# Run tests
cargo test

# Check formatting
cargo fmt --check

# Run clippy
cargo clippy

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• ACadSharp - The C# library that inspired this project
• The Rust community for excellent tooling and libraries
• All contributors who help improve this library

📞 Support

• Issues: GitHub Issues
• Discussions: GitHub Discussions

Made with ❤️ in Rust