Lib.rs

ipnet

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…

tonic

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

socket2

handling networking sockets with a maximal amount of configuration possible intended

quinn

Versatile QUIC transport protocol implementation

iroh

p2p quic connections dialed by public key

async-nats

A async Rust NATS client

rustls-native-certs

allows rustls to use the platform native certificate store

async-graphql

A GraphQL server library implemented in Rust

etherparse

parsing & writing a bunch of packet based protocols (EthernetII, IPv4, IPv6, UDP, TCP ...)

tower

modular and reusable components for building robust clients and servers

mdns-sd

mDNS Service Discovery library with no async runtime dependency

tun-rs

Cross-platform TUN and TAP library

aws-sdk-kms

AWS SDK for AWS Key Management Service

native-tls

A wrapper over a platform's native TLS implementation

hickory-proto

safe and secure low-level DNS library. This is the foundational DNS protocol library used by the other higher-level Hickory DNS crates.

libp2p

Peer-to-peer networking library

connectrpc

A Tower-based Rust implementation of the ConnectRPC protocol

ipnetwork

work with IP CIDRs in Rust

suppaftp

A super FTP/FTPS client library for Rust

rumqttc

An efficient and robust mqtt client for your connected devices

etcd-client

An etcd v3 API client

tonic-build

Codegen module of tonic gRPC implementation

dns-lookup

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

matchit

A high performance, zero-copy URL router

if-addrs

Return interface IP addresses on Posix and windows systems

cid

CID in rust

tun

TUN device creation and handling

hyperlocal

Hyper bindings for Unix domain sockets

russh

A client and server SSH library

s2n-quic

IETF QUIC protocol

azure_identity

Rust wrappers around Microsoft Azure REST APIs - Azure identity helper crate

aws-sdk-s3

AWS SDK for Amazon Simple Storage Service

governor

A rate-limiting implementation in Rust

async-net

Async networking primitives for TCP/UDP/Unix communication

zenoh

Zero Overhead Pub/Sub/Query Protocol

socketcan

Linux SocketCAN library. Send and receive CAN frames via CANbus on Linux.

quiche

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

network-interface

Retrieve system's Network Interfaces on Linux, FreeBSD, macOS and Windows on a standarized manner

capnp-rpc

Cap'n Proto remote procedure call protocol

tower-http

Tower middleware and utilities for HTTP clients and servers

netlink-sys

netlink sockets, with optional integration with tokio

firestore

API for Google Firestore and own Serde serializer based on efficient gRPC API

aws-sdk-bedrockruntime

AWS SDK for Amazon Bedrock Runtime

agate

Very simple server for the Gemini hypertext protocol

russh-sftp

SFTP subsystem supported server and client for Russh

loro

high-performance CRDTs framework. Make your app collaborative efforlessly.

arti-client

connecting to the Tor network as an anonymous client

actix-service

Service trait and combinators for representing asynchronous request/response operations

netdev

Cross-platform library for enumerating network interfaces with metadata

surge-ping

Asynchronous ICMP ping library

yamux

Multiplexer over reliable, ordered connections

str0m

WebRTC library in Sans-IO style

fe2o3-amqp

AMQP1.0 protocol based on serde and tokio

tonic-health

Health Checking module of tonic gRPC implementation

domain

A DNS library for Rust

google-cloud-auth

Google Cloud Client Libraries for Rust - Authentication

tokio-socks

Asynchronous SOCKS proxy support for Rust

ipconfig

Get network adapters information and network configuration for windows

rskafka

A minimal Rust client for Apache Kafka

wtransport

WebTransport (over HTTP3) protocol

aws-sdk-sqs

AWS SDK for Amazon Simple Queue Service

hickory-resolver

safe and secure DNS stub resolver library intended to be a high-level library for DNS record resolution

pingora

A framework to build fast, reliable and programmable networked systems at Internet scale

iroh-gossip

gossip messages over broadcast trees

raptorq

(RFC6330)

gix-transport

gitoxide project dedicated to implementing the git transport layer

spider

A web crawler and scraper, building blocks for data curation workloads

pmcp

