Lib.rs

actix-rt

Actix runtime

rusoto_core

AWS SDK for Rust - Core

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…

pnet

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

httparse

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

tonic

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

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…

zmq

High-level bindings to the zeromq library

tarpc

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

pulsar

Rust client for Apache Pulsar

mles

Mles - a distributed publish/subscribe data server

backoff

Retry operations with exponential backoff policy

etherparse

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

rust-s3

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

rusoto_s3

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

grpcio-compiler

gRPC compiler for grpcio

nats

A Rust NATS client

shadowsocks-rust

shadowsocks is a fast tunnel proxy that helps you bypass firewalls

libp2p

Peer-to-peer networking library

actix-service

Actix service

twitchchat

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

pnet_base

Fundamental base types and code used by pnet

dns-lookup

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

doh-proxy

A DNS-over-HTTPS (DoH) proxy

irc

the irc crate – usable, async IRC for Rust

smoltcp

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

ipnetwork

A library to work with IP CIDRs in Rust

capnp-rpc

implementation of the Cap’n Proto remote procedure call protocol

quinn-proto

State machine for the QUIC transport protocol

quiche

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

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.

google-dns1

A complete library to interact with dns (protocol v1)

raptorq

RaptorQ (RFC6330)

mqtt-protocol

MQTT Protocol Library

ether-dream

A full implementation of the Ether Dream Laster DAC protocol

amq-protocol

AMQP specifications

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…

prometheus_wireguard_exporter

Prometheus WireGuard Exporter

schannel

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

protocol

Easy protocol definitions

trust-dns-proto

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

tun

TUN device creation and handling

yamux

Multiplexer over reliable, ordered connections

ipconfig

Get network adapters information and network configuration for windows

mdns

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

nanomsg

A high-level, Rust idiomatic wrapper around nanomsg

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…

tentacle

Minimal implementation for a multiplexed p2p network framework

rustls-native-certs

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

libunftp

Safe, fast and extensible FTP(S) server library for Rust

nng

A safe wrapper for NNG (Nanomsg v2)

imap-proto

IMAP protocol parser and data structures

varlink

Client and server support for the varlink protocol

tower-limit

Limit maximum request rate to a Service

rpki

A library for validating and creating RPKI data

grpcio-proto

Public proto files for grpcio

quinn

QUIC transport protocol implementation for Tokio

tonic-build

Codegen module of tonic gRPC implementation

netaddr2

A Rust network address parsing and arithmetic library

qlog

qlog data model for QUIC and HTTP/3

lambda_runtime

Rust runtime for AWS Lambda

rusoto_sts

AWS SDK for Rust - AWS Security Token Service @ 2011-06-15

bgp-rs

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

state

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

nordselect

Select the ideal NordVPN server

google-adsense1d4-cli

A complete library to interact with AdSense (protocol v1.4)

fibers_rpc

RPC library built on top of fibers crate

runng-sys

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

new-tokio-smtp

extendible smtp implementation for tokio

solicit

A library implementation of HTTP/2

rusp

The Rust USP toolkit

oxygengine-network

Network module for Oxygen Engine

telegram-bot-raw

Telegram Bot API types

mbus-api

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

encrypted-dns

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

mqttrs

Mqtt protocol encoding and decoding

iovec

Portable buffer type for scatter/gather I/O operations

beanstalkc

Yet another simple Beanstalkd client for Rust

iprange

A library to manage IP ranges

actyxos_sdk

Tools for interacting with the services of an ActyxOS node

azure_sdk_storage_blob

Rust wrappers around Microsoft Azure REST APIs - Blob storage crate

pcarp

A pure-Rust library for reading pcap-ng files

ip_network

IPv4 and IPv6 network structs

openssh-keys

read and write OpenSSH public keys

faktory

API bindings for the language-agnostic Faktory work server

async_ftp

FTP client for Rust

quic-p2p

Peer-to-peer networking library using QUIC

ethox

A standalone network stack for user-space networking and unikernels

rust-doh-proxy

Rust DNS over HTTPS proxy application

nano-get

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

ftp

FTP client for Rust

zipkin

A library for collecting timing information about distributed computations

aster-proxy

A light, fast and powerful cache proxy written in Rust

actix-connect

Actix connect - tcp connector service

librsync

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

coap

A CoAP library

ldap3

Pure-Rust LDAPv3 Client

paho-mqtt-sys

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

wifiscanner

List WiFi hotspots in your area

libp2p-swarm

The libp2p swarm

natsclient

NATS client designed for both an ergonomic API and performance

async-listen

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

packet_crafter

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

a2

A native, asynchronous Apple push notification client

