Lib.rs

trust-dns-resolver

Trust-DNS is a safe and secure DNS library. This Resolver library uses the Client library to perform all DNS queries. The Resolver is intended to be a high-level library for any DNS…

zmq

High-level bindings to the zeromq library

actix-rt

Actix runtime

nats

A Rust NATS client

rusoto_core

AWS SDK for Rust - Core

ipnet

Provides types and useful methods for working with IPv4 and IPv6 network addresses, commonly called IP prefixes. The new IpNet, Ipv4Net, and Ipv6Net types build on the existing IpAddr…

tarpc

An RPC framework for Rust with a focus on ease of use

httparse

A tiny, safe, speedy, zero-copy HTTP/1.x parser

tonic-build

Codegen module of tonic gRPC implementation

rust-s3

Rust library for working with Amazon S3 and compatible object storage APIs

capnp-rpc

implementation of the Cap’n Proto remote procedure call protocol

mles

Mles - a distributed publish/subscribe data server

libp2p

Peer-to-peer networking library

rusoto_s3

AWS SDK for Rust - Amazon Simple Storage Service @ 2006-03-01

grpcio-compiler

gRPC compiler for grpcio

etherparse

A library for parsing & writing a bunch of packet based protocols (EthernetII, IPv4, IPv6, UDP, TCP …)

pulsar

Rust client for Apache Pulsar

actix-router

Resource path matching library

backoff

Retry operations with exponential backoff policy

dns-lookup

A simple dns resolving api, much like rust’s unstable api. Also includes getaddrinfo and getnameinfo wrappers for libc variants.

pnet_base

Fundamental base types and code used by pnet

tentacle

Minimal implementation for a multiplexed p2p network framework

state

A library for safe and effortless global and thread-local state management

yamux

Multiplexer over reliable, ordered connections

ipnetwork

A library to work with IP CIDRs in Rust

smoltcp

A TCP/IP stack designed for bare-metal, real-time systems without a heap

quinn

QUIC transport protocol implementation for Tokio

async-trait

Type erasure for async trait methods

mac_address

Cross-platform retrieval of a network interface MAC address

webrtc-sdp

This create parses strings in the format of the Session Description Protocol according to RFC4566. It specifically supports the subset of features required to support WebRTC according to the JSEP draft.

quiche

🥧 Savoury implementation of the QUIC transport protocol and HTTP/3

rustls-native-certs

rustls-native-certs allows rustls to use the platform native certificate store

iovec

Portable buffer type for scatter/gather I/O operations

pnet

Cross-platform, low level networking using the Rust programming language

eui48

A library to generate and parse IEEE EUI-48 and EUI-64, also known as MAC-48 media access control addresses. The IEEE claims trademarks on the names EUI-48 and EUI-64, in which EUI is an…

shadowsocks-rust

shadowsocks is a fast tunnel proxy that helps you bypass firewalls

raptorq

RaptorQ (RFC6330)

mqtt-protocol

MQTT Protocol Library

schannel

Schannel bindings for rust, allowing SSL/TLS (e.g. https) without openssl

encrypted-dns

A modern encrypted DNS server (DNSCrypt v2, Anonymized DNSCrypt, DoH)

sentry-actix

Sentry client extension for actix-web 3

imap-proto

IMAP protocol parser and data structures

protocol

Easy protocol definitions

actix-connect

TCP connector service for Actix ecosystem

async-net

Async networking primitives for TCP/UDP/Unix communication

ipconfig

Get network adapters information and network configuration for windows

google-dns1

A complete library to interact with dns (protocol v1)

protobuf

Rust implementation of Google protocol buffers

prometheus_wireguard_exporter

Prometheus WireGuard Exporter

irc

the irc crate – usable, async IRC for Rust

libunftp

Extensible, async, cloud orientated FTP(S) server library

paho-mqtt

The Official Eclipse Paho MQTT Rust Client Library. This is a wrapper around the Paho C library

ether-dream

A full implementation of the Ether Dream Laster DAC protocol

