Lib.rs

actix-rt

Actix runtime

rusoto_core

AWS SDK for Rust - Core

zmq

High-level bindings to the zeromq library

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…

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…

grpcio

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

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

irc

the irc crate – usable, async IRC for Rust

tarpc

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

rust-s3

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

etherparse

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

mles

Mles - a distributed publish/subscribe data server

shadowsocks-rust

shadowsocks is a fast tunnel proxy that helps you bypass firewalls

backoff

Retry operations with exponential backoff policy

rusoto_s3

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

actix-service

Actix service

yamux

Multiplexer over reliable, ordered connections

doh-proxy

A DNS-over-HTTPS (DoH) proxy

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.

twitchchat

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

libp2p

Peer-to-peer networking library

smoltcp

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

quinn-proto

State machine for the QUIC transport protocol

capnp-rpc

implementation of the Cap’n Proto remote procedure call protocol

ipconfig

Get network adapters information and network configuration for windows

ipnetwork

A library to work with IP CIDRs in Rust

schannel

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

grpcio-compiler

gRPC compiler for grpcio

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.

tentacle

Minimal implementation for a multiplexed p2p network framework

prometheus_wireguard_exporter

Prometheus WireGuard Exporter

google-dns1

A complete library to interact with dns (protocol v1)

mqtt-protocol

MQTT Protocol Library

ether-dream

A full implementation of the Ether Dream Laster DAC protocol

protocol

Easy protocol definitions

raptorq

RaptorQ (RFC6330)

amq-protocol

AMQP specifications

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

libunftp

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

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…

sentry-types

Common reusable types for implementing the sentry.io protocol

quic-p2p

Peer-to-peer networking library using QUIC

imap-proto

IMAP protocol parser and data structures

nng

A safe wrapper for NNG (Nanomsg v2)

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…

quinn

QUIC transport protocol implementation for Tokio

lambda_runtime

Rust runtime for AWS Lambda

netaddr2

A Rust network address parsing and arithmetic library

tonic-build

Codegen module of tonic gRPC implementation

qlog

qlog data model for QUIC and HTTP/3

queen

message queue

env_proxy

Determination of proxy parameters for a URL from the environment

pulsar

Rust API bindings for Apache Pulsar

encrypted-dns

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

rustls-native-certs

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

natsio

A Rust NATS client

state

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

zmq-sys

Low-level bindings to the zeromq library

ip_network

IPv4 and IPv6 network structs

nordselect

Select the ideal NordVPN server

google-adsense1d4-cli

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

rusoto_sts

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

iovec

Portable buffer type for scatter/gather I/O operations

rusp

The Rust USP toolkit

new-tokio-smtp

extendible smtp implementation for tokio

solicit

A library implementation of HTTP/2

rw-stream-sink

Adaptator between Stream/Sink and AsyncRead/AsyncWrite

tower-service

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

telegram-bot-raw

Telegram Bot API types

mqttrs

Mqtt protocol encoding and decoding

oxygengine-network

Network module for Oxygen Engine

faktory

API bindings for the language-agnostic Faktory work server

rpki

A library for validating and creating RPKI data

libstrophe

Rust ergonomic wrapper for libstrophe

varlink

Client and server support for the varlink protocol

azure_sdk_for_rust

Rust wrappers around Microsoft Azure REST APIs

pcarp

A pure-Rust library for reading pcap-ng files

iprange

A library to manage IP ranges

beanstalkc

Yet another simple Beanstalkd client for Rust

async_ftp

FTP client for Rust

ethox

A standalone network stack for user-space networking and unikernels

actori-service

Actori service

actyxos_sdk

Tools for interacting with the services of an ActyxOS node

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

runng-sys

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

librsync

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

aster-proxy

A light, fast and powerful cache proxy written in Rust

coap

A CoAP library

wifiscanner

List WiFi hotspots in your area

ldap3

Pure-Rust LDAPv3 Client

fibers_rpc

RPC library built on top of fibers crate

pca9956b-api

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

packet_crafter

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

xmpp-parsers

