Prepare your environmentThese examples require the .NET 10 SDK. Framework libraries target .NET 8 / 10.
Install & configureUse the tested package version, then adjust the connection and addresses for your device.
Read & validateRun against the local loopback environment before connecting your own device.

Full quickstart Browse the Examples repository

Choose the protocol, then check address rules and data types.

Choose an example and copy it to get started.

Tested example version26.301.1Download the local demo ↓Run instructions ↗

dotnet add package Snet.Modbus --version 26.301.1

Modbus TCP

dotnet add package Snet.Modbus --version 26.301.1

using Snet.Modbus;
using Snet.Model.data;
using Snet.Model.@enum;
using System.Text.Json;

await using var device = await ModbusOperate.InstanceAsync(new ModbusData.Basics
{
    IpAddress = "127.0.0.1", Port = 1502, Station = 1,
    ProtocolType = ModbusData.ProtocolType.ModbusTcpNet,
    AddressStartWithZero = false
});
var connected = await device.OnAsync();
if (!connected.Status) { Console.WriteLine(connected.Message); return; }
var value = await device.ReadAsync(new Address(new AddressDetails
{
    AddressName = "1", AddressDataType = DataType.Short
}));
Console.WriteLine(value.Status ? JsonSerializer.Serialize(value.ResultData) : value.Message);
await device.OffAsync(true);

Siemens S7

dotnet add package Snet.Siemens --version 26.301.1

using Snet.Siemens;
using Snet.Model.data;
using Snet.Model.@enum;
using System.Text.Json;

await using var device = await SiemensOperate.InstanceAsync(new SiemensData.Basics
{
    IpAddress = "127.0.0.1", Port = 102,
    ProtocolType = SiemensData.ProtocolType.SiemensS7Net_S1200,
    Rack = 0, Slot = 1, PDULength = -1
});
var connected = await device.OnAsync();
if (!connected.Status) { Console.WriteLine(connected.Message); return; }
var value = await device.ReadAsync(new Address(new AddressDetails
{
    AddressName = "DB1.DBD0", AddressDataType = DataType.Float
}));
Console.WriteLine(value.Status ? JsonSerializer.Serialize(value.ResultData) : value.Message);
await device.OffAsync(true);

MQTT forwarding

dotnet add package Snet.Modbus --version 26.301.1
dotnet add package Snet.Mqtt --version 26.301.1

using Snet.Modbus;
using Snet.Mqtt.client;
using Snet.Model.data;
using Snet.Model.@enum;
using System.Text.Json;
using System.Text;

await using var device = await ModbusOperate.InstanceAsync(new ModbusData.Basics
{
    IpAddress = "127.0.0.1", Port = 1502, Station = 1,
    ProtocolType = ModbusData.ProtocolType.ModbusTcpNet,
    AddressStartWithZero = false
});
await using var mqtt = await MqttClientOperate.InstanceAsync(new MqttClientData.Basics
{
    IpAddress = "127.0.0.1", Port = 1883,
    UserName = "", Password = ""
});
var connected = await device.OnAsync();
if (!connected.Status) { Console.WriteLine(connected.Message); return; }
var broker = await mqtt.OnAsync();
if (!broker.Status) { Console.WriteLine(broker.Message); return; }
var value = await device.ReadAsync(new Address(new AddressDetails
{
    AddressName = "1", AddressDataType = DataType.Short
}));
if (!value.Status) { Console.WriteLine(value.Message); return; }
var sent = await mqtt.ProduceAsync("snet/demo", JsonSerializer.Serialize(value.ResultData), Encoding.UTF8);
Console.WriteLine(sent.Status ? "Published" : sent.Message);
await mqtt.OffAsync(true);
await device.OffAsync(true);

Local loopback verificationModbus TCP · 1234Verification scope →

Local demo ports: Modbus 1502 / MQTT 1883. Configure the parameters before connecting to real devices.

Framework capabilities

Different protocols. A familiar interface.

Organize acquisition, messaging and transport through consistent interfaces. Focus on your data and extend device support as needed.

36Device access packages

130+Protocol variants

6Messaging & transport channels

46Framework packages

What do these numbers cover?

The framework website lists 36 access packages, including device protocols, databases, simulation and custom access; 130+ protocol variants, 6 messaging/transport channels and 46 framework packages. These are not all packages by the author, or devices tested by this page.

View the framework directory

Explore the connection diagram

PLCPLC controllers

OPCDevice input

DBDatabase acquisition

Snet.Unified API · Open extension

MQTTMessaging

APIData services

APPApplications

