✅ PRODUCTION READY - PHASE 1 COMPLETE
This project has successfully completed Phase 1 development and is ready for production use.
The core functionality is fully implemented, tested, and stable, with comprehensive data type support and advanced tag addressing capabilities.
Production release v1.0 is planned for Q4 2025.

🆕 NEW: Go + Next.js Fullstack Example!

Try the new high-performance Go backend + Next.js frontend demo for real-time, batch, and performance operations. See fullstack example & guide →

A high-performance, production-ready EtherNet/IP communication library specifically designed for Allen-Bradley CompactLogix and ControlLogix PLCs. Built in pure Rust with focus on PC applications, offering exceptional performance, memory safety, and comprehensive industrial features.

This library is specifically designed for:

• Allen-Bradley CompactLogix (L1x, L2x, L3x, L4x, L5x series)
• Allen-Bradley ControlLogix (L6x, L7x, L8x series)
• PC Applications (Windows, Linux, macOS)
• Industrial Automation software and SCADA systems
• High-performance data acquisition and control

• Automatic session management with proper registration/unregistration
• Connection health monitoring with configurable timeouts
• Network resilience handling for industrial environments
• Comprehensive error handling with detailed CIP error mapping

• Program-scoped tags: Program:MainProgram.Tag1
• Array element access: MyArray[5], MyArray[1,2,3]
• Bit-level operations: MyDINT.15 (access individual bits)
• UDT member access: MyUDT.Member1.SubMember
• String operations: MyString.LEN, MyString.DATA[5]
• Complex nested paths: Program:Production.Lines[2].Stations[5].Motor.Status.15

All Allen-Bradley native data types with proper CIP encoding:

• BOOL - Boolean values (CIP type 0x00C1)
• SINT - 8-bit signed integer (-128 to 127, CIP type 0x00C2)
• INT - 16-bit signed integer (-32,768 to 32,767, CIP type 0x00C3)
• DINT - 32-bit signed integer (-2.1B to 2.1B, CIP type 0x00C4)
• LINT - 64-bit signed integer (CIP type 0x00C5)
• USINT - 8-bit unsigned integer (0 to 255, CIP type 0x00C6)
• UINT - 16-bit unsigned integer (0 to 65,535, CIP type 0x00C7)
• UDINT - 32-bit unsigned integer (0 to 4.3B, CIP type 0x00C8)
• ULINT - 64-bit unsigned integer (CIP type 0x00C9)
• REAL - 32-bit IEEE 754 float (CIP type 0x00CA)
• LREAL - 64-bit IEEE 754 double (CIP type 0x00CB)
• STRING - Variable-length strings (CIP type 0x00DA)
• UDT - User Defined Types with full nesting support (CIP type 0x00A0)

• Complete C# wrapper with all data types
• 22 FFI functions for seamless integration
• Type-safe API with comprehensive error handling
• NuGet package ready for easy distribution
• Cross-platform support (Windows, Linux, macOS)

• CGO wrapper with comprehensive API coverage
• Type-safe Go bindings for all PLC data types
• Connection management and health monitoring
• Error handling with Go-idiomatic patterns
• Full-stack example with Go backend + Next.js frontend (see example)

• PyO3-based Python wrapper with full API coverage
• Type-safe Python bindings for all PLC data types
• Synchronous and asynchronous APIs for flexible usage
• Comprehensive error handling with Python exceptions
• Easy installation via pip or maturin
• Cross-platform support (Windows, Linux, macOS)
• Write_tag method now correctly returns a boolean indicating success or failure

• Detailed CIP error mapping with 40+ error codes
• Network-level diagnostics and troubleshooting
• Granular error types for precise error handling
• Automatic error recovery for transient issues

• Automated build scripts for Windows and Linux/macOS
• Cross-platform compilation with proper library generation
• Comprehensive testing with 30+ unit tests
• CI/CD ready with GitHub Actions examples