Collection of parsers and serialisers for XMPP extensions

natsclient

NATS client designed for both an ergonomic API and performance

paho-mqtt-sys

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

ipp

Asynchronous IPP print protocol implementation

poldercast

Peer to Peer topology management

oping

Rust bindings for liboping, a simple ICMP ping library

mesalock-linux/mesalink

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

a2

A native, asynchronous Apple push notification client

actix-connect

Actix connect - tcp connector service

irc-proto

The IRC protocol distilled

netstat2

Cross-platform library to retrieve network sockets information

pnet_macros_support

Support library for libpnet_macros

requiem-service

Actix service

abci-rs

A Rust crate for creating ABCI applications

osshkeys

A library to read and write OpenSSH public and private keys

wmata

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

tiny

An IRC client

gpsd_proto

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

input_buffer

A peekable FIFO-like buffer for receiving network data efficiently

io-uring

The io_uring library for Rust

vpncloud

Peer-to-peer VPN

lib3h

The lib3h p2p communication rust library

knx_examples_rs

Examples for KNX Library

mles-client

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

secded

Single Error Correction, Double Error Detection Codes for Everyone

rcon

An rcon protocol implementation

ccsds_primary_header

Implementation of the CCSDS Primary Header for space applications

shorty

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

telnet

A simple implementation of telnet protocol

pcap

A packet capture API around pcap/wpcap

rust-doh-proxy

Rust DNS over HTTPS proxy application

cidr

IP network and IP host withing network types

ellidri

Your kawaii IRC server

opcua-core

Core components for OPC UA used by client and server

fast-socks5

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

sntp_request

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

enet

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

rodbus

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

jid

A crate which provides a Jid struct for Jabber IDs

telebot

A wrapper around the telegram bot api, powered by futures

poston

Yet another Fluentd logger for Rust

tokio-socks

Asynchronous SOCKS proxy support for Rust

port_check

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

keyphrase

KeyPhrase generation for the EARTH Network

packet-builder

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

google-analytics3-cli

A complete library to interact with analytics (protocol v3)

what

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

rsntp

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

figma-asset-downloader

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

bolt-proto

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

tokio-tls-api

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

netidx

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

hdlc

Rust implementation of HDLC with support of the IEEE standard

astro-dnssd

Simple & safe DNS-SD wrapper

adventure

Helps your great adventure for the various type of requests

fractal-matrix-api

Library to communicate with a Matrix.org server

url-bot-rs

Minimal IRC URL bot in Rust

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

mac_address

Cross-platform retrieval of a network interface MAC address

ssdp-client

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

kipa

Distributed Key to IP Address (KIPA) query network

beanstalkd

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

openssh

SSH through OpenSSH

kf-protocol

Native Rust implementation of kafka protocol

amiquip

Pure Rust RabbitMQ client

buffering

A library primarily designed for network packet buffer operations

ncgopher

An ncurses gopher client for the modern internet

nbd

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

packet

Network packet handling

rusoto_logs

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

abbegm

externally guided motion for ABB industrial robots

tcp-warp-cli

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

dlt_parse

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

pdu

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

no-std-net

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

utp

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

amq-protocol-types

AMQP specifications - types

grpcio-sys

FFI bindings to gRPC c core library

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

service_world

Discover services from Hasicorp’s consul

twilio-async

An async and ergonomic wrapper around Twilio API & TwiML

async-listen

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

ur20

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

actix-router

Path router

get-port

Get an available port

svc-agent

An agent library

nfq

Rust library for dealing with NetFilter queue

wifi-rs

Interface with and manage Wireless Network (WiFi)

capsule

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

i3_ipc

For communicating with i3 over it’s IPC interface synchronously

oui

Lookup MAC OUI vendor information from the Wireshark manufacturer database

fahrenheit

toy futures executor (formerly known as toykio)

lambda_runtime_client

Client SDK for AWS Lambda’s runtime APIs

prosafe_exporter

Prometheus exporter for NETGEAR switches supported by ProSAFE Plus utility

hassium-network

Network module for Hassium home automation engine

oxygengine-network-backend-web