amq-protocol-types

AMQP specifications - types

ip_network

IPv4 and IPv6 network structs

trust-dns-proto

Trust-DNS is a safe and secure DNS library. This is the foundational DNS protocol library for all Trust-DNS projects.

grpcio-proto

Public proto files for grpcio

ldap3

Pure-Rust LDAPv3 Client

igd

Internet Gateway Protocol client

nanomsg

A high-level, Rust idiomatic wrapper around nanomsg

lrpc

local rpc

beanstalkc

Yet another simple Beanstalkd client for Rust

netstat2

Cross-platform library to retrieve network sockets information

tokio-socks

Asynchronous SOCKS proxy support for Rust

pcarp

A pure-Rust library for reading pcap-ng files

sozu-command-lib

configuration library to command a sozu instance

cidr

IP network and IP host within network types

oxygengine-network

Network module for Oxygen Engine

domain

A DNS library for Rust

tun

TUN device creation and handling

openldap

Straightforward Rust bindings to the C openldap library. This is a fork of cldap that has been methodically fixed, extended, and made to be more compliant with openldap. It should be…

swayipc

A library for controlling sway through its IPC interface

nng-sys

Bindings to NNG (Nanomsg-Next-Generation) aka Nanomsg2

twitchchat

interface to the irc-side of twitch’s chat system

rusoto_logs

AWS SDK for Rust - Amazon CloudWatch Logs @ 2014-03-28

bgp-rs

A library for parsing Border Gateway Protocol (BGP) formatted streams

google-drive3-cli

A complete library to interact with drive (protocol v3)

varlink

Client and server support for the varlink protocol

runng-sys

Bindings to NNG (Nanomsg-Next-Generation) aka Nanomsg2

mbus-api

A RESTful HTTP API exposing (wired) M-Bus functionality

tonic

A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility

new-tokio-smtp

extendible smtp implementation for tokio

bitstream-io

Library for reading/writing un-aligned values from/to streams in big-endian and little-endian formats

rumqttc

An efficient and robust mqtt client for your connected devices

koibumi

An experimental Bitmessage client

telegram-bot-raw

Telegram Bot API types

azure_sdk_storage_blob

Rust wrappers around Microsoft Azure REST APIs - Blob storage crate

libp2p-core

Core traits and structs of libp2p

discv5

Implementation of the p2p discv5 discovery protocol

rusp

The Rust USP toolkit

io-uring

The io_uring library for Rust

solicit

A library implementation of HTTP/2

ttrpc

A Rust version of ttrpc

nordselect

Select the ideal NordVPN server

zenoh-protocol

Zenoh: Zero Overhead Pub/sub, Store/Query and Compute

libstrophe

Rust ergonomic wrapper for libstrophe

fibers_rpc

RPC library built on top of fibers crate

rsntp

An RFC 4330 compliant Simple Network Time Protocol (SNTP) client library for Rust

lambda_runtime

Rust runtime for AWS Lambda

fast-socks5

Fast SOCKS5 client/server implementation written in Rust async/.await (with async-std)

iprange

A library to manage IP ranges

qlog

qlog data model for QUIC and HTTP/3

vopono

Launch applications via VPN tunnels using temporary network namespaces

netidx-tools

Cross platform secure messaging framework, “like DNS for values”

tokio-native-tls

An implementation of TLS/SSL streams for Tokio using native-tls giving an implementation of TLS for nonblocking I/O streams

async_ftp

FTP client for Rust

hap

Rust implementation of the Apple HomeKit Accessory Protocol (HAP)

mdns

A multicast DNS client library. Supports discovery of any mDNS device on a LAN

openssh-keys

read and write OpenSSH public keys

cid

CID in rust

aster-proxy

A light, fast and powerful cache proxy written in Rust

async-listen

Various helpers for writing production-ready servers in rust using async-std

agate

Very simple server for the Gemini hypertext protocol

librsync

Bindings to librsync for calculating and applying network deltas exposed as Reader/Writer streams