• Real-time tag monitoring with configurable update intervals (1ms - 10s)
• Event-driven notifications for tag value changes
• Multi-tag subscriptions supporting hundreds of concurrent monitors
• Automatic reconnection and error recovery
• Memory-efficient engine with minimal CPU overhead

• Batch read operations - read up to 100+ tags in a single request
• Batch write operations - write multiple tags atomically
• Parallel processing with concurrent execution
• Transaction support with rollback capabilities
• 2,000+ ops/sec throughput with intelligent packet packing

Optimized for PC applications with excellent performance:

• Basic tag read/write operations
• Connection management and session handling
• Enhanced tag path parsing (Program-scoped, arrays, bit access)
• Complete data type support (All Allen-Bradley types)
• C# wrapper integration (22 FFI functions)
• Comprehensive testing (30+ unit tests)
• Build automation (Cross-platform build scripts)
• Documentation (Examples, API docs, guides)

• Batch operations (multi-tag read/write) ✅ COMPLETED
• Real-time subscriptions (tag change notifications) ✅ COMPLETED
• Performance optimizations (50% faster operations) ✅ COMPLETED
• Enhanced error handling & recovery ✅ COMPLETED

• Stress testing (long-term stability tests)
• Performance benchmarking (vs other libraries)
• Production deployment (v1.0 release)
• Community features (Discord, support channels)

Add to your Cargo.toml:

[dependencies]
rust-ethernet-ip = "0.4.0"
tokio = { version = "1.0", features = ["full"] }

Install via NuGet:

<PackageReference Include="RustEtherNetIp" Version="0.4.0" />

Or via Package Manager Console:

Install-Package RustEtherNetIp

Install via pip:

pip install rust-ethernet-ip

Or build from source using maturin:

cd pywrapper
maturin develop

use rust_ethernet_ip::{EipClient, PlcValue};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Connect to CompactLogix PLC
    let mut client = EipClient::connect("192.168.1.100:44818").await?;
    
    // Read different data types
    let motor_running = client.read_tag("Program:Main.MotorRunning").await?;
    let production_count = client.read_tag("Program:Main.ProductionCount").await?;
    let temperature = client.read_tag("Program:Main.Temperature").await?;
    
    // Write values
    client.write_tag("Program:Main.SetPoint", PlcValue::Dint(1500)).await?;
    client.write_tag("Program:Main.StartButton", PlcValue::Bool(true)).await?;
    
    println!("Motor running: {:?}", motor_running);
    println!("Production count: {:?}", production_count);
    println!("Temperature: {:?}", temperature);
    
    Ok(())
}

using RustEtherNetIp;

using var client = new EtherNetIpClient();
if (client.Connect("192.168.1.100:44818"))
{
    // Read different data types
    bool motorRunning = client.ReadBool("Program:Main.MotorRunning");
    int productionCount = client.ReadDint("Program:Main.ProductionCount");
    float temperature = client.ReadReal("Program:Main.Temperature");
    
    // Write values
    client.WriteDint("Program:Main.SetPoint", 1500);
    client.WriteBool("Program:Main.StartButton", true);
    
    Console.WriteLine($"Motor running: {motorRunning}");
    Console.WriteLine($"Production count: {productionCount}");
    Console.WriteLine($"Temperature: {temperature:F1}°C");
}

from rust_ethernet_ip import PyEipClient

def main():
    # Create a client and connect to the PLC
    client = PyEipClient(addr="192.168.0.1")
    if not client.connect():
        print("Failed to connect to PLC")
        return

    try:
        # Read a DINT value
        value = client.read_dint("TestDINT")
        print("Read TestDINT:", value)
        
        # Write a new value
        client.write_dint("TestDINT", 42)
        print("Wrote 42 to TestDINT")
        
    except Exception as e:
        print("Error:", e)

if __name__ == "__main__":
    main()

// Program-scoped tags
let value = client.read_tag("Program:MainProgram.Tag1").await?;

// Array elements
let array_element = client.read_tag("Program:Main.MyArray[5]").await?;
let multi_dim = client.read_tag("Program:Main.Matrix[1,2,3]").await?;