Network Web backend module for Oxygen Engine

bytebuffer-rs

A bytebuffer for networking and binary protocols

cannyls_rpc

RPC library for operating cannyls’s devices from remote nodes

ax25

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

rqpush

A library to assist with pushing notifications to RQueue

ftp-client

A FTP client library

postgres-inet

CIDR/INET support for rust-postgres

async-tftp

Async TFTP implementation

agate

Very simple server for the Gemini hypertext protocol

dementia

A small client library for the Matrix protocol

amqp

AMQP/RabbitMQ protocol client

resolv

DNS resolution via glibc

nearby

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

psocket

the socket for Rust

nannou_osc

The OSC API for Nannou, the creative coding framework

srvrls

A lightweight, opinionated serverless framework reducing boilerplate

afxdp

AF XDP for Rust

libp2p-core

Core traits and structs of libp2p

natpmp

NAT-PMP client library

ssb-packetstream

Secure Scuttlebutt packet stream protocol

grpc-protobuf

Protobuf marshaller for gRPC

phroxy

phroxy proxies gopher through HTTP

telegram-bot-async-raw

Telegram Bot API types

zenscan

This program is port scanner to target server

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

pubnub-core

PubNub core crate, modular and composable

dnscat-client

Standalone DNSCAT2 client

timeout_io

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

rust-thrift-tls

Client and Server TLS support for Apache Thrift

manuf

Ethernet vendor codes, and well-known MAC addresses

rumq-core

Serializes and deserializes mqtt byte stream

tarpc-plugins

Proc macros for tarpc

jsonrpc

Rust support for the JSON-RPC 2.0 protocol

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!

bacnet_parse

no_std BACnet parser

multicast_dns

Simple Rust wrapper around Avahi Daemon

actori-router

Path router

temp_utp

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

telegram-bot-fork-raw

Telegram Bot API types

rmonitor

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

winping

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

bgp-rs

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

tower-limit

Limit maximum request rate to a Service

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

actix_web_metrics_mw

Actix middleware library for metrics

joyent-tokio-zookeeper

Asynchronous client library for interacting with Apache ZooKeeper

async-port-scanner

Simple, yet fast, async port scanner library for Rust

wayk_proto

WaykNow packet encoder-decoder and sequencing utilities

splits-io-api

Bindings to the Splits.io API for Rust

smolapps

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

sdp-types

SDP (RFC 4566) types, parser and serializer

tftp_server

A TFTP server implementation in Rust using mio

mpd_protocol

Implementation of MPD client protocol

bip_peer

Communication with bittorrent peers via peer wire protocol

pnet_datalink

Cross-platform, datalink layer networking

blip

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

proxy_cfg

A library to get proxy configuration from the OS

libtelnet-rs

libtelnet-inspired telnet parser for rust

rpcx

A rpc/microservice framework

pf

transfer file command line tool

nng-sys

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

ds

A library for controlling FIRST Robotics Competition robots

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

secretbox

Rust implementation of the secretbox encryption algorithm

rdp-rs

A Pure RUST imlementation of Remote Desktop Protocol

openssh-keys

read and write OpenSSH public keys

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

td_proto_rust

bin protocol for Rust

psk-client

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

nearprotocol/near-network

Reference NEAR Protocol client

runng

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

tentacle-ping

ping protocol implementation for tentacle

saltyrtc-client

Asynchronous SaltyRTC client implementation for Rust 1.26+

network

http_header

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

ironrdp

A Rust implementation of the Microsoft Remote Desktop Protocol

file_transfer

Enum to transfer files

lib3h_protocol

Protocol definition for interacting with Lib3h

bubblebabble

The Bubble Babble Binary Data Encoding

domain

A DNS library for Rust

azure_sdk_storage_blob

Rust wrappers around Microsoft Azure REST APIs - Blob storage crate

amy

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

gatekeeper

A SOCKS proxy implementation

mqttest

An MQTT server designed for unittesting MQTT clients

pad-motion

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

tcp-stream

mio’s TcpStream on steroids

knx_rs