High-quality Rust SDK for Model Context Protocol (MCP) with full TypeScript SDK compatibility

gcloud-sdk

Async Google gRPC/REST APIs and the client implementation hiding complexity of GCP authentication based on Tonic middleware and Reqwest

addr

parsing domain names

rtc

Sans-I/O WebRTC implementation in Rust

axum-prometheus

A tower middleware to collect and export HTTP metrics for Axum

amqprs

AMQP 0-9-1 client implementation for RabbitMQ

smg-mesh

Mesh gossip protocol and distributed state synchronization for Shepherd Model Gateway

pcap

A packet capture API around pcap/wpcap

pkarr

Public-Key Addressable Resource Records (Pkarr); publish and resolve DNS records over Mainline DHT

libunftp

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

aws-smithy-http-client

HTTP client abstractions for generated smithy clients

tarpc

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

wr_malloc_size_of

Internal utility to measure memory usage in WebRender

azure_storage_blob

Microsoft Azure Blob Storage client library for Rust

openssh

SSH through OpenSSH

pact_consumer

Pact-Rust module that provides support for writing consumer pact tests

rsntp

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

azure_devops_rust_api

Rust API library for Azure DevOps

google-androidpublisher3

A complete library to interact with Android Publisher (protocol v3)

bgpkit-parser

MRT/BGP/BMP data processing library

discv5

p2p discv5 discovery protocol

getifs

Cross-platform enumeration of network interfaces and their MTU, gateway, multicast, and local/private/public IP addresses

pnet

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

dust_dds

Data Distribution Service (DDS) implementation

nacos-sdk

Nacos client in Rust

dhcproto

A DHCP parser and encoder for DHCPv4/DHCPv6. dhcproto aims to be a functionally complete DHCP implementation.

listeners

Cross-platform library to find out processes listening on network ports

retry-policies

A collection of plug-and-play retry policies for Rust projects

gping

Ping, but with a graph

foca

Gossip-based cluster membership discovery, based on SWIM

buf-list

A list of buffers that implements the bytes::Buf trait

tls-parser

Parser for the TLS protocol

matrix-commander

but convenient CLI-based Matrix client app for sending and receiving

binstalk-downloader

The binstall toolkit for downloading and extracting file

boringtun

WireGuard® protocol designed for portability and speed

zeromq

A native Rust implementation of ZeroMQ

async-memcached

An Tokio-based memcached client for Rust

nftables

Safe abstraction for nftables JSON API. It can be used to create nftables rulesets in Rust and parse existing nftables rulesets from JSON.

iprange

manage IP ranges

netflow_parser

Parser for Netflow Cisco V5, V7, V9, IPFIX

pulsar

Rust client for Apache Pulsar

web-transport-quinn

WebTransport library for Quinn

netstat2

Cross-platform library to retrieve network sockets information

rabbitmq-stream-client

client for RabbitMQ Stream

jupyter-protocol

Jupyter messaging structures and traits for jupyter clients and servers

restate-sdk

Restate SDK for Rust

webrtc-sdp

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.

ssh2-config

an ssh configuration parser for ssh2-rs

axum-client-ip

Client IP address extractors for Axum

rtnetlink

manipulate linux networking resources via netlink

wireman

A TUI based gRPC client

axum-streams

HTTP body streaming support for Axum: json/csv/protobuf/arrow/txt

rs-consul