tcp-stream

mio’s TcpStream on steroids

poldercast

Peer to Peer topology management

pnet_macros_support

Support library for libpnet_macros

irc-proto

The IRC protocol distilled

zmq-sys

Low-level bindings to the zeromq library

oping

Rust bindings for liboping, a simple ICMP ping library

abci-rs

A Rust crate for creating ABCI applications

libstrophe

Rust ergonomic wrapper for libstrophe

wmata

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

ipp

Asynchronous IPP print protocol implementation

input_buffer

A peekable FIFO-like buffer for receiving network data efficiently

xmpp-parsers

Collection of parsers and serialisers for XMPP extensions

url-bot-rs

Minimal IRC URL bot in Rust

shorty

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

tokio-socks

Asynchronous SOCKS proxy support for Rust

lib3h

The lib3h p2p communication rust library

tiny

An IRC client

mles-client

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

secded

Single Error Correction, Double Error Detection Codes for Everyone

gpsd_proto

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

knx_examples_rs

Examples for KNX Library

io-uring

The io_uring library for Rust

ccsds_primary_header

Implementation of the CCSDS Primary Header for space applications

rcon

An rcon protocol implementation

telnet

A simple implementation of telnet protocol

vpncloud

Peer-to-peer VPN

fast-socks5

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

pcap

A packet capture API around pcap/wpcap

figma-asset-downloader

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

cidr

IP network and IP host withing network types

rpcx

A rpc/microservice framework

sntp_request

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

jid

A crate which provides a Jid struct for Jabber IDs

poston

Yet another Fluentd logger for Rust

grpcio

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

telebot

A wrapper around the telegram bot api, powered by futures

port_check

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

enocean

EnOcean serial protocol implementation

keyphrase

KeyPhrase generation for the EARTH Network

packet-builder

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

opcua-core

Core components for OPC UA used by client and server

what

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

google-analytics3-cli

A complete library to interact with analytics (protocol v3)

rsntp

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

rodbus

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

bolt-proto

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

osshkeys

A library to read and write OpenSSH public and private keys

astro-dnssd

Simple & safe DNS-SD wrapper

mac_address

Cross-platform retrieval of a network interface MAC address

i3_ipc

For communicating with i3 over it’s IPC interface synchronously

ellidri

Your kawaii IRC server

netstat2

Cross-platform library to retrieve network sockets information

xmlrpc

An XML-RPC implementation for Rust

twilio-async

An async and ergonomic wrapper around Twilio API & TwiML

service_world

Discover services from Hasicorp’s consul

fractal-matrix-api

Library to communicate with a Matrix.org server

ssdp-client

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

ncgopher

An ncurses gopher and gemini client for the modern internet

lines_from_request

Read lines from a hyper Body in a blocking manner

kipa

Distributed Key to IP Address (KIPA) query network

beanstalkd

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

openssh

SSH through OpenSSH

mesalock-linux/mesalink

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

amiquip

Pure Rust RabbitMQ client

adventure

Helps your great adventure for the various type of requests

abbegm

externally guided motion for ABB industrial robots

hdlc

Rust implementation of HDLC with support of the IEEE standard

rusoto_logs

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

amq-protocol-types

AMQP specifications - types

utp

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

fiscalidade

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

golem-rpc-api

Typesafe binding for Brass Golem RPC services

actix-router

Path router

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

dlt_parse

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

buffering

A library primarily designed for network packet buffer operations

ur20

Rust library for the Weidmüller u-remote IP20 system

get-port

Get an available port

savon

SOAP async HTTP client generator

nfq

Rust library for dealing with NetFilter queue

svc-agent

An agent library

packet

Network packet handling

tokio-tls-api

An implementation of TLS/SSL streams for Tokio giving an implementation of TLS for nonblocking I/O streams

capsule

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

tower-service

Trait representing an asynchronous, request / response based, client or server

pdu

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

oxygengine-network-backend-desktop

Network Desktop backend module for Oxygen Engine

enet

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

oui

Lookup MAC OUI vendor information from the Wireshark manufacturer database

lavish-compiler

Compiler for the Lavish IDL

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.

lrpc

local rpc

zenscan

This program is port scanner to target server

no-std-net

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

phroxy

phroxy proxies gopher through HTTP

ttrpc

A Rust version of ttrpc

wifi-rs

Interface with and manage Wireless Network (WiFi)

tarpc-plugins

Proc macros for tarpc

prosafe_exporter

Prometheus exporter for NETGEAR switches supported by ProSAFE Plus utility

rustcord

A safe wrapper around the Discord Rich Presence API

cannyls_rpc