KNX Library

google-games1-cli

A complete library to interact with Games (protocol v1)

dtn7-plus

Additional helpers for rust dtn daemon

xmlrpc

An XML-RPC implementation for Rust

romio

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

librsyncr

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

opcua-certificate-creator

OPC UA certificate creator

requiem-router

Path router

hwaddr

MAC address handling

srtp2-sys

Binding for libsrtp

dat-network-protocol

Dat Network Protocol protobuf definitions

paxakos

Rust implementation of Paxos consensus algorithm

azure-sdk-keyvault

Rust wrapper around Microsoft Azure REST APIs for Azure Key Vault

vivaldi

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

tun-tap

TUN/TAP interface wrapper

varlink_generator

Rust code generator for the varlink protocol

cord-client

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

iptools

Python iptools port for Rust

rust_ofp

Rust OpenFlow 0x01 Protocol and Controller Framework

fbvideo

Async crate to get video URLs from Facebook

i2cbus-api

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

netflow_v9

Library for parsing Netflow-v9 packets

magnet-uri

A library for parsing Magnet URI scheme

actix-redis-jobs

Simple and reliable background processing for Rust using Actix and Redis

libslirp-sys

FFI bindings for libslirp

moped-backend

Mpd to json

sacn

Rust sACN implementation

tentacle-secio

Secio encryption protocol for p2p

actix-threadpool

Actix thread pool for sync code

woopsa

A pure Rust library for Woopsa

oci-distribution

An OCI implementation in Rust

horokai-network

struct Network, graph in mathmatics

rupnp

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

lambda_http

Rust API Gateway proxy event interfaces for AWS Lambda

ntpd

Simple NTP server and client

libipld-core

Base traits and definitions used by ipld codecs

xmpp-addr

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

streams-rs

OCaml like streams for Russt

actori-rt

Actori runtime

transmission-rpc

Transmission JRPC client

sntp

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

lando

Rust http interface for AWS lambda API gateway events

seinbot-rs

A seinfeld twitter bot using markov chains in rust

ieee802154

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

nt-network

Networking types and codecs for nt-rs

lavish-compiler

Compiler for the Lavish IDL

netsim

Network simulator

rusty_tarantool

Tarantul async client based on tokio framework

grpcio-proto

Public proto files for grpcio

hexavalent

Write HexChat plugins in Rust

rust-apex

Rust support for apex

merge-io

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

minion

Crate for managing cancellable services

easyfibers

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

fetch_configuration

Library to fetch configuration from config file

cdpay

CryptoDiggers payment API client

multisock

Unified types for TCP & Unix sockets

net-utils

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

rusoto_ec2

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

ipmpsc

Inter-process Multiple Producer, Single Consumer Channels

terraria-protocol

An implementation of Terraria’s multiplayer network protocol

requiem-utils

Actix utils - various actix net related services

robust-arduino-serial

Simple and robust serial communication protocol

actix-macros

Actix runtime macros

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…

ntp

Library for parsing and communicating over Network Time Protocol

amq-protocol-codegen

AMQP specifications - codegen

website-icon-extract

extract favicon link paths from a html page from different standards

tokio-xmpp

Asynchronous XMPP for Rust with tokio

hassium-network-backend-native

Network Native backend module for Hassium home automation engine

kinetic-rust

A Kinetic protocol library written in Rust

lxi

LXI protocol implementation

libstrophe-sys-bindgen

Rust bindings for libstrophe, generated using bindgen

wakey

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

ttrpc

A Rust version of ttrpc

tcp-channel

SPSC channels, working on everything that implements Read and Write

rusty-p4

A (WIP) library for writing P4 controller in Rust

gotham_middleware_aws_sig_verify

Gotham middleware for AWS SigV4 verification

sawtooth-zmq

High-level bindings to the zeromq library

ellidri-tokens

Parse IRC like a boss

bincode-thin

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

vk-bot

Build chat bots for VK (VKontakte) communities easily

autd-holo-gain

CSV Gain for AUTD

wayk_core

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

psn_api_rs

A simple PSN Network API wrapper

