rust-ethernet-ip

Open source · CompactLogix · ControlLogix

EtherNet/IP library.
Read & write
Logix PLC data.

A cross-platform PLC communication library for direct CompactLogix and ControlLogix tag access, with first-class Rust, .NET, Python, C, and C++ APIs.

What it does: EtherNet/IP is the industrial Ethernet protocol Logix controllers use to exchange tag data. This driver lets your application read and write those tags without adding an OPC server.

Start building → View source
Stable release 1.2.0MIT licensedNo OPC or RSLinxReal-PLC tested
REAL-HARDWARE VALIDATION
PROCESSOR5069-L330ERM
FIRMWARE38
RESULTPASS
Rust core→C ABI→4 ecosystems
2,338tag paths read per binding
2,319write paths verified by readback
4 / 4language bindings passed
0unexpected anomalies
Source: 1.2.0 real-hardware gate · 5069-L330ERM firmware 38 · July 8, 2026 View evidence →
HMISCADA integrationMES / OEEHistoriansData loggingIIoT gatewaysEdge services

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.

  1. 01
    UI

    Interface or service

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

  2. 02
    APP

    Your application

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

    RsC#PyCC++
  3. 03
    EIP

    rust-ethernet-ip

    Thin language bindings over one memory-safe Rust protocol core.

    The layer this project provides
  4. 04
    CIP

    EtherNet/IP + CIP

    Sessions, symbolic paths, chassis routing, batching, fragmentation, and errors.

  5. 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

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.

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.

Rs
CORE

Rust

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

rust-ethernet-ip = "1.2.0"
API reference →crates.io ↗
.N
WRAPPER

.NET / C#

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

dotnet add package RustEtherNetIp
Documentation →NuGet ↗
Py
WRAPPER

Python

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

pip install rust-ethernet-ip==1.2.0
Documentation →PyPI ↗
C++
ABI v2

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?;

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 matrixContribute a test →
Processor / firmwareBindings
5069-L330ERMFirmware 38Rs · C# · Py · C++DONE
1756-L75Firmware 33Rs · C# · PyDONE
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.

01

Memory-safe core

Rust owns wire parsing, session state, routing, fragmentation, and controller-specific behavior.

02

Thin wrappers

C#, Python, and C/C++ share one native implementation and one compatibility contract.

03

Logix-aware

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

04

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.
Packaged runtimesWindows x64 · Linux x64 · macOS arm64
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 docsSponsor development ♡