ssh2

Bindings to libssh2 for interacting with SSH servers and executing remote commands, forwarding local ports, etc

unftp

When you need to FTP, but don’t want to. An async, cloud orientated FTP(S) server built on libunftp

quinn-proto

State machine for the QUIC transport protocol

astro-dnssd

Simple & safe DNS-SD wrapper

ftp

FTP client for Rust

nano-get

A very tiny implementation of HTTP(s) GET, using minimal dependencies

alexa_sdk

Implements Request/Response for Amazon Alexa skills

nb-connect

Non-blocking TCP or Unix connect

prost-build

A Protocol Buffers implementation for the Rust Language

url-bot-rs

Minimal IRC URL bot in Rust

gpsd_proto

The gpsd_proto module contains types and functions to connect to gpsd to get GPS coordinates and satellite information

libsip

SIP protocol Implementation, with a focus towords softphone clients

protobuf-codegen

Code generator for rust-protobuf. Includes a library and protoc-gen-rust binary. See protoc-rust and protobuf-codegen-pure crates

ssdp-client

An asynchronous library for discovering, notifying and subscribing to devices and services on a network

ion-binary-rs

Pure Rust parser, encoder and hasher for Amazon’s Ion binary format

doh-proxy

A DNS-over-HTTPS (DoH) proxy

c-ares

A Rust wrapper for the c-ares library, for asynchronous DNS requests

nature

Summary says Nature is a tool to ensure final consistency of data. However, it also is: distribute-stream-engine, business-controll-center, dispatch-center, data-center and minimalist-programming-platform.

get-port

Get an available port

kf-protocol

Native Rust implementation of kafka protocol

i3_ipc

For communicating with i3 over it’s IPC interface synchronously

zipkin

A library for collecting timing information about distributed computations

pdu

Small, fast, and correct L2/L3/L4 packet parser

networking

secure RSA + AES network implementations in a peer to peer enabled manner

oping

Rust bindings for liboping, a simple ICMP ping library

fixed-buffer

Fixed-size buffers for network protocol parsers

toy-rpc

An async-std based RPC library that mimics the API of golang net/rpc

gip

A library and command-line frontend to check global IP address

port_check

Get a free local port or check if a port somewhere is reachable

lsl

Lab streaming layer (liblsl) bindings for rust

tcp-stream

std::net::TcpStream on steroids

no-std-net

Rust’s std::net… without the ‘std’.

pcap

A packet capture API around pcap/wpcap

quic-p2p

Peer-to-peer networking library using QUIC

pnet_macros_support

Support library for libpnet_macros

mles-client

Mles-client, a distributed data protocol example (chat) client/ws-proxy

mqttrs

Mqtt protocol encoding and decoding

secded

Single Error Correction, Double Error Detection Codes for Everyone

packet

Network packet handling

opcua-certificate-creator

OPC UA certificate creator

tentacle-ping

ping protocol implementation for tentacle

remote-trait-object

A remote method invocation library based on trait objects

openssh

SSH through OpenSSH

parity-multiaddr

Implementation of the multiaddr format

coap

A CoAP library

dachshund

Dachshund is a graph mining library written in Rust. It provides high performance data structures for multiple kinds of graphs, from simple undirected graphs to typed hypergraphs. Dachshund…

rpki

A library for validating and creating RPKI data

aquatic

Blazingly fast, multi-threaded BitTorrent tracker (UDP, HTTP, WebTorrent)

ckb-network

TODO(doc): @driftluo crate description

basic-cookies

Low-level RFC 6265 combatible cookie handling library for Rust

netcdf-sys

FFI bindings to NetCDF

kipa

Distributed Key to IP Address (KIPA) query network

ipp

Asynchronous IPP print protocol implementation

sntp_request

Tiny Rust library to request timestamp from NTP servers trough SNTP protocol

grpcio

The rust language implementation of gRPC, base on the gRPC c core library

poldercast

Peer to Peer topology management

tower-limit

Limit maximum request rate to a Service