rdap_client

Async and fast RDAP client and parser

stegos_consensus

Stegos - Consensus Implementation

actix-lua

A safe scripting environment for actix with the Lua Programming Language

rodbus-client

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

ssdp

An asynchronous abstraction for discovering devices and services on a network

quick_crawler

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

scaproust

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

rusturn

A Rust implementation of TURN server and client

elp

AWS ELB Access Log Parser

x11-input-mirror

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

dusk-uds

Minimalistic boilerplate for UnixListener bindings

online

📶 Library to check your Internet connectivity

bgb-link

An implementation of BGB’s link protocol

netstring

Library for encoding and decoding netstrings

pnet_transport

Cross-platform, transport layer networking

clam-client

A simple Rust implementation for talking to ClamD

pubnub-hyper

PubNub async crate based on Tokio and Hyper

oxygengine-network-backend-native

Network Native backend module for Oxygen Engine

libhoney-rust

Rust library for sending data to Honeycomb

tap-windows

tap-windows driver interface

wamp_async

An asynchronous WAMP implementation

airmash-protocol

Protocol library for airma.sh

banananet

A protocol for decentralized information management

someip_parse

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

ipinfo

ipinfo: A Rust library for IPInfo

grammers-mtproto

An implementation of the Mobile Transport Protocol

bytebuffer

A byte buffer for networking and binary protocols

my_internet_ip

Retrieve the public IP of the machine your app runs on

ip_network_table-deps-treebitmap

Forked version of fast IPv4/IPv6 lookup trie

septid

Pure Rust implementation of the spiped protocol

lrpc

local rpc

snmp

SNMP client library

samurai

Very early stage user-space P2P network protocol

framed-serial

Add frames to serial connections. Useful for embedded devices. Can be built with no_std.

sim1h

A simulation of lib3h

rpki-rtr

A library for RPKI RTR

mux

mux codecs for rust

ssb-handshake

Secret-handshake protocol for Secure Scuttlebutt

updns

DNS proxy tool

network-manager

Rust NetworkManager bindings

suricata-ipc

Library for sending packets to suricata and receiving output

golem-rpc-macros

Procedural macros for binding Brass Golem RPC endpoints

network-framework-sys

Network.framework bindings for macOS and iOS

fast-rpc

streaming JSON RPC over TCP

dpdk-virtual-devices

A wrapper around DPDK’s virtual devices framework

mosquitto-client

Rust interface to the Mosquitto MQTT broker client

aws-region

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

libaster

A light, fast and powerful cache proxy written in Rust

protocol-derive

Easy protocol definitions

async-mpd

Async Mpd client library

sonor

a library for controlling sonos speakers

msgp

Byte message protocol for Rust

reliudp

A custom Reliable UDP protocol for Rust

libp2p-swarm

The libp2p swarm

irc3

An IRC3 client and server toolchain

mbus-api

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

nbdserve

Simple network block device server

pnet_base_bandwhich_fork

Fundamental base types and code used by pnet

bip_utracker

Communication with bittorrent UDP trackers

tun-tap-mac

TUN/TAP interface wrapper

pnetlink

Netlink library in pure rust

ip_network_table

IPv4 and IPv6 network fast lookup table

varmint

A Rust implementation of the varint codec as used in Google’s Protocol Buffers

cobalt

Low level, UDP based networking library

rustls-connector

Connector similar to openssl or native-tls for rustls

proxy-enum

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

dnscat

DNSCAT2 protocol

google-drive3-cli

A complete library to interact with drive (protocol v3)

tokio-zookeeper

Asynchronous client library for interacting with Apache ZooKeeper

csfml-network-sys

Bindings to csfml-network

mles-utils

Mles-utils for Mles server and clients

tower-make

Trait aliases for Services that produce specific types of Responses

c-ares

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

yip

TCP server that responds with callers IP address

linux-io-uring

The io_uring library for Rust

lib3h_p2p_protocol

Lib3h Protocol definition for inter-node p2p communication

libdoh

DoH library for the rust-doh app

dockers

A rust docker library