RPC library for operating cannyls’s devices from remote nodes

resolv

DNS resolution via glibc

tcp-warp-cli

A userspace tunnel between two hosts mapping ports on client machine to addresses reachable from server machine

lambda_runtime_client

Client SDK for AWS Lambda’s runtime APIs

nbd

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

grpc-protobuf

Protobuf marshaller for gRPC

async-net

Async networking primitives for TCP/UDP/Unix communication

brokaw

📰 An NNTP client liberary. More at 11! 📰

rqpush

A library to assist with pushing notifications to RQueue

pca9956b-api

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

fahrenheit

toy futures executor (formerly known as toykio)

jsonrpc

Rust support for the JSON-RPC 2.0 protocol

bytebuffer-rs

A bytebuffer for networking and binary protocols

amqp

AMQP/RabbitMQ protocol client

nearby

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

nannou_osc

The OSC API for Nannou, the creative coding framework

hassium-network

Network module for Hassium home automation engine

srvrls

A lightweight, opinionated serverless framework reducing boilerplate

postgres-inet

CIDR/INET support for rust-postgres

actori-service

Actori service

joyent-tokio-zookeeper

Asynchronous client library for interacting with Apache ZooKeeper

ax25

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

natpmp

NAT-PMP client library

ssb-packetstream

Secure Scuttlebutt packet stream protocol

async-tftp

Async TFTP implementation

multicast_dns

Simple Rust wrapper around Avahi Daemon

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.

lib3h_mdns

lib3h mdns LAN discovery module

dynamixel2

dynamixel protocol 2.0

async-mpd

Async Mpd client library

timeout_io

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

brpc-protoc-plugin

Protobuf-compiler plugin for brpc-rs

ftp-client

A FTP client library

nng-sys

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

psocket

the socket for Rust

libtelnet-rs

libtelnet-inspired telnet parser for rust

manuf

Ethernet vendor codes, and well-known MAC addresses

dementia

A small client library for the Matrix protocol

gatekeeper

A SOCKS proxy implementation

matrix_bot_api

API for writing a bot for the Matrix messaging protocol

bincode-no-std

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

erpc-rs

eRPC library for Rust

pubnub-core

PubNub core crate, modular and composable

smolapps

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

temp_utp

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

telegram-bot-fork-raw

Telegram Bot API types

afxdp

AF XDP for Rust

rmonitor

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

splits-io-api

Bindings to the Splits.io API for Rust

winping

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

pcap_on_demand

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

catalyst-protocol-sdk-rust

Protocol Specification for Catalyst Network

async-port-scanner

Simple, yet fast, async port scanner library for Rust

actix_web_metrics_mw

Actix middleware library for metrics

sdp-types

SDP (RFC 4566) types, parser and serializer

runng

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

blip

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

domain

A DNS library for Rust

actori-router

Path router

rumq-core

Serializes and deserializes mqtt byte stream

varlink_generator

Rust code generator for the varlink protocol

bacnet_parse

no_std BACnet parser

bip_peer

Communication with bittorrent peers via peer wire protocol

pnet_datalink

Cross-platform, datalink layer networking

ds

A library for controlling FIRST Robotics Competition robots

telegram-bot-async-raw

Telegram Bot API types

requiem-service

Actix service

aurpc

Asynchronous UDP RPCs

tftp_server

A TFTP server implementation in Rust using mio

nispor

Unified interface for Linux network state querying

net-parser-rs

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

async-ssh2

Async wrapper over ssh2

onc-rpc

Open Network Computing / Sun RPC types and fast serialisation

td_proto_rust

bin protocol for Rust

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…

middleman

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

proxy_cfg

A library to get proxy configuration from the OS

potatonet

PotatoNet is a lightweight microservices framework

paxakos

Rust implementation of Paxos consensus algorithm

hwaddr

MAC address handling

dnscat-client

Standalone DNSCAT2 client

bmp-client

Tokio-based BMP client

iptools

Python iptools port for Rust

dtn7-plus

Additional helpers for rust dtn daemon

rustls-connector

Connector similar to openssl or native-tls for rustls

saltyrtc-client

Asynchronous SaltyRTC client implementation for Rust 1.26+

bubblebabble

The Bubble Babble Binary Data Encoding

azure_sdk_for_rust

Rust wrappers around Microsoft Azure REST APIs

network

netidx-tools

it’s like DNS for values

rusty_tarantool

Tarantul async client based on tokio framework

psk-client

Simple wrapper to facilitate TLS connections which use pre-shared keys

subspace

A convenience crate for IPC, using TcpStreams

multistream-select

Multistream-select negotiation protocol for libp2p