abci-rs

A Rust crate for creating ABCI applications

coldsnap

A library and command-line interface for uploading and downloading Amazon EBS snapshots

geoip-rs

geoip-rs provides geographical information about the calling or the specified IP address

udp_netmsg

A low cost abstraction for sending and receiving udp datagrams. Gives ability to send and receive datagrams defined by custom structs in a simple way

aws-build

Build Rust crates for deployment to AWS EC2 or AWS Lambda

google-analytics3-cli

A complete library to interact with analytics (protocol v3)

oxygengine-network-backend-desktop

Network Desktop backend module for Oxygen Engine

cymrust

Query Team Cymru’s IP-to-ASN mapping via DNS

shorty

shorty is a library for assigning short IDs to long URL, and store them on redis

fizyr-rpc

Native Rust implementation of the Fizyr RPC protocol

poston

Yet another Fluentd logger for Rust

bolt-proto

Bolt protocol primitives: values, messages, and serialization / deserialization

lib3h_protocol

Protocol definition for interacting with Lib3h

zeroconf

cross-platform library that wraps ZeroConf/mDNS implementations like Bonjour or Avahi

libtelnet-rs

libtelnet-inspired telnet parser for rust

osshkeys

A library to read and write OpenSSH public and private keys

beanstalkd

Easy-to-use beanstalkd client for Rust (IronMQ compatible)

input_buffer

A peekable FIFO-like buffer for receiving network data efficiently

enocean

EnOcean serial protocol implementation

amiquip

Pure Rust RabbitMQ client

rdkafka-sys

Native bindings to the librdkafka library

knx_examples_rs

Examples for KNX Library

tls-api

TLS API without implementation

keyphrase

KeyPhrase generation for the EARTH Network

rcon

An rcon protocol implementation

nng

A safe wrapper for NNG (Nanomsg v2)

amq-protocol

AMQP specifications

suricata-ipc

Library for sending packets to suricata and receiving output

nispor

Unified interface for Linux network state querying

phroxy

phroxy proxies gopher through HTTP

ieee802154

Partial implementation of the IEEE 802.15.4 standard for low-rate wireless personal area networks

datachannel

Rust wrappers for libdatachannel

telebot

A wrapper around the telegram bot api, powered by futures

actyxos_sdk

Tools for interacting with the services of an ActyxOS node

netaddr2

A Rust network address parsing and arithmetic library

actix_web_metrics_mw

Actix middleware library for metrics

telnet

A simple implementation of telnet protocol

sc-network-gossip

Gossiping for the Substrate network protocol

tiny

An IRC client

capsule

A framework for network function development. Written in Rust, inspired by NetBricks and built on Intel’s Data Plane Development Kit.

rpcx

A rpc/microservice framework

ccsds_primary_header

Implementation of the CCSDS Primary Header for space applications

tarpc-plugins

Proc macros for tarpc

wifiscanner

List WiFi hotspots in your area

faktory

API bindings for the language-agnostic Faktory work server

zenscan

This program is port scanner to target server

nfq

Rust library for dealing with NetFilter queue

packet-builder

High-level library for interacting with low-level network data

tentacle-secio

Secio encryption protocol for p2p

ipmap

An interactive map that shows connected IP addresses

winping

An easy-to-use ICMP Echo API for Windows programs without requiring elevated rights

libhoney-rust

Rust library for sending data to Honeycomb

zmq-sys

Low-level bindings to the zeromq library

dockworker

Docker daemon API client. (a fork of Faraday’s boondock)

utp

A µTP (Micro/uTorrent Transport Library) library implemented in Rust

mpd_protocol

Implementation of MPD client protocol

trust-dns-client

Trust-DNS is a safe and secure DNS library. This is the Client library with DNSec support. DNSSec with NSEC validation for negative records, is complete. The client supports dynamic…

sctpx

A simple and friendly SCTP wrapper

jid

A crate which provides a Jid struct for Jabber IDs

aws-sdk-rust