Devices → Unified interfaces → Applications

Unified interfaces

IDaq, IMq and ICommunication organize acquisition, messaging and transport operations. Connection, read/write, subscription and result handling follow consistent patterns.

Extensible plugins

AssemblyLoadContext loads plugins for custom devices and messaging systems. Compatible hosts support loading and unloading plugins at runtime.

Acquisition to messaging

Address models parse and convert device data. Messaging configuration can forward the results to MQTT, Kafka and other systems, connecting the factory floor to applications.

Addresses and batch reads

Shared address, subscription and result models simplify data access. Supported protocols can combine scattered addresses into batch requests to reduce communication round trips.

Application integration

Transports, events, caching, logging and WebAPI support integration. Combine them with RPC, Redis and WPF libraries to build data services and desktop applications.

Development and validation

Async operations return status, messages and data through OperateResult. Simulation and virtual addresses help during development, while the framework supports Chinese and English.

OperateResult
  Status: true
  Message: OK
  ResultData: { ... }

Built for these workflows

Device data acquisitionEdge gatewaysProduction monitoringIndustrial integrationCommunication diagnosticsVisual inspection

Connect devicesPLCs / instruments / databases

Acquire and parseIDaq / address models

Forward and serveIMq / WebAPI / RPC

Build applicationsMonitor / store / visualize

Example workflows

A clear path from task to implementation.

These illustrative workflows link to configuration steps and source projects.

ACQUIRE

Deliver field data to your services

PLC→Daq→MQTT / API

Configure devices and addresses, acquire data and forward it to your services.

Explore messaging ↗

DIAGNOSE

Diagnose one device first

Device→Debug→Read / Subscribe

Use interactive reads, writes, subscriptions and OPC UA browsing to diagnose connectivity and addresses.

Explore the debugger ↗

INSPECT

Build a vision workflow

Dataset→Train→Validate

Move from datasets and assisted labeling to training, ONNX and combined validation.

Explore the vision platform ↗

PROTOCOLS & CONNECTIVITY

Find your device. Connect your system.

Browse and search ↗

SiemensSiemens ModbusGeneral protocol MitsubishiMitsubishi OmronOmron Allen-BradleyRockwell BeckhoffBeckhoff OPC UA / DADevice input DatabaseDatabase acquisition

36 access packages

Grouped by primary use; vendors may span several device types. Consult the driver docs for models, TCP/serial transport and read/write capabilities. “Simulation” identifies a simulated source, not a maturity rating.

Messaging & transport channels

Message middleware: MQTT, Kafka, RabbitMQ and RocketMQ.

MQTT Kafka RabbitMQ RocketMQ

Peer-to-peer and network transport: NetMQ and Netty.

NetMQ Netty

Channel documentation

From connections to data services

TCP · UDP · Serial · WebSocket · HTTP

Choose transport for the device and messaging for the system. A unified result model connects the data processing stages.

Transport reference Protocol docs

Open source

From framework to applications.

Choose your workflow, then explore the source. Acquisition, protocol diagnostics and industrial vision are the ecosystem’s three core paths.

Core products Acquisition · Diagnostics · Vision

Data acquisitionWPF / BlazorMIT

Snet.Iot.Daq

Plugin-based acquisition and forwarding

Configure acquisition across PLCs, OPC, Modbus, databases and custom devices, then forward data with messaging plugins. A Windows WPF desktop application and a Blazor web application for Windows / Linux share the same core business logic.

Runtime pluginsOPC UA ServerMQTT BrokerLive charts (desktop)

Star128 Fork32

View source ↗Downloads & releases ↗

Daq desktop: plugin and connection configuration — Actual interface screenshots from the project README · Click to enlarge

Industrial visionASP.NET CoreMIT

VisualIdentity

From annotation to inspection and APIs

A .NET 10 industrial vision platform: YOLO recognizes objects and known defects, Anomalib locates anomalies, and SAM assists point-prompt annotation. Includes annotation, training, ONNX and joint validation, Windows / Linux web and API applications, and a Windows WPF tool. Core components integrate through source project references.

Five YOLO tasksAnomaly detectionAssisted annotationCPU / CUDA

Star51 Fork19

View source ↗Source integration guide ↗

VisualIdentity: screw image dataset workspace — Actual interface screenshots from the project README · Click to enlarge

VisualIdentity: training progress and resource monitoring — Actual interface screenshots from the project README · Click to enlarge

Windows WPF.NET 10MIT

Snet.Iot.Debug

Interactive diagnostics for one device or protocol

