lemunozm/message-io
74.3
Strong · 9 November 2026
4.5k
lines of production code
Rust
primary language
7
measurements over time
What this system is
This system is a Rust networking library that provides a modular, adapter-based architecture for building networked applications. It supports multiple transport protocols, including TCP, UDP, and WebSocket, through a unified API that handles connection management, message encoding, and event processing. The library includes utilities for efficient data handling and thread management, along with examples and benchmarks to demonstrate performance and usage patterns.
How it got here
2020 — Initial release and example expansion
5 changes.
The project launched the message-io networking library as a public crate, providing a modular API for building networked applications with support for TCP, UDP, and WebSocket transports. This release was accompanied by significant dependency updates and the addition of diverse examples, including distributed discovery, multicast, and file transfer scenarios, to demonstrate the library's capabilities.
2021 — Network adapter architecture and transport implementation
7 changes.
The project established a pluggable network architecture with a unified Driver and Adapter trait, enabling support for TCP, UDP, and WebSocket transports. Concrete implementations for these protocols were developed alongside utility modules for encoding and threading. The period also included comprehensive integration tests, latency benchmarks, and a ping-pong example to validate the new multi-transport capabilities.
Features
Added TCP file-transfer example
A new example demonstrating how to send and receive files over TCP using the FramedTcp transport. The example includes a receiver that listens on port 3005 and a sender that transfers files in 64KB chunks to avoid blocking the event queue, with progress reporting and support for multiple concurrent connections.
examples/file-transfer · high confidence
Added distributed network example with discovery server
A new example demonstrating a distributed network architecture has been added to the examples/distributed directory. It features a discovery server that manages participant registration and unregistration, notifying other participants of network changes. Participants can register with the server, receive a list of existing members, and establish direct private communication channels with each other using Framed TCP transport.
examples/distributed · high confidence
Added multicast discovery example
A new example demonstrating how to use multicast for node discovery has been added to the examples directory. It shows how to connect to a multicast address, send a greeting message upon connection, and listen for messages from other nodes on the same LAN.
examples/multicast · high confidence
Added ping-pong example demonstrating multi-transport client-server communication
Introduced a new ping-pong example in the \examples/ping-pong\ directory that illustrates a client-server architecture supporting TCP, UDP, and WebSocket transports. The example includes a server that listens for connections and a client that sends periodic ping messages, with logic to handle connection-oriented versus connection-less protocols appropriately. Users can run the server and client via command-line arguments to test connectivity and message exchange across different network transports.
examples/ping-pong · high confidence
Added throughput benchmark example
A new example application has been added to measure and compare network throughput across different transport protocols (UDP, TCP, Framed TCP, and WebSocket). The tool benchmarks both the \message-io\ library's performance and native standard library implementations by transferring 1GB of data over localhost, allowing users to evaluate protocol overhead and library efficiency.
examples/throughput · high confidence
Initial release of the message-io networking library
The library is now available as a public crate, exposing a modular API for building networked applications. Users can create nodes via \node::split\ to handle connections and signals, and interact with the network through \NetworkController\ methods like \connect\ and \listen\ which support multiple transports (TCP, UDP, WebSocket) via feature flags. The API includes a synchronized event queue (\EventReceiver\) for processing network events and timers, and provides adapters for various transport protocols.
src · high confidence
Introduces configurable TCP, UDP, and WebSocket network adapters
The \src/adapters\ directory now provides concrete implementations for TCP, UDP, and WebSocket transports, replacing the previous placeholder or unimplemented state. The TCP adapter (\tcp.rs\, \framed\_tcp.rs\) supports non-blocking connections, source address binding, device binding (on Unix), and configurable TCP keepalive settings. The UDP adapter (\udp.rs\) adds support for broadcast messages, source address specification, and socket reuse options (\SO\_REUSEADDR\, \SO\_REUSEPORT\), with specific handling for Linux broadcast reception. The WebSocket adapter (\ws.rs\) implements frame-based communication using \tungstenite\, handling both client and server handshakes and delivering binary messages. A template adapter (\template.rs\) is also included as a reference for implementing new transports.
src/adapters · high confidence
Introduction of a configurable, adapter-based network architecture
The network subsystem has been restructured to support pluggable transport adapters via a new \Adapter\ trait and \DriverLoader\ configuration system. This change introduces a generic \Driver\ that manages resources (connections and listeners) through a unified \ActionController\ and \EventProcessor\ interface, allowing the library to support multiple transport protocols (TCP, UDP, WebSocket) independently. Users can now configure which network adapters are available by mounting them to the \DriverLoader\, and the system exposes new types like \Endpoint\, \ResourceId\, and \RemoteAddr\ to handle connection identification and address resolution across different transport types.
src/network · high confidence
New utility modules for varint encoding and namespaced threading
Added src/util/encoding.rs, which provides varint-based message encoding and a zero-copy Decoder for handling partial data chunks, and src/util/thread.rs, which introduces a NamespacedThread wrapper that automatically names threads for better debugging and ensures threads are joined on drop.
src/util · high confidence
Test coverage
Added integration tests for network transport behavior; Added latency benchmark suite for network transports.
Dependencies
message-io library updated to version 0.19.0 with dependency upgrades
The message-io network library has been updated to version 0.19.0. This release includes significant dependency upgrades, most notably updating the tungstenite WebSocket library to version 0.26 (up from 0.20.1) and the socket2 system socket library to version 0.5.1 (up from 0.3.19). Other dependencies such as mio, strum, and crossbeam-channel have also been updated to their latest compatible versions. The Cargo.toml manifest has been expanded with comprehensive metadata, including license, description, and feature definitions for tcp, udp, and websocket support.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 73 → 74 (+1.7)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 97 → 97 (+0.0)
- Architecture 88 → 88 (+0.0)
- Maturity 57 → 61 (+3.7)
- Readiness 80 → 80 (-0.1)
- Security 100 → 100 (+0.5)
- Event Sourcing 100 → 100 (+0.0)
- Performance 90 → 90 (+0.0)
Resolved (4)
- Confusing naming convention. process_poll_event (singular) vs process_poll_events_until_timeout (plural + duration) is inconsistent. It is unclear if the singular version processes one event and blocks, or processes all available events. The naming does not clearly convey the iteration behavior.
- Inconsistent async handling. for_each implies a synchronous iteration, but for_each_async returns a NodeTask. This suggests for_each might be blocking or synchronous, while the async version is non-blocking. However, in an async runtime, having a synchronous for_each that blocks the thread is often an anti-pattern or requires careful documentation. The naming suggests they are variants of the same operation, but the signatures are fundamentally different in how they handle execution.
- Redundant method naming and parameter duplication. The distinction between connect and connect_with is unclear without documentation, as is the distinction between the base Transport and TransportConnect. Similarly, connect vs connect_sync implies a synchronous/asynchronous difference, but the API surface suggests connect might be async and connect_sync sync, yet both return Result. This creates a confusing combinatorial explosion of methods for a single operation.
- Redundant method naming. Similar to connect, the distinction between listen and listen_with is ambiguous. Why does one take Transport and the other TransportListen? If TransportListen is a specific config, the naming should reflect that (e.g., listen_with_config), or the base method should accept the config.
New (1)
- Outdated: log
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
lemunozm/message-io was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 9 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit f1c67d0a3ec87902cc9f417af17014f87e11f531 — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-bb0cb800cd0f.