lib3h_protocol

Protocol definition for interacting with Lib3h

secretbox

Rust implementation of the secretbox encryption algorithm

amy

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

file_transfer

Enum to transfer files

http_header

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

pad-motion

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

tentacle-ping

ping protocol implementation for tentacle

rdp-rs

A Pure RUST imlementation of Remote Desktop Protocol

grpcio-sys

FFI bindings to gRPC c core library

google-games1-cli

A complete library to interact with Games (protocol v1)

oci-distribution

An OCI implementation in Rust

pf

transfer file command line tool

naia-server

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

rust-thrift-tls

Client and Server TLS support for Apache Thrift

wayk_proto

WaykNow packet encoder-decoder and sequencing utilities

actix-threadpool

Actix thread pool for sync code

actix-redis-jobs

Simple and reliable background processing for Rust using Actix and Redis

sozu-command-lib

configuration library to command a sozu instance

agate

Very simple server for the Gemini hypertext protocol

srtp2-sys

Binding for libsrtp

mpd_protocol

Implementation of MPD client protocol

azure-sdk-keyvault

Rust wrapper around Microsoft Azure REST APIs for Azure Key Vault

quick_crawler

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

tun-tap

TUN/TAP interface wrapper

librsyncr

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

cord-client

The client-side user interfaces for the Cord Platform that publish and subscribe messages to the Broker

rust_ofp

Rust OpenFlow 0x01 Protocol and Controller Framework

knx_rs

KNX Library

magnet-uri

A library for parsing Magnet URI scheme

libslirp-sys

FFI bindings for libslirp

nt-network

Networking types and codecs for nt-rs

requiem-router

Path router

sacn

Rust sACN implementation

opcua-certificate-creator

OPC UA certificate creator

tailscale

A set of application-level primitives for Tailscale

nearprotocol/near-network

Reference NEAR Protocol client

vivaldi

Efficient network point-to-point latency estimations for large scale clusters

ntpd

Simple NTP server and client

libipld-core

Base traits and definitions used by ipld codecs

dat-network-protocol

Dat Network Protocol protobuf definitions

multisock

Unified types for TCP & Unix sockets

lambda_http

Rust API Gateway proxy event interfaces for AWS Lambda

netflow_v9

Library for parsing Netflow-v9 packets

romio

Event loop and I/O resources for asynchronous network services using futures

transmission-rpc

Transmission JRPC client

sntp

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

ieee802154

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

xmpp-addr

An implementation of the XMPP Address format (Jabber ID) defined in RFC 7622

kf-protocol

Native Rust implementation of kafka protocol

hexavalent

Write HexChat plugins in Rust

artillery-core

Fire-forged cluster management & Distributed data protocol

rust-apex

Rust support for apex

mqttest

An MQTT server designed for unittesting MQTT clients

tentacle-secio

Secio encryption protocol for p2p

woopsa

A pure Rust library for Woopsa

rtorrent_xml_rpc

A crate to send XML RPC to rtorrent

minion

Crate for managing cancellable services

horokai-network

struct Network, graph in mathmatics

seinbot-rs

A seinfeld twitter bot using markov chains in rust

rusoto_ec2

AWS SDK for Rust - Amazon Elastic Compute Cloud @ 2016-11-15

net-utils

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

minirpc

A minimalist RPC framework

ironrdp

A Rust implementation of the Microsoft Remote Desktop Protocol

lando

Rust http interface for AWS lambda API gateway events

terraria-protocol

An implementation of Terraria’s multiplayer network protocol

naia-server-socket

An abstraction to provide a common API over either a UDP socket or a service that can establish WebRTC connections

robust-arduino-serial

Simple and robust serial communication protocol

netinfo-ffi

C FFI for netinfo, which groups network usage by process

telnetify

A tool for local development of TELNET applications

azure-sdk-rust

Under very heavy development It will most likely break! Microsoft Azure SDK for Rust. Originally designed to stay as close as possible to aws-sdk-rust but design decision changed to make it Azure specific…

libstrophe-sys-bindgen

Rust bindings for libstrophe, generated using bindgen

gotham_middleware_aws_sig_verify

Gotham middleware for AWS SigV4 verification

amq-protocol-codegen

AMQP specifications - codegen

fetch_configuration

Library to fetch configuration from config file

easyfibers

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

actix-lua

A safe scripting environment for actix with the Lua Programming Language

ipmpsc

Inter-process Multiple Producer, Single Consumer Channels

netsim

Network simulator

kinetic-rust

A Kinetic protocol library written in Rust

merge-io

Merge two separate AsyncRead and AsyncWrite objects into a single I/O stream