Interactive diagnostics for individual devices and protocols. Read/write data, manage subscriptions, test messaging, view charts and browse OPC UA nodes. Complements Daq's acquisition workflow.

Interactive read/writeSubscriptions & live chartsOPC UA browsing

Star11 Fork5

View source Downloads & releases

Debug: device read/write and subscription debugging — Actual interface screenshots from the project README · Click to enlarge

Debug: OPC UA server configuration — Actual interface screenshots from the project README · Click to enlarge

Developer tools & libraries Compose what your application needs

WpfMUI

Star16 Fork3

Modern WPF interfaces and application foundations: Snet.Windows.Core / Controls, MVVM, themes, Chinese/English localization, window base classes, property editors and common controls.

UI library · WindowsView source

Rpc

Star7 Fork2

A .NET RPC library built on DotNetty, with service registration, client proxies and async calls. Includes server and client examples for process and internal service communication.

Service calls · .NETView source

Redis

Star6 Fork0

Snet.Redis wraps connections and operations for caching, sessions, state and publish/subscribe workflows. A shared entry point manages Redis access and common data structures.

Caching · .NETView source

Examples

Star4 Fork0

Snet reference examples organized into core, daq, relay, tep and web groups. Explore transports, acquisition, message forwarding, custom device access and WebAPI integration.

Examples · .NET 10View source

Plugins

Star3 Fork1

A community source directory organized by author and daq / mq type. Share device access, custom acquisition and messaging plugins. Each plugin documents its interface, dependencies and host compatibility.

Plugins · IDaq / IMqView source

SKILLS

Star21 Fork7

Four skills for AI coding assistants, covering acquisition, messaging, IDaq / IMq plugins and WPF applications, with development workflows and interface contracts.

AI assistance · GuidesView source

More tools

These tools are independent of the industrial acquisition workflow.

KMSim

Star9 Fork2

A programmable keyboard and mouse simulator for Windows. Scripts combine keys, pointer actions, delays, loops and clipboard operations for repetitive tasks and desktop automation.

Automation · WindowsView source

CopilotProxy

Star41 Fork7

Provides an Ollama-compatible interface for GitHub Copilot, forwarding requests to DeepSeek / MiMo. Includes a Windows WPF manager for configuration, service controls and logs. See the README for model and IDE requirements.

AI tools · Proxy

Models are provided by third-party services; read their terms before use.

View source

11 applications, tools and ecosystem projects. Framework packages and application source have separate entrances.

Data updated2026-10-30 · Current releases & repositories ↗

Documentation & practice

Learn the concepts. See the practice.

Start with the framework concepts, then follow protocol guides, source code and practical articles into your own use case.

Snet documentation

Docs home

Installation, configuration, the core engine, protocols, messaging, WPF and API references, available in Chinese and English.

Getting started

Install, configure, connect, read and subscribe

Core architecture

Lifecycles, abstractions, events, caches and plugins

Protocols and devices

Vendor drivers, address rules, OPC and custom access

Messaging systems

Connect MQTT, Kafka, RabbitMQ and other systems

WPF development

Windows, controls, MVVM, themes and localization

API reference

Interfaces, results, addresses, enums and attributes

SNET BLOG / ENGINEERING

Practical answers from experience.

Da Shun's technical blog shares Snet projects, C# / .NET, WPF, industrial communication, vision applications and developer tools, alongside personal stories.

Communication and acquisition

Daq, acquisition and forwarding, data parsing and custom plugins.

Interfaces and engineering

WPF libraries, themes, localization and .NET encoding issues.

Vision and AI tools

VisualIdentity, YOLO applications and model proxy tools.

Visit the blog Article archive

Read articles alongside the documentation for your installed version.

Start with a plain-language request.

Snet AI Skills give coding assistants domain knowledge, interface contracts and development steps.

Explore all four skills

Your request

Connect a Modbus device, read registers and forward the data to MQTT.

The assistant’s workflow

Read the DAQ-Skill and MQ-Skill interface contracts
Prepare device, address and message settings
Generate code, then validate with the device

// DAQ → MQTT
var value = await device.ReadAsync(address);
if (value.Status)
    await mqtt.ProduceAsync(topic,
        Serialize(value.ResultData), Encoding.UTF8);

Workflow illustration; generated output still needs review and testing.

DAQ-Skill ↗

Acquire and forward

Describe the device, addresses and destination to help generate acquisition code.

MQ-Skill ↗

Connect messaging

Build messaging code around brokers, topics and send/receive requirements.

PluginDev-Skill ↗

Build custom plugins