// Bit access
let bit_value = client.read_tag("Program:Main.StatusWord.15").await?;

// UDT members
let udt_member = client.read_tag("Program:Main.MotorData.Speed").await?;
let nested_udt = client.read_tag("Program:Main.Recipe.Step1.Temperature").await?;

// String operations
let string_length = client.read_tag("Program:Main.ProductName.LEN").await?;
let string_char = client.read_tag("Program:Main.ProductName.DATA[0]").await?;

// All supported data types
let bool_val = client.read_tag("BoolTag").await?;           // BOOL
let sint_val = client.read_tag("SintTag").await?;           // SINT (-128 to 127)
let int_val = client.read_tag("IntTag").await?;             // INT (-32,768 to 32,767)
let dint_val = client.read_tag("DintTag").await?;           // DINT (-2.1B to 2.1B)
let lint_val = client.read_tag("LintTag").await?;           // LINT (64-bit signed)
let usint_val = client.read_tag("UsintTag").await?;         // USINT (0 to 255)
let uint_val = client.read_tag("UintTag").await?;           // UINT (0 to 65,535)
let udint_val = client.read_tag("UdintTag").await?;         // UDINT (0 to 4.3B)
let ulint_val = client.read_tag("UlintTag").await?;         // ULINT (64-bit unsigned)
let real_val = client.read_tag("RealTag").await?;           // REAL (32-bit float)
let lreal_val = client.read_tag("LrealTag").await?;         // LREAL (64-bit double)
let string_val = client.read_tag("StringTag").await?;       // STRING
let udt_val = client.read_tag("UdtTag").await?;             // UDT

Dramatically improve performance with batch operations that execute multiple read/write operations in a single network packet. Perfect for data acquisition, recipe management, and coordinated control scenarios.

• 3-10x faster than individual operations
• Reduced network traffic (1-5 packets instead of N packets for N operations)
• Lower PLC CPU usage due to fewer connection handling overheads
• Better throughput for data collection and control applications

• Data acquisition: Reading multiple sensor values simultaneously
• Recipe management: Writing multiple setpoints at once
• Status monitoring: Reading multiple status flags efficiently
• Coordinated control: Atomic operations across multiple tags

use rust_ethernet_ip::{EipClient, BatchOperation, PlcValue};

// Read multiple tags in a single operation
let tags_to_read = vec![
    "ProductionCount",
    "Temperature_1", 
    "Temperature_2",
    "Pressure_1",
    "FlowRate",
];

let results = client.read_tags_batch(&tags_to_read).await?;
for (tag_name, result) in results {
    match result {
        Ok(value) => println!("📊 {}: {:?}", tag_name, value),
        Err(error) => println!("❌ {}: {}", tag_name, error),
    }
}

// Write multiple tags in a single operation
let tags_to_write = vec![
    ("SetPoint_1", PlcValue::Real(75.5)),
    ("SetPoint_2", PlcValue::Real(80.0)),
    ("EnableFlag", PlcValue::Bool(true)),
    ("ProductionMode", PlcValue::Dint(2)),
    ("RecipeNumber", PlcValue::Dint(42)),
];

let results = client.write_tags_batch(&tags_to_write).await?;
for (tag_name, result) in results {
    match result {
        Ok(()) => println!("✅ {}: Write successful", tag_name),
        Err(error) => println!("❌ {}: {}", tag_name, error),
    }
}

use rust_ethernet_ip::BatchOperation;

let operations = vec![
    // Read current values
    BatchOperation::Read { tag_name: "CurrentTemp".to_string() },
    BatchOperation::Read { tag_name: "CurrentPressure".to_string() },
    
    // Write new setpoints
    BatchOperation::Write { 
        tag_name: "TempSetpoint".to_string(), 
        value: PlcValue::Real(78.5) 
    },
    BatchOperation::Write { 
        tag_name: "PressureSetpoint".to_string(), 
        value: PlcValue::Real(15.2) 
    },
    
    // Update control flags
    BatchOperation::Write { 
        tag_name: "AutoModeEnabled".to_string(), 
        value: PlcValue::Bool(true) 
    },
];