Important Enhancements: Supports V2 and V4 API Signatures for third party S3 compliant products like Ceph Works from behind proxies Returned data can be in Rust structs, JSON or XML…

prost-types

A Protocol Buffers implementation for the Rust Language

rustdds

Rust DDS implementation with RTPS

nbd

Rust library for NBD (network block device) servers and clients

sim2h

A simulation of lib3h

rustcord

A safe wrapper around the Discord Rich Presence API

fractal-matrix-api

Library to communicate with a Matrix.org server

zenoh-router

The zenoh router

matrix_bot_api

API for writing a bot for the Matrix messaging protocol

rsinetd

A port proxy, replacement of rinetd. Because async-std use epoll rather than select, RsInetd may handle higher throughput than rinetd.

mediasoup

Cutting Edge WebRTC Video Conferencing

dicom-ul

Types and methods for interacting with the DICOM Upper Layer Protocol

buffering

A library primarily designed for network packet buffer operations

azure_iot_sdk

Client library for connection devices to Azure IoT Hub

what

Display current network utilization by process, connection and remote IP/hostname

autodiscover-rs

autodiscover-rs implements a simple algorithm to detect peers on an IP network, connects to them, and calls back with the connected stream. The algorthm supports both UDP broadcast and multicasting.

nearby

Scans all nearby wifi networks and the devices connected to each network

resolv

DNS resolution via glibc

rusoto_ssm

AWS SDK for Rust - Amazon Simple Systems Manager (SSM) @ 2014-11-06

rabbit_borough

Create a RabbitMQ consumer project with minimal effort, by bypassing templating, configuration and complicated resiliency logic

ece

Encrypted Content-Encoding for HTTP Rust implementation

rqpush

A library to assist with pushing notifications to RQueue

readwrite

Combine Read and Write into a single Read+Write object

libipld-core

Base traits and definitions used by ipld codecs

oci-distribution

An OCI implementation in Rust

twilio-async

An async and ergonomic wrapper around Twilio API & TwiML

ethox

A standalone network stack for user-space networking and unikernels

cannyls_rpc

RPC library for operating cannyls’s devices from remote nodes

dlt_parse

A library for parsing the “Diagnostic Log and Trace” network protocol (currently without payload interpretation)

nut-client

Network UPS Tools (NUT) client library

actori-router

Path router

srvrls

A lightweight, opinionated serverless framework reducing boilerplate

treebitmap

Fast IPv4/IPv6 lookup trie

ssb-boxstream

Encrypted box-stream protocol for Secure Scuttlebutt

service_world

Discover services from Hasicorp’s consul

homie-controller

A library for creating controllers to talk to devices implementing the Homie convention for MQTT

nannou_osc

The OSC API for Nannou, the creative coding framework

natpmp

NAT-PMP client library

memcached-rs

A MemCached Library in Rust

xmlrpc

An XML-RPC implementation for Rust

actix-threadpool

Actix thread pool for sync code

thrussh

A client and server SSH library

ncgopher

An ncurses gopher and gemini client for the modern internet

ds

A library for controlling FIRST Robotics Competition robots

svc-agent

An agent library

xmpp-parsers

Collection of parsers and serialisers for XMPP extensions

figma-asset-downloader

Small utility to help you download Figma assets directly to your computer

async-port-scanner

Simple, yet fast, async port scanner library for Rust

pcap_on_demand

A packet capture API around pcap/wpcap that loads pcap/wpcap on demand

paho-mqtt-sys

Rust wrapper for the Paho MQTT C Client Library. This is part of the official Eclipse Paho Rust Client Library

proxy_cfg

A library to get proxy configuration from the OS

tari_p2p

Tari base layer-specific peer-to-peer communication features

bincode-no-std

A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!

evm-network-classic

Ethereum Classic patches for SputnikVM. Deprecated and will be dropped in future releases: use evm-network instead

packet_crafter

Simple tools for creating / parsing / manipulating data packets. Calculates checsums and length fields where possible.

pad-motion