Implement custom acquisition and messaging through IDaq / IMq contracts.

WpfUI-Skill ↗

Build WPF interfaces

Combine windows, MVVM, themes, localization and controls.

PLATFORMS & LICENSING

Know the boundaries before you build.

Platform support follows each project’s documentation. Packages, source code and third-party components have separate license scopes.

Platform support

Application and component platforms
Component	Windows	Linux	macOS
Daq / VisualIdentity Web、API	Supported	Supported	Undeclared
WPF / Debug / KMSim	Supported	Unsupported	Unsupported
.NET communication libraries	Driver and dependency specific; OPC DA requires Windows COM.

Applications mainly use .NET 10; libraries target .NET 8 / 10. See project documentation for driver and acceleration requirements.

License scope

Daq, Debug and VisualIdentity source is published under MIT, which permits commercial use under its terms. Framework packages are distributed on NuGet. Plugins, models and dependencies retain their own licenses.

License details & dependency references

Distribution formats and license references
Component	Distribution & license
Snet.Modbus	NuGet package · MIT ↗The package license does not mean this site provides the framework’s core source.
Daq / Debug / VisualIdentity	GitHub source · MITRefer to each repository’s LICENSE.
Plugins, models & dependencies	Refer to the relevant repositories and upstream licenses.

See the notices for plugin, model and dependency license references.

Third-party resources & notices ↗

Snet.Modbus 26.301.1

NuGet downloads44,817

Stars across 11 projects297

Versions & release history Public statistics refresh daily; example versions are validated separately.

Evidence & scope

Evidence where it matters.

Example verification, platform support and licensing scope in one place.

Example verification records & scope

Example	Method	Result & scope
Modbus TCP	Local loopback simulator	Reads 1234; no physical PLC is connected.
Modbus → MQTT	Loopback simulation and MQTT receive assertions	Published; the receiver confirms the same address value is 1234.
Siemens S7	Compilation check	Not connected to a physical PLC or S7 simulator.

Compose provides a Modbus simulator and Mosquitto, with ports bound to localhost. Docker is unavailable in this verification environment, so the container stack has not been run.

Screenshots come from public project READMEs; architecture, scenarios and AI code illustrate workflows. Validate performance, hardware compatibility and generated code in your environment.

Framework packages are distributed on NuGet, while application source is linked separately. Dependencies, plugins and models have their own licenses.

Run the same local examples ↗

Author & community

Connections continue in the community.

Projects grow through code. Experience grows through conversation. Meet the author, follow updates and bring ideas to the factory floor.

Shun / Da ShunSnet author · Industrial IoT · .NET

The author of Snet, focused on industrial IoT, .NET and open source. Report issues in the relevant repository, read the blog or join the publicly listed communities.

Meet the author and explore more

GitHub Issues · Feedback QQ technical community

Before you get started.

Is Snet a framework or an application?

At its core, Snet is an industrial communication and acquisition framework for .NET. Its ecosystem includes Daq, Debug, WpfMUI, VisualIdentity and related projects. Install packages in an existing application or start with public application source.

Which library or tool should I choose?

Use a NuGet protocol package to connect devices from an existing .NET project. Choose Daq for configurable acquisition and forwarding, Debug for interactive device diagnostics, VisualIdentity for inspection, and WpfMUI for desktop interfaces.

Is it open source, and can I use it?

The framework is distributed via NuGet; Snet.Modbus package metadata declares MIT. This does not mean this site provides the framework’s core source. Daq, Debug and VisualIdentity publish source under MIT. Check plugins, model weights and dependencies separately; see the license table above.

Can I use it on Windows, Linux and macOS?

Daq Blazor Web and VisualIdentity Web/API support Windows and Linux. WPF desktop apps, Debug, WpfMUI and KMSim require Windows. These applications do not declare macOS support. Check each driver’s dependencies; OPC DA requires Windows COM.

Why do versions and counts differ between sources?

Pages and articles may use different update dates or counting scopes. Follow the documentation, APIs and references for your installed versions, and keep Snet package versions consistent.

How should I compare libraries and acquisition tools?

For embedded device communication in a .NET system, evaluate protocol packages, APIs and platform dependencies. For configured acquisition and forwarding, evaluate Daq; for single-device troubleshooting, start with Debug. Choose for your protocols, deployment environment and maintainability, then validate with your own devices.

Where can I report issues, and when will I hear back?

Open an issue in the relevant repository with your version, protocol, reproduction steps and necessary logs. Use the QQ group for discussion. The community project does not promise a response time. Keep passwords, keys and production connection details out of public reports.