access to a set of strongly typed apis to interact with consul (https://www.consul.io/)

mac_address

Cross-platform retrieval of a network interface MAC address

gcloud-pubsub

Google Cloud Platform pubsub client library

servo

A component of the servo web-engine

iceoryx2

Lock-Free Zero-Copy Interprocess Communication

litep2p

Peer-to-peer networking library

renet

Server/Client network library for multiplayer games with authentication and connection management

deepgram

Community Rust SDK for Deepgram's automated speech recognition APIs

aws-lc-fips-sys

AWS-LC is a general-purpose cryptographic library maintained by the AWS Cryptography team for AWS and their customers. This is the FIPS validated version of AWS-LC.

unit

A self-replicating software nanobot — minimal Forth interpreter that is also a networked mesh agent

rusteron-client

core client functionalities for interacting with the Aeron protocol, such as establishing connections, subscribing, and publishing. It uses the Aeron C bindings from aeron-client module.

tower-mcp

Tower-native Model Context Protocol (MCP) implementation

azure_storage

Azure Storage crate from the Azure SDK for Rust

goku-bench

Goku is an HTTP load testing application written in Rust

lumina-utils

Platform abstraction utilities used across lumina project

cidr

IP network and IP host within network types

ntex-mqtt

Client and Server framework for MQTT v5 and v3.1.1 protocols

if-watch

crossplatform asynchronous network watcher

sozu-command-lib

configuration library to command a sozu instance

dynamo-runtime

Dynamo Runtime Library

turmoil

Simulation testing framework for distributed systems

igd-next

Internet Gateway Protocol client

retina

high-level RTSP multimedia streaming library

netcdf

High-level NetCDF bindings for Rust

pdu

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

ntpd

Full-featured implementation of NTP with NTS support

vopono

Launch applications via VPN tunnels using temporary network namespaces

crux_core

Cross-platform app development in Rust

remoc

🦑 Remote multiplexed objects, channels, observable collections and RPC making remote interactions seamless. Provides multiple remote channels and RPC over TCP, TLS or any other transport.

rsbinder

Pure-Rust Binder IPC for Linux, Android, and macOS — kernel binder plus a libbinder-compatible RPC (binder-over-socket) transport

tentacle

Minimal implementation for a multiplexed p2p network framework

defguard_wireguard_rs

A unified multi-platform high-level API for managing WireGuard interfaces

getifaddrs

A cross-platform library for retrieving network interface addresses and indices (getifaddrs, if_nametoindex, if_indextoname)

ip_network

IPv4 and IPv6 network structs

rumqttc-v4-next

Explicit MQTT 3.1.1 client crate in the rumqttc-next family

tobaru

Port forwarding CLI utility written in Rust with allowlists, TLS SNI and ALPN routing, HTTP forwarding, load balancing, IP-to-destination mapping, and iptables support

temporalio-client

Clients for interacting with Temporal

magnetar-runtime-moonpool

moonpool runtime engine for magnetar — deterministic-sim friendly. Custom rustls-over-bytepipe TLS adapter. No channels.

patchbay

Linux network-namespace lab for NAT, routing, and link-impairment experiments

pubky

SDK

google-cloud-storage

Google Cloud Client Libraries for Rust - Storage

dropshot-api-manager

Manage OpenAPI documents generated by Dropshot

rustdds

Native Rust DDS implementation with RTPS

uhyve

A specialized hypervisor for Hermit

pistol

about Cybersecurity

bytesbuf

Types for creating and manipulating byte sequences

cloud-copy

copying files to and from cloud storage

kanade

Admin CLI for the kanade endpoint-management system. Deploy YAML manifests, schedule cron jobs, kill running jobs, revoke commands, publish new agent releases — over NATS + HTTP

magic-wormhole

Get things from one computer to another, safely

snf-core

Deterministic, offline-first network protocol analysis engine

moshpit

client (mp) — encrypted, resilient remote terminal session client

stun-rs

Rust framework to manage STUN messages

socks5-impl

Fundamental abstractions and async read / write functions for SOCKS5 protocol and Relatively low-level asynchronized SOCKS5 server implementation based on tokio

sniffnet

Application to comfortably monitor your network traffic

pea2pea

A lightweight, performant microkernel for TCP peer-to-peer (P2P) networking. Handles connection pooling and framing, leaving the logic to you.

worker-build

be used as a custom build command for a Cloudflare Workers workers-rs project

sse-stream

Conversion between http body and sse stream

tailscale

A work-in-progress Tailscale implementation

wayfind

A speedy, flexible router

libssh2-sys

Native bindings to the libssh2 library

apt-transport-blob

rama-socks5

SOCKS5 support for rama

mqtt5

Complete MQTT v5.0 platform with high-performance async client and full-featured broker supporting TCP, TLS, WebSocket, authentication, bridging, and resource monitoring

rustack-cli

A high-performance, LocalStack-compatible AWS service emulator written in Rust — 18 services, <1s startup, ~8 MB Docker image

doh-proxy

A DNS-over-HTTPS (DoH) and ODoH (Oblivious DoH) proxy

irc

usable, async IRC for Rust

quinn-proto

State machine for the QUIC transport protocol

azure_security_keyvault_secrets

Rust wrappers around Microsoft Azure REST APIs - Azure Key Vault Secrets

cheetah-string

An immutable, clone-cheap UTF-8 string with explicit construction and byte interoperability

certon

Automatic HTTPS/TLS certificate management via the ACME protocol

openssh-sftp-client

Highlevel API used to communicate with openssh sftp server

netidx

Secure, fast, pub/sub messaging

aws-smithy-mocks

Testing utilities for smithy-rs generated clients

network-types

Rust structs representing network-related types in Linux

gotatun

WireGuard® protocol designed for portability and speed

http-handle

A fast and lightweight Rust library for handling HTTP requests and responses

linkerd2-proxy-api

Linkerd Proxy API gRPC bindings and utilities

tls-listener

wrap incoming Stream of connections in TLS

udp-over-tcp

Command-line tool for tunneling UDP datagrams over TCP

iptools

High-performance IPv4/IPv6 utilities and iterators inspired by Python's iptools

remotefs-ssh

remotefs SSH client library

crawlberg

High-performance web crawling engine

metainfo

Transmissing metainfo across components

fast-socks5

Fast SOCKS5 client/server implementation written in Rust async/.await (tokio)

jowtun

A small TCP relay that scrambles traffic with a deliberately non-cryptographic, password-seeded stream cipher. A teaching toy, not real security.

edge-dhcp

Async + no_std + no-alloc implementation of the DHCP protocol

turnip-tunnel

IP/Ethernet tunnel backed by a half-duplex serial port

amq-protocol

AMQP specifications

tonic-prost-build

Prost build integration for tonic

ppp

A Proxy Protocol Parser written in Rust. See HAProxy for the protocol specification.

dlt_parse

parsing the "Diagnostic Log and Trace" network protocol (currently without payload interpretation)

netwatcher

List network interfaces and watch for changes efficiently

sacn

ANSI E1.31 Streaming ACN protocol, tested against protocol version ANSI E1.31-2018

maybenot

A framework for traffic analysis defenses

google-sheets4

A complete library to interact with Sheets (protocol v4)

dockworker

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

rustrtc

A high-performance real-time communication library — WebRTC, RTP/SRTP, T.38 Fax, and RTP Latching

yoagent

effective agent loop with tool execution and event streaming

lua-astra

🔥 Blazingly Fast 🔥 runtime environment for Lua

tun2proxy

Tunnel interface to proxy

attohttpc

Small and lightweight HTTP client

ax-runtime

Runtime library of ArceOS

demagnetize

Convert magnet links to .torrent files

http-content-range

HTTP Content Range response header parser

rsurl

A pure-Rust implementation of curl. Library, C FFI, and CLI for HTTP/HTTPS/FTP/FTPS.

discord-presence

client for Discord RPC

proxelar

MITM proxy for HTTP/HTTPS traffic

upnp-daemon

A daemon for continuously opening ports via UPnP

port_check

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

vsock

Virtio socket support for Rust

zlink

Async Varlink API

twitch-hls-client

Minimal CLI client for watching Twitch streams

fakecloud-iam

IAM and STS implementation for FakeCloud

railwayapp

Interact with Railway via CLI

turbomcp

Rust SDK for the Model Context Protocol (MCP): macro-driven servers and a typed client, dual protocol versions, stdio/HTTP/WebSocket transports, OAuth 2.1, OpenTelemetry

rf-cli

RavenFabric — CLI client (rf)

unftp

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

taws

Terminal UI for AWS - navigate, observe, and manage AWS resources

coap-lite

A lightweight CoAP message manipulation crate, ideal for embedded environments

renet2

Server/Client network protocol library for multiplayer games, forked from renet

replaybook

Incident replay trainer - fix broken infrastructure in real Docker environments

port-selector

that provides functions to port availability checking, port filtering based on conditions and occupy specified ports

rusty-penguin

A fast TCP/UDP tunnel, transported over HTTP WebSocket

domain-check

A fast CLI tool for checking domain availability using RDAP with WHOIS fallback

timestamped-socket

async UDP and raw ethernet sockets with timestamping

libdd-data-pipeline

Trace exporter package allowing sending data from datadog SDKs to the Trace Agent

pyo3-object_store

object_store integration for pyo3

ant-node

Pure quantum-proof network node for the Autonomi decentralized network

sflow-parser

InMon sFlow v5 Parser

packet_parser

A powerful and modular Rust crate for network packet parsing

tonic-prost

Prost codec implementation for tonic

simple-someip

A lightweight SOME/IP serialization and communication library

xmpp-parsers

Collection of parsers and serialisers for XMPP extensions

hyperi-rustlib

There's plenty of sage advice out there about how to run Rust services in production at scale — config cascades, structured logging, masking secrets, multi-backend secrets management…

kcr_kafka_strimzi_io

Kubernetes Custom Resource Bindings

ngx

FFI bindings to NGINX

route_manager

Cross-platform route management interface

innernet

A client to manage innernet network interfaces

rsipstack

SIP Stack Rust library for building SIP applications

swayipc

controlling sway through its IPC interface

tokio-listener

Add flexibility in a way of accepting connections: unix sockets, socket activation, inetd mode to Tokio-based projects

rumqttd

high performance MQTT broker written in Rust which is light weight and embeddable

ipinfo

ipinfo: A Rust library for IPInfo

routecore

Building Blocks for BGP Routing

ndisapi

interacting with the Windows Packet Filter driver (NDISAPI)

pantheon-probe

Pantheon Probe is a versatile network diagnostics tool designed for measuring latency, packet loss, jitter, and bandwidth

bach

Discrete-event simulation environment for async workflows

aralez

Reverse proxy built on top of Cloudflare's Pingora

bgpexplorer

BGP route explorer for routing information database with ability to drill-down routes change history

ralph-proto

Shared types, error definitions, and traits for Ralph Orchestrator

shadowsocks-rust

shadowsocks is a fast tunnel proxy that helps you bypass firewalls

aws-sdk-ec2

AWS SDK for Amazon Elastic Compute Cloud

reqx

Rust HTTP transport client for API SDK libraries with retry, timeout, idempotency, proxy, and pluggable TLS backends

pact-plugin-driver

Pact support library that provides an interface for interacting with Pact plugins

netlink-proto

async netlink protocol

urlx-cli

urlx — a memory-safe command-line URL transfer tool, drop-in replacement for curl

crc-catalog

Catalog of CRC algorithms (generated from http://reveng.sourceforge.net/crc-catalogue) expressed as simple Rust structs

rmcp-openapi

converting OpenAPI specifications to MCP tools

letmein

Authenticated port knocking - Client

iceoryx2-bb-system-types

iceoryx2: [internal] strong types that represents low level constructs like file, path, ip address, etc

ethercrab

A pure Rust EtherCAT MainDevice supporting std and no_std environments

rqbit

A bittorrent command line client and server

async-opcua

OPC UA client and server API

proksi

A batteries-included reverse proxy with automatic HTTPS using Cloudflare Pingora and Let's Encrypt

bacnet-server

BACnet server: APDU dispatch and service handlers

s2-common

Common stuff for client and servers for S2, the durable streams API

huddle

Terminal-native chat over a self-hosted Tor onion relay (opt-in LAN mDNS / direct dial), all Megolm end-to-end encrypted

zentinel-proxy

A security-first reverse proxy built on Pingora with sleepable ops at the edge

async-snmp

Modern async-first SNMP client library for Rust

git2-curl

Backend for an HTTP transport in libgit2 powered by libcurl. Intended to be used with the git2 crate

backhopper-core

Core types, snapshot I/O, store, and compatibility analysis for backhopper

iftoprs

Real-time bandwidth monitor — iftop clone in Rust with ratatui TUI, 31 themes, process attribution, mouse support

twirp

An async-compatible library for Twirp RPC in Rust

nitor-vault

Encrypted AWS key-value storage utility

icann-rdap-client

An RDAP client library

secure-exec-kernel

Shared kernel plane for secure-exec native and browser sidecars

hickory-server

integrating safe and secure DNS servers into an async Tokio application. It supports a variety of protocol features (DNSSEC, TSIG, SIG(0), DoT, DoQ, DoH). Servers can be operated in an authoritative…

nym-exit-policy

Get and set the Nym Exit Policy, used by Exit Gateways

ohttp

Oblivious HTTP

ruby-rbs

Rust bindings for RBS -- the type signature language for Ruby programs

astro-dnssd

& safe DNS-SD wrapper

melin-oe-gateway

FIX 4.4 order entry gateway for the Melin exchange

nanocl

Container and virtual machine orchestrator

msgtrans

Support for a variety of communication protocols such as TCP / QUIC / WebSocket, easy to create server and client network library

fvm_shared

Filecoin Virtual Machine shared types and functions

arti

Tor privacy tools

rocket-client-addr

Resolve client IP addresses in rocket from trusted proxy headers with safe socket fallback

ttl

Modern traceroute/mtr-style TUI with hop stats and optional ASN/geo enrichment

rns-core

Wire protocol, transport routing, and link/resource engine for the Reticulum Network Stack

metrics_cloudwatch_embedded

CloudWatch embedded metrics format emitter for the metrics crate

cdns-rs

A native Sync/Async Rust implementation of client DNS resolver

oxhttp

HTTP 1.1 (both client and server)

sct

Certificate transparency SCT verification library

mockbox

A Rust-based HTTP mock server with scripting capabilities using Rune

jsonrpc

Rust support for the JSON-RPC 2.0 protocol

naia-shared

Common functionality shared between naia-server & naia-client crates

mainline

robust, BitTorrent's Mainline DHT implementation

mq-bridge-app

A message queue bridge application written in Rust, designed to connect different messaging systems like RabbitMQ, Kafka, and NATS

prefix-trie

Prefix trie (tree) datastructure (both a set and a map) that provides exact and longest-prefix matches

gst-plugin-reqwest

GStreamer reqwest HTTP Source Plugin

mtu

Obtain the local network interface MTU towards a given IP address

rustls-tokio-stream

AsyncRead/AsyncWrite interface for RustTLS on Tokio

moosicbox_scan

MoosicBox scan package

velo

Velo distributed-systems runtime: active messaging, peer discovery, streaming, rendezvous, and queue backends

msb_krun

Native Rust API for libkrun microVMs

http-range-header

No-dep range header parser

binstalk-manifests

The binstall toolkit for manipulating with manifest

telemetry-rust

Open Telemetry fox Axum and Tracing

dnsglobe

Global DNS propagation checker TUI — watch a DNS record propagate across 34 public resolvers worldwide, on a world map in your terminal

qrusty

A trusty priority queue server built with Rust

rust-criu

Rust bindings for CRIU

cfn-guard-ffi

AWS CloudFormation Guard is an open-source general-purpose policy-as-code evaluation tool. It provides developers with a simple-to-use, yet powerful and expressive domain-specific language (DSL)…

moq-cli

Media over QUIC

ct-merkle

append-only log described in the Certificate Transparency specification (RFC 6962)

netip

IPv4/IPv6 network types with non-contiguous masks support

nrf-modem

Async modem api for the nRF91xx

cqrs-es

A lightweight, opinionated CQRS and event sourcing framework

zenohd

Zenoh: The Zero Overhead Pub/Sub/Query Protocol

knockknock

CLI tool for ping protocols

kcr_networking_istio_io

Kubernetes Custom Resource Bindings

rust-ethernet-ip

High-performance EtherNet/IP communication library for Allen-Bradley CompactLogix and ControlLogix PLCs

stun_codec

Encoders and decoders for STUN (RFC 5389) and its extensions

meow-tunnel

Core routing engine (TCP/UDP relay, rule dispatch, connection statistics) for the meow-rs proxy kernel

takanawa-cli

Command-line downloader using the Takanawa resumable range download engine

camgrab-cli

CLI interface for camgrab - capture, record, and monitor RTSP/ONVIF cameras

stamp-suite

Two-Way Active Measurement Protocol (STAMP)

nispor

Unified interface for Linux network state querying

async-graphql-parser

GraphQL query parser for async-graphql

kevy

kevy — a pure-Rust, zero-dependency, Redis-compatible KV server

xxpdump

The next generation of traffic capture software

spop

parsing HAProxy SPOP (Stream Processing Offload Protocol)

dtop

A terminal-based Docker container monitoring tool with real-time CPU and memory metrics

objectstore-types

Shared types for the Objectstore client and server

rpc-router

JSON RPC Router Library

ls-types

Types for the Language Server Protocol specification

domaincheck

Check domainname availability on CLI using RDAP (with WHOIS fallback)

vibeio-http

High-performance HTTP server primitives for the vibeio runtime

zerodds-rtps

DDSI-RTPS 2.5 wire stack for ZeroDDS — submessages, writer/reader state machines, reliable + fragmentation, inline QoS, ParameterList, BuiltinTopicData. Pure-Rust no_std + alloc.

wa-rs

Async Rust client for WhatsApp Web — fork of whatsapp-rust with stable Rust support

imsg

Read and send iMessages from the command line over Bluetooth MAP/PBAP — no Apple hardware required

oxvif

Async Rust client library for the ONVIF IP camera protocol

cargo-whero

A high-performance HTTP load testing tool as a cargo subcommand

kube-runtime

Kubernetes controller runtime

afterburn

cloud provider agent

aws-iot-device-sdk-rust

An easy to use SDK for connecting to AWS IoT Core

rodbus

A high-performance async implementation of the Modbus protocol using tokio

rusp

USP toolkit

gcloud-auth

Google Cloud Platform server application authentication library

qbit-rs

interacting with qBittorrent's Web API

nym-pemstore

Store private-public keypairs in PEM format

iroh-quinn

Versatile QUIC transport protocol implementation

pktana-cli

CLI binary for pktana — Linux packet analyser & network inspector

statico

A blazing-fast HTTP server implemented in Rust that serves static responses at lightning speed

proxy-twister

A flexible HTTP proxy switcher that routes traffic through different proxies (SOCKS5 or HTTP) based on target host patterns

sandlock-cli

CLI for sandlock process sandbox

freeswitch-types

FreeSWITCH ESL protocol types: channel state, events, headers, commands, and variables

openapi-forge-cli

OpenAPI Forge command-line interface

sciparse

Zero-copy SCION packet parsing, serialization and control plane components

zerofs_nfsserve

NFS Server implementation

gcloud-artifact-registry

Google Cloud Platform Artifact Registry client library

agent-desktop

CLI tool for AI agents to observe and interact with desktop UIs via accessibility APIs

axum-governor

Rate limiting middleware for Axum, powered by governor

pavao

Rust client library for SMB 2/3 based on libsmbclient

envoy-types

Collection of protobuf types and other assets to work with the Envoy Proxy through Rust gRPC services

rpki

validating and creating RPKI data

pact

Pact consolidated CLI - pact_core_mock_server, pact_verifier, pact-stub-server, pact-plugin-cli, pact-broker-cli in a single binary

actix-codec

Codec utilities for working with framed protocols

aws-smithy-runtime

The new smithy runtime crate

r-lanterm

A full-featured terminal user interface (TUI) application for managing and interacting with networked LAN devices

hardware-address

IEEE 802 MAC-48, EUI-48, EUI-64, or a 20-octet IP over InfiniBand link-layer addresses and more

smb2

Pure-Rust SMB2/3 client library with pipelined I/O

adk-gemini

Rust client for Google Gemini API

serf

A decentralized solution for service discovery and orchestration that is lightweight, highly available, and fault tolerant

google-calendar3

A complete library to interact with calendar (protocol v3)

ice-tool

CLI for managing cloud VM instances and marketplace offers

rvoip-media-core

Media processing and codec support for the rvoip stack