Implementation of Cemuhook gamepad motion protocol. Includes client and server implementations.

libp2p-swarm

The libp2p swarm

jsonrpc

Rust support for the JSON-RPC 2.0 protocol

psocket

the socket for Rust

hdlc

Rust implementation of HDLC with support of the IEEE standard

httpbis

Rust implementation of HTTP/2 protocol

naia-server

A server that uses either UDP or WebRTC communication to send/receive events to/from connected clients, and syncs registered actors to clients to whom those actors are in-scope

fiscalidade

Biblioteca Rust para geração, validação, assinatura de XMLs de Documentos Fiscais e transmissão com webservices da SEFAZ

dtn7-plus

Additional helpers for rust dtn daemon

ellidri

Your kawaii IRC server

nearprotocol/near-network

Reference client for NEAR Protocol

smolapps

A collection of application-layer protocols built on top of smoltcp

ekko

Ekko is a simple utility for sending echo requests, giving you (mostly) everything you need

enet

High-level, rust-y bindings to the ENet library

bip_peer

Communication with bittorrent peers via peer wire protocol

brpc-protoc-plugin

Protobuf-compiler plugin for brpc-rs

async-mpd

Async Mpd client library

wifi-rs

Interface with and manage Wireless Network (WiFi)

pnet_datalink

Cross-platform, datalink layer networking

joystream/joystream-node-runtime

Joystream Monorepo

temp_utp

A µTP (Micro/uTorrent Transport Library) library implemented in Rust

mobc-lapin

RabbitMQ support for the async mobc connection pool

td_proto_rust

bin protocol for Rust

bevy_prototype_networking_laminar

This is a prototype of a networking crate for bevy. This create provides a low-level networking plugin built on top of laminar.

aurpc

Asynchronous UDP RPCs

unimap

Scan only once by IP address and reduce scan times with Nmap for large amounts of data

rodbus

A high-performance implementation of the Modbus protocol using Tokio and async/await

bolt-proto-derive

Procedural macros for bolt-proto

prosafe_exporter

Prometheus exporter for NETGEAR switches supported by ProSAFE Plus utility

bytefmt

an utility to parse byte string into bytes count and vice versa

lambda_runtime_client

Client SDK for AWS Lambda’s runtime APIs

zedmq

A lightweight, safe, pure-Rust ØMQ/ZMTP library implementation

natsclient

NATS client designed for both an ergonomic API and performance

wayk_proto

WaykNow packet encoder-decoder and sequencing utilities

irc-proto

The IRC protocol distilled

async-dnssd

Asynchronous wrapper for DNS-SD C libraries

networksetup

Change macos system network settings

hexavalent

Write HexChat plugins in Rust

artillery-core

Fire-forged cluster management & Distributed data protocol

fibers_transport

Transport layer abstraction built on top of [fibers] crate

drogue-network

A Network Abstraction Layer (NAL) for Embedded Systems

wmata

wmata is a high level Rust interface to the Washington Metropolitan Area Transit Authority (WMATA) API

uniui_core

Basic structures like Signal and Slot for uniui_* crates familiy

popol

Minimal non-blocking I/O

aws-region

Tiny Rust library for working with Amazon AWS regions, supports s3 crate

multicast_dns

Simple Rust wrapper around Avahi Daemon

bioyino-metric

Library for handling metrics in bioyino and related projects

secreteriat

A Discord bot for managing the Langford Discord guild

amqp

AMQP/RabbitMQ protocol client

middleman

A wrapper for a mio::TcpStream to send and receive serializable Structs (blocking or non blocking) of arbitrary size

manuf

Ethernet vendor codes, and well-known MAC addresses

saltyrtc-client

Asynchronous SaltyRTC client implementation for Rust 1.26+

gatekeeper

A SOCKS proxy implementation

ironrdp

A Rust implementation of the Microsoft Remote Desktop Protocol

timeout_io

This library provides a simple timeout-based API for IO-operations

oui

Lookup MAC OUI vendor information from the Wireshark manufacturer database

