Open source · CompactLogix · ControlLogix

EtherNet/IP driver.
Read & write Logix tags.
No OPC server.

A modern, cross-platform EtherNet/IP/CIP explicit-messaging SDK for CompactLogix and ControlLogix tag access, built for native performance, memory safety, and async I/O — with first-class APIs for Rust, .NET/C#, Python, C, and C++.

What that means: the driver originates request/response messages to read, write, batch, and discover Logix tags without an OPC server. It is not a cyclic implicit-I/O Scanner or Adapter.

Start building → View source

Stable release 1.2.1MIT licensedNo OPC or RSLinxReal-PLC tested

REAL-HARDWARE VALIDATION

PROCESSOR1756-L75

FIRMWARE33

RESULTPASS

Rust core→C ABI→4 ecosystems

2,304tag paths read per binding

2,285write paths verified by readback

4 / 4language bindings passed

0unexpected anomalies

Source: 1.2.1 real-hardware gate · 1756-L75 firmware 33 · August 22, 2026 View evidence →

HMISCADA integrationMES / OEEHistoriansData loggingIIoT gatewaysEdge services

Runnable C# + React example

From browser screen
to real PLC tags.

Start in simulation, then connect the same application to a CompactLogix or routed ControlLogix. The walkthrough includes the exact Studio 5000 tags, PC prerequisites, build commands, architecture, and safe read-only defaults.

C# and React Web HMI connected to a ControlLogix PLC, showing 39 of 39 healthy array, UDT, and program-scoped tag reads — **39 / 39** live signals good **1.2.1** native Rust core **ABI 3** C# wrapper boundary **Read-only** by default

Run the demo → Create the PLC tags View live validation evidence ↗

Where the library fits

Your application.
Direct Logix data.

Build the interface your users need. This project owns the protocol, routing, and controller details between your application code and CompactLogix or ControlLogix tags.

01
UI

Interface or service

Desktop HMI, web backend, MES service, collector, historian, or edge gateway.
02
APP

Your application

Write normal application code in Rust, C#, Python, C, or C++.

RsC#PyCC++
03
EIP

rust-ethernet-ip

An explicit-messaging client driver with thin language bindings over one memory-safe Rust protocol core.
The layer this project provides
04
CIP

Explicit EtherNet/IP + CIP

TCP sessions and request/response tag messaging, with symbolic paths, chassis routing, batching, fragmentation, and errors.
05
PLC

Logix controller

Read, write, discover, batch, and monitor CompactLogix or ControlLogix tags.

Direct application-to-controller path No OPC serverNo RSLinx dependencyNo proprietary runtime key

Protocol scope: this project is an explicit-message client/originator for Logix data access. It does not implement cyclic Class 1 implicit I/O, an I/O Scanner, or an I/O Adapter. A TCP EtherNet/IP session is also distinct from a connected CIP Class 3 connection.

Web application note: the PLC connection belongs in your backend or edge service; browser JavaScript should call that service rather than opening an industrial protocol connection directly.

Rust core capabilities

What can the library do?

One protocol core handles the controller work. Choose a language wrapper for your application without reimplementing EtherNet/IP.

Single-tag I/O

Typed reads and writes for BOOL, integer, floating-point, STRING, arrays, and symbolic bit paths.

Batch operations

Read or write many independent tags with packet-size-aware grouping and per-tag results.

Controller + program scope

Use TagName or Program:Main.TagName with the same read/write APIs.

Tag discovery

Enumerate controller tags and inspect type metadata; Rust also exposes program-scoped enumeration.

UDTs and nested members

Read whole structures, access nested symbolic paths, and write known members without rebuilding a UDT.

Built-in + custom STRINGs

Handle-aware text access for standard STRING and custom DATA sizes, including fragmented large transfers.

ControlLogix routing

Route through a 1756 Ethernet module and backplane slot, including ordered multi-hop paths.

Monitoring + diagnostics

Subscriptions, tag-group polling, health checks, operation metrics, latency, and native error detail.

Wrapper surfaces intentionally differ today. Use the language guides below to confirm exact API availability for each stack.

Choose your stack

Native where it matters.
Familiar where you work.

Every binding runs through the same Rust implementation, so protocol fixes and controller behavior stay consistent.