cdpay

CryptoDiggers payment API client

lrpc-macros

lrpc’s proc macros

fbvideo

Async crate to get video URLs from Facebook

bincode-thin

A fork of bincode with experimental hacks to have a smaller serialized size (for webrender)

rusty-p4

A (WIP) library for writing P4 controller in Rust

website-icon-extract

extract favicon link paths from a html page from different standards

online

📶 Library to check your Internet connectivity

tower-make

Trait aliases for Services that produce specific types of Responses

oxygengine-network-backend-web

Network Web backend module for Oxygen Engine

koibumi

An experimental Bitmessage client

sawtooth-zmq

High-level bindings to the zeromq library

my_internet_ip

Retrieve the public IP of the machine your app runs on

vk-bot

Build chat bots for VK (VKontakte) communities easily

hassium-network-backend-native

Network Native backend module for Hassium home automation engine

stegos_consensus

Stegos - Consensus Implementation

ssdp

An asynchronous abstraction for discovering devices and services on a network

netifs

Cross-platform utility library to enumerate local network interfaces

tcp-channel

SPSC channels, working on everything that implements Read and Write

scaproust

Nanomsg scalability protocols implementation in rust. Various messaging patterns over pluggable transports

lxi

LXI protocol implementation

pnet_transport

Cross-platform, transport layer networking

ellidri-tokens

Parse IRC like a boss

x11-input-mirror

Mirrors X11 (Xserver) input events from one PC to multiple over the network

rusturn

A Rust implementation of TURN server and client

wakey

Wake-on-LAN library for creating and sending magic WOL packets

psn_api_rs

A simple PSN Network API wrapper

proxy-enum

Emulate dynamic dispatch and sealed classes using a proxy enum, which defers all method calls to its variants

sysrepo

Sysrepo Rust bindings generatedy by bindgen

netstring

Library for encoding and decoding netstrings

ntp

Library for parsing and communicating over Network Time Protocol

tap-windows

tap-windows driver interface

clam-client

A simple Rust implementation for talking to ClamD

rupnp

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

discord-rpc-client

A Rust client for Discord RPC

someip_parse

A library for parsing the SOME/IP network protocol (without payload interpretation)

bytebuffer

A byte buffer for networking and binary protocols

autd-holo-gain

CSV Gain for AUTD

local-reconstruction-code-gen

Generate encode matrices for Local Reconstruction Codes

rodbus-client

A command line program for making Modbus client requests using the Rodbus crate

tokio-xmpp

Asynchronous XMPP for Rust with tokio

tokio-tower

Bridging the protocol gap between Tokio and Tower

actix-macros

Actix runtime macros

libaster

A light, fast and powerful cache proxy written in Rust

suricata-ipc

Library for sending packets to suricata and receiving output

samurai

Very early stage user-space P2P network protocol

sim1h

A simulation of lib3h

rpki-rtr

A library for RPKI RTR

rdap_client

Async and fast RDAP client and parser

pubnub-hyper

PubNub async crate based on Tokio and Hyper

golem-rpc-macros

Procedural macros for binding Brass Golem RPC endpoints

pnet_base_bandwhich_fork

Fundamental base types and code used by pnet

aws-region

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

kf-socket

Provide TCP socket wrapper using kafka protocol

grammers-mtproto

An implementation of the Mobile Transport Protocol

protocol-derive

Easy protocol definitions

elp

AWS ELB Access Log Parser

ipstuff

IP structures and utilities

ssb-handshake

Secret-handshake protocol for Secure Scuttlebutt

brpc-rs

Apache BRPC library for Rust

msgp

Byte message protocol for Rust

google-adexchangebuyer1d4-cli

A complete library to interact with Ad Exchange Buyer (protocol v1.4)

dnscat

DNSCAT2 protocol

ip_network_table-deps-treebitmap

Forked version of fast IPv4/IPv6 lookup trie

csfml-network-sys

Bindings to csfml-network

nbdserve

Simple network block device server

wayk_core

Provides data structures and other utilities used by Wayk products not specific to protocol itself

wamp_async

An asynchronous WAMP implementation

mles-utils

Mles-utils for Mles server and clients

radiotap

A parser for the Radiotap capture format. See http://www.radiotap.org.

c-ares

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

ip_network_table

IPv4 and IPv6 network fast lookup table

smtpbis

Asynchronous ESMTP service library

mosquitto-client

Rust interface to the Mosquitto MQTT broker client

lib3h_p2p_protocol

Lib3h Protocol definition for inter-node p2p communication

updns

DNS proxy tool

kf-protocol-transport

Transport frame encoder and decoder for Kakfa protocol