let results = client.execute_batch(&operations).await?;
for result in results {
    match result.operation {
        BatchOperation::Read { tag_name } => {
            match result.result {
                Ok(Some(value)) => println!("📊 Read {}: {:?} ({}μs)", 
                    tag_name, value, result.execution_time_us),
                Err(error) => println!("❌ Read {}: {}", tag_name, error),
            }
        }
        BatchOperation::Write { tag_name, .. } => {
            match result.result {
                Ok(_) => println!("✅ Write {}: Success ({}μs)", 
                    tag_name, result.execution_time_us),
                Err(error) => println!("❌ Write {}: {}", tag_name, error),
            }
        }
    }
}

use rust_ethernet_ip::BatchConfig;

// High-performance configuration
let high_perf_config = BatchConfig {
    max_operations_per_packet: 50,      // More operations per packet
    max_packet_size: 4000,              // Larger packets for modern PLCs
    packet_timeout_ms: 1000,            // Faster timeout
    continue_on_error: true,            // Don't stop on single failures
    optimize_packet_packing: true,      // Optimize packet efficiency
};

client.configure_batch_operations(high_perf_config);

// Conservative/reliable configuration
let conservative_config = BatchConfig {
    max_operations_per_packet: 10,      // Fewer operations per packet
    max_packet_size: 504,               // Smaller packets for compatibility
    packet_timeout_ms: 5000,            // Longer timeout
    continue_on_error: false,           // Stop on first error
    optimize_packet_packing: false,     // Preserve exact operation order
};

client.configure_batch_operations(conservative_config);

use std::time::Instant;

let tags = vec!["Tag1", "Tag2", "Tag3", "Tag4", "Tag5"];

// Individual operations (traditional approach)
let individual_start = Instant::now();
for tag in &tags {
    let _ = client.read_tag(tag).await?;
}
let individual_duration = individual_start.elapsed();

// Batch operations (optimized approach)  
let batch_start = Instant::now();
let _ = client.read_tags_batch(&tags).await?;
let batch_duration = batch_start.elapsed();

let speedup = individual_duration.as_nanos() as f64 / batch_duration.as_nanos() as f64;
println!("📈 Performance improvement: {:.1}x faster with batch operations!", speedup);

// Batch operations provide detailed error information per operation
match client.execute_batch(&operations).await {
    Ok(results) => {
        let mut success_count = 0;
        let mut error_count = 0;
        
        for result in results {
            match result.result {
                Ok(_) => success_count += 1,
                Err(_) => error_count += 1,
            }
        }
        
        println!("📊 Results: {} successful, {} failed", success_count, error_count);
        println!("📈 Success rate: {:.1}%", 
            (success_count as f32 / (success_count + error_count) as f32) * 100.0);
    }
    Err(e) => println!("❌ Entire batch failed: {}", e),
}

• Use batch operations for 3+ operations to see significant performance benefits
• Group similar operations (reads together, writes together) for optimal packet packing
• Adjust max_operations_per_packet based on your PLC's capabilities (10-50 typical)
• Use higher packet sizes (up to 4000 bytes) for modern CompactLogix/ControlLogix PLCs
• Enable continue_on_error for data collection scenarios where partial results are acceptable
• Disable optimize_packet_packing if precise operation order is critical for your application

# Windows
build.bat

# Linux/macOS
./build.sh

# Build Rust library
cargo build --release --lib

# Copy to C# project (Windows)
copy target\release\rust_ethernet_ip.dll csharp\RustEtherNetIp\

# Build C# wrapper
cd csharp/RustEtherNetIp
dotnet build --configuration Release

See BUILD.md for comprehensive build instructions.

Run the comprehensive test suite:

# Rust unit tests (30+ tests)
cargo test

# C# wrapper tests
cd csharp/RustEtherNetIp.Tests
dotnet test