bytebuffer-rs

A bytebuffer for networking and binary protocols

grpcio-sys

FFI bindings to gRPC c core library

deadpool-ldap

LDAP support for the deadpool connection pool

potatonet

PotatoNet is a lightweight microservices framework

netidx

Cross platform secure messaging framework, “like DNS for values”

av-stream-info-rust

Analyze a http/https internet address and display information if an audio or video stream has been found. All information is extracted from metainformation.

rust-doh-proxy

Rust DNS over HTTPS proxy application

secretbox

Rust implementation of the secretbox encryption algorithm

protoc-rust

protoc –rust_out=… available as API. protoc needs to be in $PATH, protoc-gen-run does not.

net-parser-rs

Basic network parser leveraging Rust and nom for safe and efficient packet parsing. Design influenced by pktparse-rs.

runng

High-level wrapper around nng (Nanomsg-Next-Generation) aka Nanomsg2

mbus

An HTTP microservice exposing M-Bus Functionality

ftp-client

A FTP client library

quick_crawler

QuickCrawler is a Rust crate that provides a completely async, declarative web crawler with domain-specific request rate-limiting built-in

simpletcp

Crate for simple and secure tcp communication

pixelflut-rs

A library providing a pixelflut server to easily connect your display or project to it

erpc-rs

eRPC library for Rust

google-monitoring3-cli

A complete library to interact with Monitoring (protocol v3)

third-wheel

third-wheel is a TLS man-in-the-middle proxy written in rust, with the aim of being lightweight and fast. It is currently in pre-alpha stage.

adventure

Helps your great adventure for the various type of requests

jupiter

Jupiter is a library for providing high-throughput ultra low latency services via the RESP protocol as defined by Redis

amy

Polling and Registration abstractions around kqueue and epoll for multithreaded async network programming

brokaw

📰 An NNTP client liberary. More at 11! 📰

opcua-core

Core components for OPC UA used by client and server

rtable

Generic Routing Table Library with Radix Tree

postgres-inet

CIDR/INET support for rust-postgres

onc-rpc

Open Network Computing / Sun RPC types and fast serialisation

azure_sdk_for_rust

Rust wrappers around Microsoft Azure REST APIs

async-tftp

Executor agnostic async TFTP implementation

sacn

Rust sACN implementation

tun-tap

TUN/TAP interface wrapper

ruma-identifiers-macros

Procedural macros for creating Matrix identifiers

bacnet_parse

no_std BACnet parser

joyent-tokio-zookeeper

Asynchronous client library for interacting with Apache ZooKeeper

vpncloud

Peer-to-peer VPN

sdp-types

SDP (RFC 4566) types, parser and serializer

multicast-socket

Single-socket multi-interface multicast socket

transmission-rpc

Transmission JRPC client

datachannel-sys

Native bindings to libdatachannel

ntp

Library for parsing and communicating over Network Time Protocol

ssb-handshake

Secret-handshake protocol for Secure Scuttlebutt

cueball-dns-resolver

This is a rust implementation of Joyent’s node-cueball DNS resolver

rust_ofp

Rust OpenFlow 0x01 Protocol and Controller Framework

tls-api-stub

TLS API implementation that returns error on any operation

rustls-connector

Connector similar to openssl or native-tls for rustls

amqp-manager

Lapin wrapper that encapsulates the use of connections/channels and provides some helpful methods

dementia

A small client library for the Matrix protocol

persia-rpc

high performance rpc framework on http2

hassium-network-backend-web

Network Web backend module for Hassium home automation engine

parsec

Implementation of Protocol for Asynchronous, Reliable, Secure and Efficient Consensus

minion

Crate for managing cancellable services

ax25

Utilities for Packet Radio in Rust. AX.25 encoding/decoding and radio interfacing.

did_doc

Library for loading/saving DID documents

tftp_server

A TFTP server implementation in Rust using mio

lavish-compiler

Compiler for the Lavish IDL

golem-rpc-api

Typesafe binding for Brass Golem RPC services