CORE

Rust

Async, typed access with full control over routes, batches, UDTs, diagnostics, and subscriptions.

rust-ethernet-ip = "1.2.1"

API reference →crates.io ↗

WRAPPER

.NET / C#

Typed, idiomatic APIs for HMIs, MES integrations, Windows services, and ASP.NET applications.

dotnet add package RustEtherNetIp

Documentation →NuGet ↗

WRAPPER

Python

PLC data for collectors, analytics, historians, APIs, pandas workflows, and edge services.

pip install rust-ethernet-ip==1.2.1

Documentation →PyPI ↗

C++

ABI v3

C / C++

A checked-in C header and compact RAII wrapper for native, Qt, and industrial PC applications.

#include "rust_ethernet_ip.h"

Integration guide →Examples ↗

use rust_ethernet_ip::{EipClient, PlcValue};

let mut plc = EipClient::connect("192.168.1.10:44818").await?;
let speed = plc.read_tag("Program:Main.Speed").await?;
plc.write_tag("Program:Main.Setpoint", PlcValue::Dint(1500)).await?;

using var plc = new EtherNetIpClient();
plc.Connect("192.168.1.10:44818");

var speed = plc.ReadDint("Program:Main.Speed");
plc.WriteDint("Program:Main.Setpoint", 1500);

from rust_ethernet_ip import EtherNetIpClient

with EtherNetIpClient("192.168.1.10:44818") as plc:
    speed = plc.read_tag("Program:Main.Speed")
    plc.write_tag("Program:Main.Setpoint", 1500)

auto result = EipClient::connect("192.168.1.10:44818");
if (!result) return 1;
EipClient plc = std::move(result.value);

auto speed = plc.read_dint("Program:Main.Speed");
plc.write_dint("Program:Main.Setpoint", 1500);

Start in minutes

One connection.
The API you expect.

Direct CompactLogix or routed ControlLogix, controller tags or program tags—the same symbolic paths work across every supported language.

Installation guide →

Evidence, not assumptions

Tested on real Logix hardware.

The library targets CompactLogix and ControlLogix explicit tag access, including integrated Ethernet and chassis routing. Compatibility claims are tied to an exact processor, firmware, topology, release, and language binding—not only a family name.

Designed targets CompactLogix 5370 / 5380 · ControlLogix 5570 / 5580Validated routes Direct Ethernet · 1756-EN2T · 1756-EN3TR

View full matrix Contribute a test →

Processor / firmwareBindings

5069-L330ERMFirmware 38Rs · C# · Py · C++DONE

1756-L75Firmware 33Rs · C# · Py · C++DONE

1769-L18ERFirmware 33Rs · C# · PyDONE

1756-L81ESFirmware 37Rs · C# · PyDONE

Your PLCL7, L8, 5069…Help expand coverageOPEN

Built for industrial software

Protocol depth without protocol duplication.

Why the core is Rust

Rust combines native performance with memory and thread safety for byte-level packet parsing, asynchronous network I/O, sessions, and long-running industrial services.

Why wrappers exist

Industrial teams can keep familiar C#, Python, C, or C++ application code while one tested Rust core owns the protocol behavior and fixes.

Logix-aware

Program tags, arrays, packed BOOLs, built-in and custom strings, nested UDTs, and routed chassis access.

Inspectable evidence

Simulator tests, cross-language contracts, release gates, and real-hardware records live beside the code.

Direct connectivityNo OPC server, RSLinx, or proprietary runtime key required.

Cross-platformRun the application on Windows x64, Linux x64, or Apple-silicon macOS by shipping the matching native runtime.

Examples includedRust · C# desktop/web · Python data services · CMake C++

Support pathGitHub Issues for defects · Discussions for integration help

Open source · MIT

Connect modern software
to the factory floor.

Read the docs, inspect the protocol core, or bring another processor and firmware into the compatibility matrix.

Explore on GitHub →Read Rust API docs

EtherNet/IP driver.Read & write Logix tags.No OPC server.

From browser screento real PLC tags.

Your application.Direct Logix data.

Interface or service

Your application

rust-ethernet-ip

Explicit EtherNet/IP + CIP

Logix controller