# Run examples
cargo run --example advanced_tag_addressing
cargo run --example data_types_showcase

Explore comprehensive examples demonstrating all library capabilities across different platforms:

Modern web-based PLC dashboard with real-time monitoring and advanced features.

# Start backend API
cd examples/AspNetExample
dotnet run

# Start frontend (new terminal)
cd examples/TypeScriptExample/frontend
npm install && npm run dev

Features:

• ✅ Modern UI/UX with glassmorphism design and responsive layout
• ✅ Real-time monitoring with live tag updates and performance metrics
• ✅ Complete data type support for all 13 Allen-Bradley types
• ✅ Advanced tag addressing with interactive examples
• ✅ Type-safe API with comprehensive TypeScript interfaces
• ✅ Professional features including benchmarking and activity logging

Perfect for: Web applications, dashboards, remote monitoring, modern industrial HMIs

Rich desktop application with MVVM architecture and modern UI.

cd examples/WpfExample
dotnet run

Features:

• ✅ MVVM architecture with CommunityToolkit.Mvvm
• ✅ Real-time tag monitoring with automatic refresh
• ✅ Advanced tag discovery with type detection
• ✅ Performance benchmarking with visual metrics
• ✅ Comprehensive logging with timestamped activity

Perfect for: Desktop HMIs, engineering tools, maintenance applications

Traditional Windows Forms application with familiar UI patterns.

cd examples/WinFormsExample
dotnet run

Features:

• ✅ Classic Windows UI with familiar controls
• ✅ Connection monitoring with automatic reconnection
• ✅ Tag operations with validation and error handling
• ✅ Performance testing with real-time metrics
• ✅ Industrial styling with professional appearance

Perfect for: Legacy system integration, simple HMIs, maintenance tools

RESTful API backend providing HTTP access to PLC functionality.

cd examples/AspNetExample
dotnet run

Features:

• ✅ RESTful endpoints for all PLC operations
• ✅ Swagger documentation with interactive API explorer
• ✅ Type-safe operations with comprehensive validation
• ✅ Performance monitoring with built-in benchmarking
• ✅ Production-ready with proper error handling and logging

Perfect for: Web services, microservices, system integration, mobile backends

Native Rust examples demonstrating core library functionality.

# Advanced tag addressing showcase
cargo run --example advanced_tag_addressing

# Complete data types demonstration
cargo run --example data_types_showcase

# Batch operations performance demo
cargo run --example batch_operations_demo

Features:

• ✅ Advanced tag parsing with complex path examples
• ✅ All data types with encoding demonstrations
• ✅ Performance examples with async/await patterns
• ✅ Error handling with comprehensive error types
• ✅ Batch operations with performance comparisons and configuration examples

Perfect for: Rust applications, embedded systems, high-performance scenarios

Modern fullstack demo with a Go backend (using the Rust Go wrapper) and a Next.js (TypeScript) frontend for real-time, batch, and performance operations.

# Start backend
cd examples/gonextjs/backend
go run .

# Start frontend (new terminal)
cd ../frontend
npm install && npm run dev

Features:

• ✅ Go backend using the Rust EtherNet/IP Go wrapper (FFI)
• ✅ Next.js frontend (TypeScript, Tailwind, App Router)
• ✅ Batch read/write and individual tag operations
• ✅ Performance benchmarking (ops/sec, latency)
• ✅ Real-time tag updates via WebSocket
• ✅ Comprehensive PLC data type support
• ✅ Modern, responsive UI

Perfect for: Modern web dashboards, Go/TypeScript fullstack apps, real-time industrial monitoring

1. Choose your platform:

   • Web/Modern UI → TypeScript + React Dashboard
   • Desktop/Windows → WPF or WinForms Application
   • Web API/Services → ASP.NET Core Web API
   • Native/Performance → Rust Examples

2. Start the backend (for web examples):

   cd examples/AspNetExample
   dotnet run

3. Run your chosen example and connect to your PLC at 192.168.0.1:44818