network

requiem-router

Path router

pubnub-core

PubNub core crate, modular and composable

snmp_mp

SNMPv3 Message Processing

ssdp

An asynchronous abstraction for discovering devices and services on a network

installer

this crate serves as the installer for the artifice network, however it can also be used as a simple task scheduler

rpc-perf

RPC Performance Testing

acute_core

core sub-crate of acute

s3-ext

Simple Storage Service Extensions for Rust

rupnp

An asynchronous library for finding UPnP control points, performing actions on them and reading their service descriptions

rusty_tarantool

Tarantul async client based on tokio framework

oxygengine-network-backend-web

Network Web backend module for Oxygen Engine

mesalock-linux/mesalink

MesaLink is a memory-safe and OpenSSL-compatible TLS library based on Rustls and Ring

aliyun-openapi

Alibaba Cloud OpenAPI SDK for Rust

message_protocol

A protocol for seperating binary messages over TCP, similar to WebSockets but more minimal

madhouse_steve_tmi

A Twitch Messaging Interface client

zenoh-util

Zenoh: Zero Overhead Pub/sub, Store/Query and Compute

rtorrent_xml_rpc

A crate to send XML RPC to rtorrent

upnp-daemon

A daemon for continuously opening ports via UPnP

prost-amino-derive

A Protocol Buffers implementation for the Rust Language modified to enable amino (de)serialization

libslirp-sys

FFI bindings for libslirp

transmission_rs

A safe, ergonomic, async client for the Transmission BitTorrent client implemented in pure Rust

catalyst-protocol-sdk-rust

Protocol Specification for Catalyst Network

iptools

Python iptools port for Rust

mpack

An alternative MessagePack implementation for Rust

hwaddr

MAC address handling

simple-message-channels

Simple binary protocol with a channel, type, message scheme

smtpbis

Asynchronous ESMTP service library

subspace

A convenience crate for IPC, using TcpStreams

condure

HTTP/WebSocket connection manager

cap-async-std

Capability-oriented version of async-std

tockloader-proto

A #[no_std] implementation of the protocol used by tockloader and the TockOS bootloader

libstrophe-sys-bindgen

Rust bindings for libstrophe, generated using bindgen

net-utils

Network utility library which provides client connection pool for TCP/SSL connctions

minirpc

A minimalist RPC framework

mcping

Implementation of the Server List Ping (SLP) part of the Minecraft Modern protocol

arrsync

Asynchronous Retrieving Rust rSYNc Client

ifinfo

Simple ifconfig placed on Rust

blip

A crate for writing fast and highly resilient in-process gRPC service meshes

easyfibers

easyfibers is a closure-less couroutine library for executing asynchronous tasks as painlessly as possible

telnetify

A tool for local development of TELNET applications

rmonitor

A simple, Tokio-compatible protocol decoder for RMonitor, a line based timing protocol supported by different vendors of sport timing software

varlink_generator

Rust code generator for the varlink protocol

drogue-ttn

API mappings for the ‘The Things Network’

http_header

A simple, dependency-less HTTP-header builder and parser

sntp

A Simple Network Time Protocol (SNTP) client implementation using smoltcp

bmp-client

Tokio-based BMP client

lrpc-macros

lrpc’s proc macros

greetd_ipc

An implementation of the greetd IPC protocol

tile_net

Continuous tile-based collision detection and resolution

protocol-derive

Easy protocol definitions

robust-arduino-serial

Simple and robust serial communication protocol

anysocket

Socket types that can be either Tcp or Unix Domain

i2cbus-api

HTTP RESTful API and skeleton server/client implement for I2C bus control

amq-protocol-codegen

AMQP specifications - codegen

librsyncr

librsyncr is a Rust library to calculate and apply deltas between two files without having access to both files on the same system

kinetic-rust

A Kinetic protocol library written in Rust

mijia-homie

Service to connect to Xiaomi Mijia 2 temperature/humidity sensors over Bluetooth and report their readings to an MQTT broker following the Homie convention