4. Explore features:

   • Tag discovery with advanced addressing
   • Real-time monitoring and benchmarking
   • All 13 Allen-Bradley data types
   • Professional error handling and logging

examples/
├── TypeScriptExample/          # React + TypeScript dashboard
│   ├── frontend/              # Modern web UI
│   ├── start-backend.bat      # Backend startup script
│   └── start-frontend.bat     # Frontend startup script
├── WpfExample/                # WPF desktop application
├── WinFormsExample/           # WinForms desktop application
├── AspNetExample/             # ASP.NET Core Web API
└── rust-examples/             # Native Rust examples
    ├── advanced_tag_addressing.rs
    ├── data_types_showcase.rs
    └── batch_operations_demo.rs

Each example includes comprehensive documentation, setup instructions, and demonstrates different aspects of the library's capabilities.

• API Documentation - Complete API reference
• Examples - Practical usage examples
• Build Guide - Comprehensive build instructions
• C# Wrapper Guide - C# integration documentation
• Changelog - Version history and changes

• Discord Server - Community discussions, support, and development updates
• GitHub Issues - Bug reports and feature requests
• GitHub Discussions - General questions and ideas

This project draws inspiration from excellent libraries in the industrial automation space:

• pylogix - Python library for Allen-Bradley PLCs
• pycomm3 - Python library for Allen-Bradley PLCs
• gologix - Go library for Allen-Bradley PLCs
• libplctag - Cross-platform PLC communication library

We welcome contributions! Please see our Contributing Guide for details on:

• Code style and standards
• Testing requirements
• Pull request process
• Development setup

This library is provided "AS IS" without warranty of any kind. Users assume full responsibility for its use in their applications and systems.

The developers and contributors make NO WARRANTIES, EXPRESS OR IMPLIED, including but not limited to:

• Merchantability or fitness for a particular purpose
• Reliability or availability of the software
• Accuracy of data transmission or processing
• Safety for use in critical or production systems

• 🏭 Industrial Use: Users are solely responsible for ensuring this library meets their industrial safety requirements
• 🔒 Safety Systems: This library should NOT be used for safety-critical applications without proper validation
• ⚙️ Production Systems: Thoroughly test in non-production environments before deploying to production systems
• 📋 Compliance: Users must ensure compliance with all applicable industrial standards and regulations

Under no circumstances shall the developers, contributors, or associated parties be liable for:

• Equipment damage or malfunction
• Production downtime or operational disruptions
• Data loss or corruption
• Personal injury or property damage
• Financial losses of any kind
• Consequential or indirect damages

By using this library, you acknowledge and agree that:

• You have the technical expertise to properly implement and test the library
• You will perform adequate testing before production deployment
• You will implement appropriate safety measures and fail-safes
• You understand the risks associated with industrial automation systems
• You accept full responsibility for any consequences of using this library

Users agree to indemnify and hold harmless the developers and contributors from any claims, damages, or liabilities arising from the use of this library.

⚠️ IMPORTANT: This disclaimer is an integral part of the license terms. Use of this library constitutes acceptance of these terms.

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

Built with ❤️ for the industrial automation community

• C# + React: Modern web and desktop examples using the C# wrapper
• Go + Next.js: Fullstack Go backend + Next.js frontend example (NEW in v0.4.0!)
• TypeScript + ASP.NET: Classic React + ASP.NET example
• ...and more in the examples/ directory

To build all wrappers, libraries, and examples (including Go + Next.js):

./build-all.bat

This script builds:

• Rust library (DLL/SO/DYLIB)
• C# wrapper and tests
• Go wrapper and tests
• All example backends and frontends (C#, Go, TypeScript, Next.js)

See BUILD.md for details.

Current Release: v0.4.0 (Release Notes)

See CHANGELOG.md for a full list of changes.

See RELEASE_NOTES_v0.4.0.md for detailed release notes and migration info.

• See examples/gonextjs/README.md for step-by-step instructions.
• Features: Go backend (using Rust FFI), Next.js frontend, batch ops, real-time, performance, and more.